tauAnalysisHelperObject.h

Go to the documentation of this file.

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

 
 
#ifndef TAUREC_TAUANALYSISHELPEROBJECT_H
#define TAUREC_TAUANALYSISHELPEROBJECT_H
 
#include "Particle/TrackParticle.h"
#include "Particle/TrackParticleContainer.h"
 
#include "AthLinks/ElementLink.h"
#include "AthLinks/ElementLinkVector.h"
 
#include "CaloEvent/CaloCell.h"
#include "CaloEvent/CaloCellContainer.h"
 
#include "EventKernel/I4Momentum.h"
 
#include "FourMom/P4EEtaPhiM.h"
 
#include <vector>
#include <sys/types.h>

class tauAnalysisHelperObject
{
    public:
        // element links
        typedef ElementLink<Rec::TrackParticleContainer>           tauTrack_type;
        typedef ElementLinkVector<Rec::TrackParticleContainer>     tauTrackColl_type;
        typedef tauTrackColl_type::iterator                        tauTrackColl_iterator;
 
        typedef ElementLink<CaloCellContainer>                     tauCell_type;
        typedef ElementLinkVector<CaloCellContainer>               tauCellColl_type;
        typedef tauCellColl_type::iterator                         tauCellColl_iterator;
 
        tauAnalysisHelperObject() = default;
        ~tauAnalysisHelperObject() = default;


        int jettype() const                                 { return m_jettype; }

        double decmode() const                              { return m_decmode; };
 
 
        //   -- set Analysis Helper --
        void setJettype( const int jettype )                { m_jettype = jettype; }
        void setDecmode( const int decmode )                { m_decmode = decmode; };
 


        double TowEMRadius() const                           { return m_TowEMRadius; }

        double TowIsoFrac() const                             { return m_TowET12Frac; }

        double EMRadii( const int idx ) const               { return m_emradii[idx]; };

        double HADRadii( const int idx ) const              { return m_hadradii[idx]; };
 
 
        //   -- set FastShower Analysis Helper --
        void setTowEMRadius(const double rad)               { m_TowEMRadius = rad; }
        void setTowIsoFrac(const double frac)                { m_TowET12Frac = frac; }
        void setEMRadii( const int idx, const double rad )  { m_emradii[idx] = rad; };
        void setHADRadii( const int idx, const double rad ) { m_hadradii[idx] = rad; };
 


        double RawImpactParameter( const int track ) const { return m_RawImpactParameter[track]; }
        double ImpactParameter( const int track ) const  { return m_ImpactParameter[track]; }
        double SignedImpactParameter( const int track ) const  { return m_SignedImpactParameter[track]; }
        double ImpactParameterSignificance( const int track ) const  { return m_ImpactParameterSignificance[track]; }
        double SignedImpactParameterSignificance( const int track ) const  { return m_SignedImpactParameterSignificance[track]; }
 
 
        //   -- set Impact Parameter Analysis Helper --
        void setImpactParameter( const int track, const double ip ) { if ( track < 10 ) m_ImpactParameter[track] = ip; }
        void setRawImpactParameter( const int track, const double ip ) { if ( track < 10 ) m_RawImpactParameter[track] = ip; }
        void setSignedImpactParameter( const int track, const double ip ) { if ( track < 10 ) m_SignedImpactParameter[track] = ip; }
        void setImpactParameterSignificance( const int track, const double ip ) { if ( track < 10 ) m_ImpactParameterSignificance[track] = ip; }
        void setSignedImpactParameterSignificance( const int track, const double ip ) { if ( track < 10 ) m_SignedImpactParameterSignificance[track] = ip; }
 


        double d0prf() { return m_d0prf; };

        double d0iso() { return m_d0iso; };

        double d0isoet() { return m_d0isoet; };

        double d0ettr() { return m_d0ettr; };

        double d0etem() { return m_d0etem; };

        double d0etem2() { return m_d0etem2; };
 

        double d0emclet() { return m_d0emclet; };

        double d0emcleta() { return m_d0emcleta; };

