Reconstruction/tauEvent/tauEvent/TauJet.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 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();

            const 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