Reconstruction/tauEvent/tauEvent/TauJet.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef TAU_ANALYSIS_H
#define TAU_ANALYSIS_H
 
#include <bitset>
 
#include "CLHEP/Vector/LorentzVector.h"
#include "ParticleEvent/ParticleImpl.h"
#include "AthLinks/ElementLinkVector.h"
#include "FourMom/Lib/P4ImplEEtaPhiM.h"
#include "Particle/TrackParticleContainer.h"
#include "CaloEvent/CaloClusterContainer.h"
#include "JetEvent/JetCollection.h"
 
#include "tauEvent/TauJetParameters.h"
#include "tauEvent/TauPID.h"
#include "tauEvent/TauDetailsContainer.h"
#include "tauEvent/Tau1P3PDetails.h"
#include "tauEvent/Tau1P3PExtraDetails.h"
#include "tauEvent/TauRecDetails.h"
#include "tauEvent/TauRecExtraDetails.h"
#include "tauEvent/TauCommonDetails.h"
#include "tauEvent/TauCommonExtraDetails.h"
 
//forward declaration to store link to PanTauSeed
//this connects the TauJet to PanTauSeed and vice versa
namespace PanTau {
  class PanTauSeed;
}
 
namespace Analysis
{
    typedef NavigableTerminalNode TauJetNavigation;
 
