Trigger/TrigEvent/TrigParticle/TrigParticle/TrigElectron.h

Go to the documentation of this file.

// -*- C++ -*-
 
/*
  Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef TRIG_ELECTRON
#define TRIG_ELECTRON
 
#include <vector>
#include <iostream>
#include <string>
#include <cmath> 
 
#include "FourMom/P4PtEtaPhiM.h"
#include "Navigation/Navigable.h"
#include "EventKernel/INavigable4Momentum.h"
 
#include "AthLinks/ElementLink.h"
 
#include "TrigCaloEvent/TrigEMClusterContainer.h"
#include "TrigInDetEvent/TrigInDetTrackCollection.h"
 
class TrigElectron : public P4PtEtaPhiM,
             public NavigableTerminalNode ,
             virtual public INavigable4Momentum {
 
 public:
  
  TrigElectron();
  
  TrigElectron(unsigned int roi, 
           float trkEtaAtCalo, float trkPhiAtCalo, float EToverPT,
           const TrigEMClusterContainer* cluster, unsigned int cl_index,
           const TrigInDetTrackCollection* track, unsigned int tr_index);
 
  TrigElectron(float pt,
               float eta,
               float phi,
 
               // roi word
               unsigned int roi,
               bool valid,
 
               // track-cluster match variables
               float trkEtaAtCalo,
               float trkPhiAtCalo,
               float EToverPT,
 
               // Cluster
               const ElementLink< TrigEMClusterContainer >& cluster,
               float caloEta,
               float caloPhi,
               float Rcore,
               float Eratio,
               float EThad,
               float F0,
               float F1,
               float F2,
               float F3,
 
               // Track
               const ElementLink< TrigInDetTrackCollection >& track,
               TrigInDetTrack::AlgoId trackAlgo,
               float Zvtx,
               int nTRTHits,
               int nTRTHiThresholdHits) ;
 
  ~TrigElectron() = default;
  
  int   roiId()    const { return m_roiWord;    } 
  int   roiWord()  const { return m_roiWord;    }
 
  bool  isValid()  const { return m_valid;    }
 
  TrigInDetTrack::AlgoId trackAlgo()const { return m_tr_Algo;}
  float Zvtx()                 const { return m_tr_Zvtx;                 }
  int   nTRTHits()             const { return m_tr_nr_trt_hits;          }
  int   nTRTHiThresholdHits()  const { return m_tr_nr_trt_hithresh_hits; }
  float nTRTHiTHitsRatio()     const { return (m_tr_nr_trt_hits>0 ? (float)m_tr_nr_trt_hithresh_hits/(float)m_tr_nr_trt_hits : -1); }
 
  int trackIndx()  const { return (m_track.isValid() ? m_track.index() : 0); } 
  const TrigInDetTrackCollection* trackColl() const { return (m_track.isValid() ? m_track.getStorableObjectPointer() : NULL); } 
 
  float trkPt()        const { return (m_track.isValid() ? fabs((*m_track)->param()->pT()) : 0 ); }
 
  int charge()     const { return (m_track.isValid() ? (int)((*m_track)->param()->pT()/fabs((*m_track)->param()->pT())) : 0); } 
 
  float err_Pt()    const { return err_trkPt(); } // OBSOLETE: to be removed in next iteration 
  float err_trkPt() const { return (m_track.isValid() ? (*m_track)->param()->epT()   : -1); } 
  float err_eta()   const { return (m_track.isValid() ? (*m_track)->param()->eeta()  : -1); }
  float err_phi()   const { return (m_track.isValid() ? (*m_track)->param()->ephi0() : -1); } 
  float err_Zvtx()  const { return (m_track.isValid() ? (*m_track)->param()->ez0()   : -1); } 
 
  float trkEtaAtCalo() const { return m_tr_eta_at_calo;  }
  float trkPhiAtCalo() const { return m_tr_phi_at_calo;  }
 
  float trkClusDeta()  const { return (DeltaEta1()); } // old method name - RG 15/6/09
  float trkClusDphi()  const { return (DeltaPhi2()); } // old method name - RG 15/6/09
  float DeltaEta1()    const { return fabs(m_tr_eta_at_calo - m_cl_eta);  }
  float DeltaPhi2()    const { return (fabs(m_tr_phi_at_calo-m_cl_phi)<M_PI ? 
                       fabs(m_tr_phi_at_calo-m_cl_phi) : 
                       2*M_PI - fabs(m_tr_phi_at_calo-m_cl_phi)); }
 
  float EtOverPt() const { return m_etoverpt; }
 
  float caloEta() const { return m_cl_eta;    }
  float caloPhi() const { return m_cl_phi;    }
 
  float Rcore()   const { return m_cl_Rcore;  }    // OBSOLETE name; to be removed in next iteration
  float Reta()    const { return m_cl_Rcore;  }
  float Eratio()  const { return m_cl_Eratio; }
  float EThad()   const { return m_cl_EThad;  }    // OBSOLETE name; to be removed in next iteration
  float Ethad1()  const { return m_cl_EThad;  }
 
  float F0()      const { return m_cl_e_frac_S0; } // sampling 0 
  float F1()      const { return m_cl_e_frac_S1; } // sampling 1 
  float F2()      const { return m_cl_e_frac_S2; } // sampling 2 
  float F3()      const { return m_cl_e_frac_S3; } // sampling 3 
 
  const TrigEMCluster* cluster() const;
  const ElementLink< TrigEMClusterContainer >& clusterLink() const
  { return m_cluster; }
 
  const TrigInDetTrack* track() const;
  const ElementLink< TrigInDetTrackCollection >& trackLink() const
  { return m_track; }
 
 private:
  // private data members
  unsigned int m_roiWord; 
 
  bool  m_valid; 
 
  TrigInDetTrack::AlgoId m_tr_Algo; 
 
  float m_tr_Zvtx; 
 
  int m_tr_nr_trt_hits;
  int m_tr_nr_trt_hithresh_hits;
 
  float m_tr_eta_at_calo;  
  float m_tr_phi_at_calo;
 
  float m_etoverpt;
 
  float m_cl_eta; 
  float m_cl_phi;
 
  float m_cl_Rcore;  
 
  float m_cl_Eratio; 
 
  float m_cl_EThad;
 
  //  float m_cl_energy; // removed 
  float m_cl_e_frac_S0;
  float m_cl_e_frac_S1;
  float m_cl_e_frac_S2;
  float m_cl_e_frac_S3;
 
  ElementLink< TrigEMClusterContainer >    m_cluster;
  ElementLink< TrigInDetTrackCollection >  m_track;
 
};
 
// comparison operators
bool operator==( const TrigElectron& te1,  const TrigElectron& te2 );
inline bool operator!=( const TrigElectron& te1,  const TrigElectron& te2 ) {
  return !( te1 == te2 );
}
void diff( const TrigElectron& te1,  const TrigElectron& te2, std::map<std::string, double>& v_diff );
 
// print TrigElectron quantities
MsgStream& operator<< ( MsgStream& msg, const TrigElectron& te );
 
 
CLASS_DEF( TrigElectron , 144277868 , 1 )
 
#endif // TRIG_ELECTRON