TauCommonDetails.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/

 
#ifndef TAUEVENT_TAUCOMMONDETAILS_H
#define TAUEVENT_TAUCOMMONDETAILS_H
 
//TauEvent includes
#include "TauDetails.h"
//Other inlcudes
#include "CLHEP/Vector/LorentzVector.h"
#include "CaloEvent/CaloClusterContainer.h"
#include "AthLinks/ElementLink.h"
#include "AthLinks/ElementLinkVector.h"
#include "Particle/TrackParticleContainer.h"
//Standard C/C++ includes
#include <string>
//Predclarations
 
namespace Analysis {

    class TauCommonDetails : public TauDetails {
        friend class TauCommonDetailsCnv_p1;
        friend class TauJet;
        public:
        //-----------------------------------------------------------------
        // Constructors, destructor, operators
        //-----------------------------------------------------------------

        TauCommonDetails();

        TauCommonDetails(
                const TauCommonDetails& rhs );

        virtual ~TauCommonDetails();

        TauCommonDetails& operator = (
                const TauCommonDetails& rhs );

        bool operator==( const TauCommonDetails& rhs ) const;

        bool operator!=( const TauCommonDetails& rhs ) const;

        virtual const std::string& className() const;

        // Private member accessors
 
        //
        // Common for track and calo seeded tau reconstruction
        //
 
        //  ---------------------------------------------------------------


        double ipZ0SinThetaSigLeadTrk() const;

        void setIpZ0SinThetaSigLeadTrk(
                double significance);




        double etOverPtLeadTrk() const;

        void setEtOverPtLeadTrk(
                double ratio );




        double leadTrkPt() const;

        void setLeadTrkPt(
                double pt );




        const Rec::TrackParticle *looseTrk(
                unsigned int i) const;

        const ElementLinkVector<Rec::TrackParticleContainer>& looseTrk() const;

        ElementLinkVector<Rec::TrackParticleContainer>& looseTrk();

        void addLooseTrk(
                const Rec::TrackParticleContainer *cont,
                const Rec::TrackParticle *track );

        unsigned int nLooseTrk() const;
 




        const Rec::TrackParticle *looseConvTrk(
                unsigned int i) const;

        const ElementLinkVector<Rec::TrackParticleContainer>& looseConvTrk() const;

        ElementLinkVector<Rec::TrackParticleContainer>& looseConvTrk();

        void addLooseConvTrk(
                const Rec::TrackParticleContainer *cont,
                const Rec::TrackParticle *track );

        unsigned int nLooseConvTrk() const;

        int nProngLoose() const;

        bool isLooseConvTrk( unsigned int i ) const;
 




        const Rec::TrackParticle *seedCalo_wideTrk(
                unsigned int i) const;

        const ElementLinkVector<Rec::TrackParticleContainer>& seedCalo_wideTrk() const;

        ElementLinkVector<Rec::TrackParticleContainer>& seedCalo_wideTrk();

        void addSeedCalo_wideTrk(
                const Rec::TrackParticleContainer *cont,
                const Rec::TrackParticle *track );

        unsigned int seedCalo_nWideTrk() const;
 




        const Rec::TrackParticle *seedTrk_wideTrk(
                unsigned int i) const;

        const ElementLinkVector<Rec::TrackParticleContainer>& seedTrk_wideTrk() const;

        ElementLinkVector<Rec::TrackParticleContainer>& seedTrk_wideTrk();

        void addSeedTrk_wideTrk(
                const Rec::TrackParticleContainer *cont,
                const Rec::TrackParticle *track );

        unsigned int seedTrk_nWideTrk() const;




        const Rec::TrackParticle *otherTrk(
                unsigned int i) const;

        const ElementLinkVector<Rec::TrackParticleContainer>& otherTrk() const;

        ElementLinkVector<Rec::TrackParticleContainer>& otherTrk();