    class TauJet: public ParticleImpl<
                  ::Analysis::TauJetNavigation, // not really a terminal node: done here
                  ::P4ImplEEtaPhiM
                                  >
    {
        // Public typedefs:
        public: 
            //-----------------------------------------------------------------
            // for readability and lazy people
            typedef ParticleImpl< ::Analysis::TauJetNavigation,
                    ::P4ImplEEtaPhiM
                        > TauJetImpl_t;
            typedef TauJetImpl_t::navigable_type navigable_type;
            typedef TauJetImpl_t::momentum_type  momentum_type;
            typedef TauJetImpl_t::particle_type  particle_type;
 
            //-----------------------------------------------------------------
 
            TauJet();
 
            TauJet( TauJetParameters :: Author author );
 
            TauJet( const TauJet &rhs );
 
            virtual ~TauJet();
 
            friend std::ostream& operator<< (
                    std::ostream& o, const TauJet& tau);
 
            friend std::ostream& operator<< (
                    std::ostream& o, const TauJet* tau);
 
            friend MsgStream& operator<< (
                    MsgStream& o, const TauJet& tau);
 
            friend MsgStream& operator<< (
                    MsgStream& o, const TauJet* tau);
 
            TauJet &operator = ( const TauJet &rhs );
 
            bool operator==( const TauJet& rhs ) const ;
 
            bool operator!=( const TauJet& rhs ) const;
 
 
            //-----------------------------------------------------------------
 
 
            virtual void fillToken(
                    INavigationToken &thisToken ) const;
 
            virtual void fillToken(
                    INavigationToken &thisToken,
                    const std::any& ) const;
 
            double parameter( TauJetParameters :: Detail detail ) const;
 
 
 
            const CaloCluster *cluster() const;
 
            const ElementLink<CaloClusterContainer> clusterLink() const;
 
            ElementLink<CaloClusterContainer> &clusterLink();
 
            void setCluster(
                    const CaloClusterContainer *cont,
                    const CaloCluster *clust );
 
            void setClusterLink(
                    const ElementLink<CaloClusterContainer> &x );
 
            const CaloCluster *cellCluster() const;
 
            const ElementLink<CaloClusterContainer> cellClusterLink() const;
 
            ElementLink<CaloClusterContainer> &cellClusterLink();
 
            void setCellCluster(
                    const CaloClusterContainer *cont,
                    const CaloCluster *clust );
 
            void setCellClusterLink(
                    const ElementLink<CaloClusterContainer> &x );
 
 
 
            const Jet *jet() const;
 
            const ElementLink<JetCollection> jetLink() const;
 
            ElementLink<JetCollection> &jetLink();
 
            void setJet(
                    const JetCollection *cont,
                    const Jet *clust );
 
            void setJetLink( const ElementLink<JetCollection> &x );
 
 
 
            const Rec :: TrackParticle *track( unsigned int i ) const;
 
            unsigned int numTrack() const;
 
            const ElementLinkVector<Rec::TrackParticleContainer>&
                trackLinkVector() const;
 
            ElementLinkVector<Rec::TrackParticleContainer>&
                trackLinkVector();
 
            void addTrack( const Rec::TrackParticleContainer *cont,
                    const Rec::TrackParticle *track );
 
            void clearTracks();
 
 
 
            const Rec :: TrackParticle *conversionTrack(
                    unsigned int i ) const;
 
            unsigned int numConversionTrack() const;
 
            const ElementLinkVector<Rec::TrackParticleContainer>&
                conversionTrackLinkVector() const;
 
            ElementLinkVector<Rec::TrackParticleContainer>&
                conversionTrackLinkVector();
 
            void addConversionTrack(
                    const Rec::TrackParticleContainer *cont,
                    const Rec::TrackParticle *track );
 
            void clearConversionTracks();
 
 
 
 
            const Rec :: TrackParticle *seedCalo_track( unsigned int i ) const;
 
            unsigned int seedCalo_numTrack() const;
 
            const ElementLinkVector<Rec::TrackParticleContainer>&
                seedCalo_trackLinkVector() const;
 
            ElementLinkVector<Rec::TrackParticleContainer>&
                seedCalo_trackLinkVector();
 
            void addSeedCalo_track( const Rec::TrackParticleContainer *cont,
                    const Rec::TrackParticle *track );
 
            void clearSeedCalo_tracks();
            
            
 
 
            const Rec :: TrackParticle *seedTrk_track( unsigned int i ) const;
 
            unsigned int seedTrk_numTrack() const;
 
            const ElementLinkVector<Rec::TrackParticleContainer>&
                seedTrk_trackLinkVector() const;
 
            ElementLinkVector<Rec::TrackParticleContainer>&
                seedTrk_trackLinkVector();
 
            void addSeedTrk_track( const Rec::TrackParticleContainer *cont,
                    const Rec::TrackParticle *track );
 
            void clearSeedTrk_tracks();
 
 
            int nProng() const;
 
            bool isConversionTrack( unsigned int i ) const;
 
 
 
            const TauPID *tauID() const;
 
            TauPID *tauID();
 
            void setTauID( TauPID *tauID );
 
 
 
            void addDetails(
                    const TauDetailsContainer *container,
                    TauDetails *details );
 
            void removeDetails(
                    const std::string &name,
                    const std::string& className = "" );
 
            void removeDetails(
                    int i );
 
            template <typename T>
                const T *details(
                        const std::string &name ) const;
 
            template <typename T>
                const T *details() const;
 
            const TauDetails* detail (const std::string& className,
                    const std::string& name = "") const;
 
            const TauDetails* detail (
                    int i) const;
 
            const ElementLink<TauDetailsContainer> detailElementLink (
                    int i) const;   
 
            std::string detailName (
                    int i) const;
 
            int nDetails() const;
 
            void CleanDetailsForAOD();
 
            ElementLinkVector<TauDetailsContainer>& tauDetailLinkVector();
            const ElementLinkVector<TauDetailsContainer>& tauDetailLinkVector() const;
 
 
 
            TauJetParameters :: Author author() const;
 
            bool hasAuthor(
                    const TauJetParameters :: Author &author ) const;
 
            void setAuthor(
                    const TauJetParameters :: Author &author );
 
            void clearAuthor(
                    const TauJetParameters :: Author &author );
 
 
 
            unsigned int numberOfTracks() const;
 
            void setNumberOfTracks(
                    unsigned int numberOfTracks );
 
 
 
            void setROIWord( unsigned int RoiWord );
 
            unsigned int ROIWord() const;
 
 
 
            void setE( double ene );
 
            void setEta( double eta );
 
            void setPhi( double phi );
 
            void setM( double m );
 
 
 
            void MergeToCommonDetails(
                    TauDetailsContainer* tauDetailsContainer = 0 , 
                    TauDetailsContainer* tauExtraDetailsContainer = 0);
 
 
            //         void MergeToCommonDetails();  // used for transient only
            //        void MergeToCommonDetails( TauDetailsContainer* tauDetailsContainer); // used for AODs or data without extra details
 
            bool hasMergedToCommonDetails() const;
 
            void setHasMergedToCommonDetails(
                    bool state);
 
 
            std::string toString() const;
 
 
            void storeHLV( TauJetParameters :: TauCalibType type, CLHEP :: HepLorentzVector hlv );
            CLHEP::HepLorentzVector getHLV( TauJetParameters :: TauCalibType type ) const;
            void clearHLV();
 
            std::vector<PanTau::PanTauSeed*> getListOfPanTauSeeds() const;                        
                                                                                                 
            void addPanTauSeed(PanTau::PanTauSeed* pantauSeed);     
 
        protected:
            template <class stream>
                void printOn(stream& o) const;
 
        private:
            //   ------------------------------------------------------------
 
 
            void CopyToCommonDetails(
                    const Tau1P3PDetails *tau1P3PDetails,
                    TauCommonDetails *tauCommonDetails);
 
            void CopyToCommonDetails(
                    const TauRecDetails *tauRecDetails,
                    TauCommonDetails *tauCommonDetails);
 
            void CopyToCommonDetails(
                    const Tau1P3PExtraDetails *tau1P3PExtraDetails,
                    TauCommonExtraDetails *tauCommonExtraDetails);
 
            void CopyToCommonDetails(
                    const TauRecExtraDetails *tauRecExtraDetails,
                    TauCommonExtraDetails *tauCommonExtraDetails);
 
 
            ElementLinkVector<Rec::TrackParticleContainer> m_tracks;
 
            ElementLinkVector<Rec::TrackParticleContainer> m_conversionTracks;
 
            ElementLinkVector<Rec::TrackParticleContainer> m_seedCalo_tracks;
          
            ElementLinkVector<Rec::TrackParticleContainer> m_seedTrk_tracks;
 
            ElementLinkVector<TauDetailsContainer> m_tauDetails;
 
            ElementLink<CaloClusterContainer> m_cluster;
 
            ElementLink<CaloClusterContainer> m_cellCluster;
 
            ElementLink<JetCollection> m_jet;
 
            std::bitset<8> m_author;
 
            unsigned int m_numberOfTracks;
 
            //Tau particle ID info
            TauPID *m_tauID;
 
            unsigned int m_roiWord;
 
            bool m_hasMergedToCommonDetails;
 
            std::vector<std::pair< TauJetParameters::TauCalibType, CLHEP::HepLorentzVector > > m_tauHLVStorage;
 
            std::vector<PanTau::PanTauSeed*> m_listOfPanTauSeeds;
 
    }; //Class TauJet
 