        double d0emclphi() { return m_d0emclphi; };
 

        double d0hadet() { return m_d0hadet; };

        double d0hadeta() { return m_d0hadeta; };

        double d0hadphi() { return m_d0hadphi; };
 

        double d0et05() { return m_d0et05; };

        double d0eta05() { return m_d0eta05; };

        double d0phi05() { return m_d0phi05; };
 

        double d0type() { return m_d0type; };

        double d0deltaR1() { return m_d0deltaR1; };

        double d0eTosumpT() { return m_d0eTosumpT; };
 

        double d0deltaR1had() { return m_d0deltaR1had; };

        double d0em3iso() { return m_d0em3iso; };

        double d0mtrem3() { return m_d0mtrem3; };
 

        double d0deltaR2() { return m_d0deltaR2; };

        double d0ntr1030() { return m_d0ntr1030; };
 

        double d0EM12isof() { return m_d0EM12isof; };

        double d0e1e2otaupT() { return m_d0e1e2otaupT; };

        double d0ettro123() { return m_d0ettro123; };

        double d0ett1oEtiso() { return m_d0ett1oEtiso; };

        double d0ett1oEtisoet() { return m_d0ett1oEtisoet; };

        double d0dalpha() { return m_d0dalpha; }

        double d0e1e2() { return m_d0e1e2; };

        double d0mtau() { return m_d0dalpha*m_d0e1e2; };

        double d0mtr1tr2() { return m_d0mtr1tr2; };

        double d0mtr1tr2tr3() { return m_d0mtr1tr2tr3; };
 

        double d0sumtaupt() { return m_d0sumtaupt; };

        double d0sumnontaupt() { return m_d0sumnontaupt; };

        double d0sumpt() { return m_d0sumpt; };

        I4Momentum* d0tower( int i ) { return new P4EEtaPhiM( m_towere[i], m_towereta[i], m_towerphi[i], 0.0 ); };

        double d0toweret( int i ) { return m_towere[i]/cosh( m_towereta[i] ); };

        int d0nTowers() { return m_towere.size(); };
        //   -- set D0 variables --

        double d0sumtoweret() { double sumet = 0; for ( int i = 0; i < d0nTowers(); i++ ) sumet += d0toweret(i); return sumet; };

        double d0uncaletlayers( int l ) { return m_d0uncaletlayers[l]; };
 
        void setD0prf( double val ) { m_d0prf = val; };
        void setD0iso( double val ) { m_d0iso = val; };
        void setD0isoet( double val ) { m_d0isoet = val; };
        void setD0ettr( double val ) { m_d0ettr = val; };
        void setD0etem( double val ) { m_d0etem = val; };
        void setD0etem2( double val ) { m_d0etem2 = val; };
 
        void setD0emclet( double val ) { m_d0emclet = val; };
        void setD0emcleta( double val ) { m_d0emcleta = val; };
        void setD0emclphi( double val ) { m_d0emclphi = val; };
 
        void setD0hadet( double val ) { m_d0hadet = val; };
        void setD0hadeta( double val ) { m_d0hadeta = val; };
        void setD0hadphi( double val ) { m_d0hadphi = val; };
 
        void setD0et05( double val ) { m_d0et05 = val; };
        void setD0eta05( double val ) { m_d0eta05 = val; };
        void setD0phi05( double val ) { m_d0phi05 = val; };
 
        void setD0type( double val  ) { m_d0type = val; };
        void setD0deltaR1( double val  ) { m_d0deltaR1 = val; };
        void setD0eTosumpT( double val  ) { m_d0eTosumpT = val; };
 
        void setD0deltaRhad( double val  ) { m_d0deltaR1had = val; };
        void setD0em3iso( double val  ) { m_d0em3iso = val; };
        void setD0mtrem3( double val  ) { m_d0mtrem3 = val; };
 
        void setD0deltaR2( double  val ) { m_d0deltaR2 = val; };
        void setD0ntr1030( double val  ) { m_d0ntr1030 = val; };
 