        void addOtherTrk(
                const Rec::TrackParticleContainer *cont,
                const Rec::TrackParticle *track );

        unsigned int nOtherTrk() const;        
 
 




        double ipSigLeadTrk() const;

        void setIpSigLeadTrk(
                double significance );




        double ipSigLeadLooseTrk() const;

        void setIpSigLeadLooseTrk(
                double significance );




        double etOverPtLeadLooseTrk() const;

        void setEtOverPtLeadLooseTrk(
                double ratio );




        double leadLooseTrkPt() const;

        void setLeadLooseTrkPt(
                double pT );




        double chrgLooseTrk() const;

        void setChrgLooseTrk(
                double charge );




        double massTrkSys() const;

        void setMassTrkSys(
                double mass );




        double trkWidth2() const;

        void setTrkWidth2(
                double trkWidth2 );




        const CaloCluster *cellEM012Cluster() const;

        void setCellEM012Cluster(
                const CaloClusterContainer *cont,
                const CaloCluster *clust );

        const ElementLink<CaloClusterContainer>& cellEM012ClusterLink() const;

        ElementLink<CaloClusterContainer>& cellEM012ClusterLink();

        void setCellEM012ClusterLink(
                const ElementLink<CaloClusterContainer> &x );




        double trFlightPathSig() const;

        void setTrFlightPathSig(
                double significance );




        const CLHEP::HepLorentzVector &sumPi0Vec() const;

        void setSumPi0Vec(
                const CLHEP::HepLorentzVector &sumPi0Vec );




        const Trk::RecVertex* secVtx() const;

        void setSecVtx(
                const Trk::RecVertex* secVtx );




        double etEflow() const;

        void setEtEflow(
                double et );




        double mEflow() const;

        void setMEflow(
                double m );




        const CaloCluster* pi0(
                unsigned int i ) const;

        const ElementLinkVector<CaloClusterContainer>& pi0LinkVec() const;

        ElementLinkVector<CaloClusterContainer>& pi0LinkVec();

        unsigned int nPi0() const;

        void addPi0(
                const CaloCluster *pi0,
                const CaloClusterContainer *cont );
 
 


        double ele_E237E277() const;

        void setEle_E237E277( double value );

        double ele_PresamplerFraction() const;

        void setEle_PresamplerFraction( double value );

        double ele_ECALFirstFraction() const;

        void setEle_ECALFirstFraction( double value );
 
 
 
        //name accessors for topocluster ID variables

        unsigned int numCells() const;

        void setNumCells(unsigned int value);

        unsigned int numTopoClusters() const;

        void setNumTopoClusters(unsigned int value);

        double numEffTopoClusters() const;

        void setNumEffTopoClusters(double value);

        double topoInvMass() const;

        void setTopoInvMass(double value);

        double effTopoInvMass() const;

        void setEffTopoInvMass(double value);
 

        double topoMeanDeltaR() const;

        void setTopoMeanDeltaR(double value);

        double effTopoMeanDeltaR() const;

        void setEffTopoMeanDeltaR(double value);
 
 
 

        //
        // Applicable for calo seeded tau reconstruction
        //




        double seedCalo_EMRadius() const;

        void setSeedCalo_EMRadius(
                double EMRadius);




        double seedCalo_hadRadius() const;

        void setSeedCalo_hadRadius(
                double hadRadius);




        double seedCalo_etEMAtEMScale() const;

        void setSeedCalo_etEMAtEMScale(
                double energy);




        double seedCalo_etHadAtEMScale() const;

        void setSeedCalo_etHadAtEMScale( double energy );




        double seedCalo_isolFrac() const;

        void setSeedCalo_isolFrac(
                double isolFrac);




        double seedCalo_centFrac() const;

        void setSeedCalo_centFrac(
                double centFrac);




        double seedCalo_stripWidth2() const;

        void setSeedCalo_stripWidth2(
                double stripWidth2 );