    template <class stream>
    void TauJet::printOn(stream& o) const
    {
        o << "TauJet {"
            << "tracks: {";
        for(ElementLinkVector<Rec::TrackParticleContainer>::const_iterator itrk
                = m_tracks.begin(); itrk!=m_tracks.end(); ++itrk)
            o << *(*itrk) << " ";
        o << "};\n"
            << "conversionTracks: {";
        for(ElementLinkVector<Rec::TrackParticleContainer>::const_iterator itrk
                = m_conversionTracks.begin(); 
                itrk!=m_conversionTracks.end(); ++itrk)
            o << *(*itrk) << " ";
        o << "};\n"
            << "tauDetails: {";
        for(ElementLinkVector<TauDetailsContainer>::const_iterator idetail
                = m_tauDetails.begin(); idetail!=m_tauDetails.end(); ++idetail)
            if ((*idetail).isValid())
                o << *(*idetail) << " ";
        o << "};\n"
            //not m_cluster
            //not m_cellCluster
            //not m_jet
            << "author: " << m_author << ";\n"
            << "numberOfTracks: " << m_numberOfTracks <<";\n"
            //not m_tauID
            << "roiWord: " << m_roiWord << ";\n"
            << "hasMergedToCommonDetails: " << m_hasMergedToCommonDetails << ";\n"
            << "};";
    }
 
    inline std::ostream& operator<<(
            std::ostream& o, const TauJet& tau)
    {
        tau.printOn(o);
        return o;
    }   
 
    inline std::ostream& operator<<(
            std::ostream& o, const TauJet* tau)
    {
        tau->printOn(o);
        return o;
    }  
 
    inline MsgStream& operator<<(
            MsgStream& o, const TauJet& tau)
    {
        tau.printOn(o);
        return o;
    }   
 
    inline MsgStream& operator<<(
            MsgStream& o, const TauJet* tau)
    {
        tau->printOn(o);
        return o;
    }  
 
} //Namespace analysis
 
#include "TauJet.icc"
 
#endif // TAU_ANALYSIS_H