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