        int seedCalo_nStrip() const;

        void setSeedCalo_nStrip(
                int nStrip);




        double seedCalo_etEMCalib() const;

        void setSeedCalo_etEMCalib(
                double etEMCalib );




        double seedCalo_etHadCalib() const;

        void setSeedCalo_etHadCalib(
                double etHadCalib);




        double seedCalo_eta() const;

        void setSeedCalo_eta(
                double eta);




        double seedCalo_phi() const;

        void setSeedCalo_phi(
                double phi );




        double seedCalo_nIsolLooseTrk() const;

        void setSeedCalo_nIsolLooseTrk(
                double nIsolTRk );




        double seedCalo_trkAvgDist() const;

        void setSeedCalo_trkAvgDist(
                double trkAvgDist );            




        double seedCalo_trkRmsDist() const;

        void setSeedCalo_trkRmsDist(
                double trkRmsDist );
                
        
        double seedCalo_lead2ClusterEOverAllClusterE() const;

        void setSeedCalo_lead2ClusterEOverAllClusterE( double lead2ClusterEOverAllClusterE );

        double seedCalo_lead3ClusterEOverAllClusterE() const;

        void setSeedCalo_lead3ClusterEOverAllClusterE( double lead3ClusterEOverAllClusterE );

        double seedCalo_caloIso() const;

        void setSeedCalo_caloIso( double caloIso );

        double seedCalo_caloIsoCorrected() const;

        void setSeedCalo_caloIsoCorrected( double caloIsoCorrected );

        double seedCalo_dRmax() const;

        void setSeedCalo_dRmax( double dRmax );
 
 

        //
        // Applicable for track seeded tau reconstruction
        //




        double seedTrk_EMRadius() const;

        void setSeedTrk_EMRadius(
                double EMRadius );




        double seedTrk_isolFrac() const;

        void setSeedTrk_isolFrac(
                double isolFrac );




        double seedTrk_etChrgHadOverSumTrkPt () const;

        void setSeedTrk_etChrgHadOverSumTrkPt (
                double fraction );




        double seedTrk_isolFracWide() const;

        void setSeedTrk_isolFracWide(
                double fraction );




        double seedTrk_etHadAtEMScale() const;

        void setSeedTrk_etHadAtEMScale (
                double et );




        double seedTrk_etEMAtEMScale() const;

        void setSeedTrk_etEMAtEMScale(
                double et );




        double seedTrk_etEMCL() const;

        void setSeedTrk_etEMCL(
                double et );




        double seedTrk_etChrgEM() const;

        void setSeedTrk_etChrgEM(
                double et );




        double seedTrk_etNeuEM() const;

        void setSeedTrk_etNeuEM(
                double et );




        double seedTrk_etResNeuEM() const;

        void setSeedTrk_etResNeuEM(
                double et );




        double seedTrk_hadLeakEt() const;

        void setSeedTrk_hadLeakEt(
                double et );




        double seedTrk_etChrgEM01Trk(
                unsigned int i ) const;
 
        const std::vector<double>& seedTrk_etChrgEM01TrkVector() const;

        void setSeedTrk_etChrgEM01Trk(
                unsigned int i,
                double et );
 
        template <class ITERATOR>
        void setSeedTrk_etChrgEM01Trk(
                ITERATOR beg,
                ITERATOR end);

        void addSeedTrk_etChrgEM01Trk(
                double et );




        double seedTrk_etResChrgEMTrk(
                unsigned int i ) const;
 
        const std::vector<double>& seedTrk_etResChrgEMTrkVector() const;

        void setSeedTrk_etResChrgEMTrk(
                unsigned int i,
                double et );
 
        template <class ITERATOR>
        void setSeedTrk_etResChrgEMTrk(
                ITERATOR beg,
                ITERATOR end);

        void addSeedTrk_etResChrgEMTrk(
                double et );




        double seedTrk_sumEMCellEtOverLeadTrkPt() const;