        void setD0EM12isof( double val  ) { m_d0EM12isof = val; };
        void setD0e1e2otaupT( double val  ) { m_d0e1e2otaupT = val; };
        void setD0ettro123( double val  ) { m_d0ettro123 = val; };
        void setD0ett1oEtiso( double  val ) { m_d0ett1oEtiso = val; };
        void setD0ett1oEtisoet( double  val ) { m_d0ett1oEtisoet = val; };
        void setD0dalpha( double val  ) { m_d0dalpha = val; }
        void setD0e1e2( double  val ) { m_d0e1e2 = val; };
 
        void setD0mtr1tr2( double  val ) { m_d0mtr1tr2 = val; };
        void setD0mtr1tr2tr3( double  val ) { m_d0mtr1tr2tr3 = val; };
 
        void setD0sumtaupt( double  val ) { m_d0sumtaupt = val; };
        void setD0sumnontaupt( double  val ) { m_d0sumnontaupt = val; };
        void setD0sumpt( double  val ) { m_d0sumpt = val; };
 
        void clearD0towers() {
          m_towere.clear();
          m_towereta.clear();
          m_towerphi.clear();
        }
        void addD0tower( const double e, const double eta, const double phi ) { m_towere.push_back( e ); m_towereta.push_back( eta ); m_towerphi.push_back( phi ); };
        void addD0tower( const I4Momentum *mom ) { m_towere.push_back( mom->e() ); m_towereta.push_back( mom->eta() ); m_towerphi.push_back( mom->phi() ); };
 
        void setD0uncaletlayers( int l, double val ) { m_d0uncaletlayers[l] = val; };
 

        tauCellColl_type&  d0_emcluster() { return m_d0_emcluster; }
        const tauCellColl_type&  d0_emcluster() const { return m_d0_emcluster; }
        int d0_emcluster_nCells() const                     { return m_d0_emcluster.size(); }
        tauCellColl_iterator d0_emcluster_begin()      { return m_d0_emcluster.begin(); }
        tauCellColl_iterator d0_emcluste_end()         { return m_d0_emcluster.end(); }
 
        const CaloCell* d0_emcluster_cell( uint i) const   { return *m_d0_emcluster[i]; }
 
        //   -- add cells to emcluster --
        void d0_emcluster_addCell(const CaloCellContainer* cellContainer, const CaloCell* theCell) {
            tauCell_type theLink;
            theLink.toContainedElement( *cellContainer, static_cast<const CaloCell*> (theCell) );
            m_d0_emcluster.push_back(theLink);
        }


        int d0_05_nTracks() const                                   { return m_d0_05_Tracks.size(); }
        tauTrackColl_type&  d0_05_tracks() { return m_d0_05_Tracks; }
        const tauTrackColl_type&  d0_05_tracks() const { return m_d0_05_Tracks; }
        tauTrackColl_iterator d0_05_track_begin()              { return m_d0_05_Tracks.begin(); }
        tauTrackColl_iterator d0_05_track_end()                { return m_d0_05_Tracks.end(); }
 
        const Rec::TrackParticle* d0_05_track( uint i) const   { return *m_d0_05_Tracks[i]; }
 
        //   -- add Tracks --
        void d0_05_addTrack(const Rec::TrackParticleContainer* trackContainer, const Rec::TrackParticle* theTrack) {
            tauTrack_type theLink;
            theLink.toContainedElement( *trackContainer, static_cast<const Rec::TrackParticle*> (theTrack) );
            m_d0_05_Tracks.push_back(theLink);
        }


        int d0_tau_nTracks() const                                     { return m_d0_tau_Tracks.size(); }
        tauTrackColl_type&  d0_tau_tracks() { return m_d0_tau_Tracks; }
        const tauTrackColl_type&  d0_tau_tracks() const { return m_d0_tau_Tracks; }
        tauTrackColl_iterator d0_tau_track_begin()              { return m_d0_tau_Tracks.begin(); }
        tauTrackColl_iterator d0_tau_track_end()                { return m_d0_tau_Tracks.end(); }
 