        void setSeedTrk_sumEMCellEtOverLeadTrkPt(
                double ratio );




        double seedTrk_secMaxStripEt() const;

        void setSeedTrk_secMaxStripEt(
                double et );




        double seedTrk_stripWidth2() const;

        void setSeedTrk_stripWidth2(
                double stripWidth2 );




        int seedTrk_nStrip() const;

        void setSeedTrk_nStrip(
                int nStrip );




        double seedTrk_etChrgHad() const;

        void setSeedTrk_etChrgHad(
                double et );




        int seedTrk_nOtherCoreTrk() const;

        void setSeedTrk_nOtherCoreTrk(
                int n );




        int seedTrk_nIsolTrk() const;

        void setSeedTrk_nIsolTrk(
                int n );




        double seedTrk_etIsolEM() const;

        void setSeedTrk_etIsolEM(
                double etIsolEM );




        double seedTrk_etIsolHad() const;

        void setSeedTrk_etIsolHad(
                double etIsolHad );


        //
        // Energy Scale getter/setters
        //
 

        double EM_TES_scale() const;

        void set_EM_TES_scale(double value);

        double LC_TES_precalib() const;

        void set_LC_TES_precalib(double value);
 


        //
        // Cell-based energies in rings getters/setters
        //
          double cellBasedEnergyRing1() const;
          void setCellBasedEnergyRing1(double value);
    
          double cellBasedEnergyRing2() const;
          void setCellBasedEnergyRing2(double value);

          double cellBasedEnergyRing3() const;
          void setCellBasedEnergyRing3(double value);

          double cellBasedEnergyRing4() const;
          void setCellBasedEnergyRing4(double value);

          double cellBasedEnergyRing5() const;
          void setCellBasedEnergyRing5(double value);

          double cellBasedEnergyRing6() const;
          void setCellBasedEnergyRing6(double value);

          double cellBasedEnergyRing7() const;
          void setCellBasedEnergyRing7(double value);
 

        double TRT_NHT_OVER_NLT() const;
        void setTRT_NHT_OVER_NLT(double value);


          double TauJetVtxFraction() const;
          void setTauJetVtxFraction(double value);


 
        // vector bool of which tracks pass the track filter
        const std::vector<bool>& TrackFilterPass() const;
        void setTrackFilterPass(const std::vector<bool>& value);
 
        // nProng based on what the track filter passes
        int TrackFilterProngs() const;
        void setTrackFilterProngs(int value);
 
        // flag used to ID probable fake taus by the track filter
        int TrackFilterQuality() const;
        void setTrackFilterQuality(int value);
 
        // generic cone size (dR)
        double Pi0ConeDR() const;
        void setPi0ConeDR(double value);
 
        protected:
        template <class stream>
            void printOn(stream& o) const; 
 
        private:
        static const std::string s_className;
 
        // -------------------------------------------------------------------


        double m_ipZ0SinThetaSigLeadTrk;

        double m_etOverPtLeadTrk;

        double m_etOverPtLeadLooseTrk;

        double m_leadTrkPt;

        double m_leadLooseTrkPt;

        double m_ipSigLeadTrk;

        double m_ipSigLeadLooseTrk;

        ElementLinkVector<Rec::TrackParticleContainer> m_looseTrk;

        ElementLinkVector<Rec::TrackParticleContainer> m_looseConvTrk;

        ElementLinkVector<Rec::TrackParticleContainer> m_seedCalo_wideTrk;

        ElementLinkVector<Rec::TrackParticleContainer> m_seedTrk_wideTrk;

        ElementLinkVector<Rec::TrackParticleContainer> m_otherTrk;

        double m_chrgLooseTrk;

        ElementLink<CaloClusterContainer>  m_cellEM012Cluster;

        CLHEP::HepLorentzVector m_sumPi0Vec;

        double m_massTrkSys;

        double m_trkWidth2;

        double m_trFlightPathSig;

        Trk::RecVertex* m_secVtx;

        double m_etEflow;

        double m_mEflow;

        ElementLinkVector<CaloClusterContainer> m_pi0;
 



        double m_Ele_E237E277;

        double m_Ele_PresamplerFraction;

        double m_Ele_ECALFirstFraction;



        unsigned int m_numCells;

        unsigned int m_numTopoClusters;

        double m_numEffTopoClusters;

        double m_topoInvMass;

        double m_effTopoInvMass;

        double m_topoMeanDeltaR;

        double m_effTopoMeanDeltaR;
 
 
 
 
 



        double m_seedCalo_nIsolLooseTrk;

        double m_seedCalo_EMRadius;

        double m_seedCalo_hadRadius;

        double m_seedCalo_etEMAtEMScale;

        double m_seedCalo_etHadAtEMScale;

        double m_seedCalo_isolFrac;

        double m_seedCalo_centFrac;

        double m_seedCalo_stripWidth2;

        int m_seedCalo_nStrip;

        double m_seedCalo_etEMCalib;

        double m_seedCalo_etHadCalib;

        double m_seedCalo_eta;

        double m_seedCalo_phi;

        double m_seedCalo_trkAvgDist;

        double m_seedCalo_trkRmsDist;
        
        double m_seedCalo_lead2ClusterEOverAllClusterE;

        double m_seedCalo_lead3ClusterEOverAllClusterE;
        
        double m_seedCalo_caloIso;
        
        double m_seedCalo_caloIsoCorrected;
        
        double m_seedCalo_dRmax;
 
        
        
 



        double m_seedTrk_EMRadius;

        double m_seedTrk_isolFrac;

        double m_seedTrk_etChrgHadOverSumTrkPt ;

        double m_seedTrk_isolFracWide;

        double m_seedTrk_etHadAtEMScale ;

        double m_seedTrk_etEMAtEMScale ;

        double m_seedTrk_etEMCL ;

        double m_seedTrk_etChrgEM ;

        double m_seedTrk_etNeuEM ;

        double m_seedTrk_etResNeuEM ;

        double m_seedTrk_hadLeakEt;

        std :: vector<double> m_seedTrk_etChrgEM01Trk;

        std :: vector<double> m_seedTrk_etResChrgEMTrk;

        double m_seedTrk_sumEMCellEtOverLeadTrkPt;

        double m_seedTrk_secMaxStripEt;

        double m_seedTrk_stripWidth2;

        int m_seedTrk_nStrip;

        double m_seedTrk_etChrgHad;

        int m_seedTrk_nOtherCoreTrk;

        int m_seedTrk_nIsolTrk;

        double m_seedTrk_etIsolEM;

        double m_seedTrk_etIsolHad;
        
        //
        // Energy Scale Attributes
        //
        
        double m_EM_TES_scale;

        double m_LC_TES_precalib;


    
          double m_cellBasedEnergyRing1;
    
          double m_cellBasedEnergyRing2;

          double m_cellBasedEnergyRing3;

          double m_cellBasedEnergyRing4;

          double m_cellBasedEnergyRing5;

          double m_cellBasedEnergyRing6;

          double m_cellBasedEnergyRing7;

        double m_TRT_NHT_OVER_NLT;



        double m_TauJetVtxFraction;


 
        // vector bool of which tracks pass the track filter
        std::vector<bool> m_TrackFilterPass;
 
        // nProng based on what the track filter passes
        int m_TrackFilterProngs;
 
        // flag used to ID probable fake taus by the track filter
        int m_TrackFilterQuality;
 
        // generic cone size (dR)
        double m_Pi0ConeDR;
 
    };//class TauCommonDetails
    } //Namespace Analysis
 
    // inline member function declarations
#include "TauCommonDetails.icc"
 
#endif //TAUEVENT_TAUCOMMONDETAILS_H