        const Rec::TrackParticle* d0_tau_track( uint i) const   { return *m_d0_tau_Tracks[i]; }
 
        //   -- add Tracks --
        void d0_tau_addTrack(const Rec::TrackParticleContainer* trackContainer, const Rec::TrackParticle* theTrack) {
            tauTrack_type theLink;
            theLink.toContainedElement( *trackContainer, static_cast<const Rec::TrackParticle*>( theTrack) );
            m_d0_tau_Tracks.push_back(theLink);
        }


        int d0_nontau_nTracks() const                                   { return m_d0_nontau_Tracks.size(); }
        tauTrackColl_type&  d0_nontau_tracks() { return m_d0_nontau_Tracks; }
        const tauTrackColl_type&  d0_nontau_tracks() const { return m_d0_nontau_Tracks; }
        tauTrackColl_iterator d0_nontau_track_begin()              { return m_d0_nontau_Tracks.begin(); }
        tauTrackColl_iterator d0_nontau_track_end()                { return m_d0_tau_Tracks.end(); }
 
        const Rec::TrackParticle* d0_nontau_track( uint i) const   { return *m_d0_nontau_Tracks[i]; }
 
        //   -- add Tracks --
        void d0_nontau_addTrack(const Rec::TrackParticleContainer* trackContainer, const Rec::TrackParticle* theTrack) {
            tauTrack_type theLink;
            theLink.toContainedElement( *trackContainer, static_cast<const Rec::TrackParticle*> (theTrack) );
            m_d0_nontau_Tracks.push_back(theLink);
        }

 
    protected:
        int    m_decmode=-1;
        int    m_jettype=-1;
 
        double m_emradii[6]={0};
        double m_hadradii[6]={0};
        double m_TowEMRadius=-1111;
        double m_TowET12Frac=-1111;
 
        double m_ImpactParameter[10]={0};
        double m_RawImpactParameter[10]={0};
        double m_SignedImpactParameter[10]={0};
        double m_ImpactParameterSignificance[10]={0};
        double m_SignedImpactParameterSignificance[10]={0};
 
        // d0 variables
        double m_d0prf=-1111;
        double m_d0iso=-1111;
        double m_d0isoet=-1111;
        double m_d0ettr=-1111;
        double m_d0etem=-1111;
        double m_d0etem2=-1111;
        double m_d0emclet=-1111;
        double m_d0emcleta=-1111;
        double m_d0emclphi=-1111;
        double m_d0et05=-1111;
        double m_d0eta05=-1111;
        double m_d0phi05=-1111;
 
        double m_d0hadet=-1111;
        double m_d0hadeta=-1111;
        double m_d0hadphi=-1111;
 
        double m_d0type=-1111;
        double m_d0deltaR1=-1111;
        double m_d0eTosumpT=-1111;
 
        double m_d0deltaR1had=-1111;
        double m_d0em3iso=-1111;
        double m_d0mtrem3=-1111;
 
        double m_d0deltaR2=-1111;
        double m_d0ntr1030=-1111;
 
        double m_d0EM12isof=-1111;
        double m_d0e1e2otaupT=-1111;
        double m_d0ettro123=-1111;
        double m_d0ett1oEtiso=-1111;
        double m_d0ett1oEtisoet=-1111;
        double m_d0dalpha=-1111;
        double m_d0e1e2=-1111;
 
        double m_d0mtr1tr2=-1111;
        double m_d0mtr1tr2tr3=-1111;
 
        double m_d0sumtaupt=-1111;
        double m_d0sumnontaupt=-1111;
        double m_d0sumpt=-1111;
 
        std::vector<double> m_towere;
        std::vector<double> m_towereta;
        std::vector<double> m_towerphi;
 
        double m_d0uncaletlayers[25]={0};
 
        tauCellColl_type m_d0_emcluster;
 
        tauTrackColl_type m_d0_05_Tracks;
        tauTrackColl_type m_d0_tau_Tracks;
        tauTrackColl_type m_d0_nontau_Tracks;
};
 
 
#endif