ATLAS Offline Software
Public Member Functions | Public Attributes | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
EgammaMonitoring Class Reference

#include <EgammaMonitoring.h>

Inheritance diagram for EgammaMonitoring:
Collaboration diagram for EgammaMonitoring:

Public Member Functions

 EgammaMonitoring (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~EgammaMonitoring ()
 
virtual StatusCode initialize ()
 
virtual StatusCode execute ()
 
virtual StatusCode finalize ()
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Public Attributes

SmartIF< ITHistSvc > rootHistSvc
 Tools and services ///. More...
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterAll
 
std::unique_ptr< egammaMonitoring::ClusterHistogramscluster10GeV
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterPromptAll
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterPrompt10GeV
 
std::unique_ptr< egammaMonitoring::ShowerShapesHistogramsshowerShapesAll
 
std::unique_ptr< egammaMonitoring::ShowerShapesHistogramsshowerShapes10GeV
 
std::unique_ptr< egammaMonitoring::IsolationHistogramsisolationAll
 
std::unique_ptr< egammaMonitoring::RecoClusterHistogramsm_clusterReco
 
std::unique_ptr< egammaMonitoring::DiObjectHistogramsm_diElectron
 
std::unique_ptr< egammaMonitoring::RecoElectronHistogramsrecoElectronAll
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthElectronAll
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthPromptElectronAll
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthElectronRecoElectronAll
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthPromptElectronWithTrack
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthPromptElectronWithGSFTrack
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthPromptElectronWithReco
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthPromptElectronWithRecoTrack
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthRecoElectronLoose
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthRecoElectronMedium
 
std::unique_ptr< egammaMonitoring::TruthElectronHistogramstruthRecoElectronTight
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterConvPhoton
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterConvPhotonSi
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterConvPhotonSiSi
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterConvPhotonTRT
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterConvPhotonTRTTRT
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterConvPhotonSiTRT
 
std::unique_ptr< egammaMonitoring::ClusterHistogramsclusterUnconvPhoton
 
std::unique_ptr< egammaMonitoring::RecoPhotonHistogramsrecoPhotonAll
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonAll
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonAllUnconv
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonAllConv
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonAllLateConv
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonRecoPhoton
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonRecoPhotonOrElectron
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonConvPhoton
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonConvRecoConv
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonConvRecoConv1Si
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonConvRecoConv1TRT
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonConvRecoConv2Si
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonConvRecoConv2TRT
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonConvRecoConv2SiTRT
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonConvRecoUnconv
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonUnconvPhoton
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonUnconvRecoConv
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonUnconvRecoConv1Si
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonUnconvRecoConv1TRT
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonUnconvRecoConv2Si
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonUnconvRecoConv2TRT
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonUnconvRecoConv2SiTRT
 
std::unique_ptr< egammaMonitoring::IHistogramstruthPhotonUnconvRecoUnconv
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonUnconvLoose
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonUnconvTight
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonConvLoose
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonConvTight
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonUnconvIsoFixedCutTight
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonUnconvIsoFixedCutTightCaloOnly
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonUnconvIsoFixedCutLoose
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonConvIsoFixedCutTight
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonConvIsoFixedCutTightCaloOnly
 
std::unique_ptr< egammaMonitoring::IHistogramsrecoPhotonConvIsoFixedCutLoose
 
std::map< std::string, std::unique_ptr< egammaMonitoring::TrackHistograms > > mapTrkHistograms
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode ZeeSelection (float mu, const EventContext &ctx)
 
StatusCode ZeePostProc ()
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static bool matchedToElectron (const xAOD::TrackParticle &tp)
 
static bool matchedToPion (const xAOD::TrackParticle &tp)
 
static bool notMatchedToTruth (const xAOD::TrackParticle &tp)
 

Private Attributes

Gaudi::Property< std::string > m_sampleType { this, "sampleType", "Unknown", "electron or gamma" }
 Sample name ///. More...
 
Gaudi::Property< bool > m_hasTRT { this, "hasTRT", true, "is there a TRT in the ID" }
 is it run 3 or run 4 and later ? More...
 
ToolHandle< IAsgElectronLikelihoodToolm_Loose_Ele { this, "Loose_Ele", "", "" }
 Selector tools. More...
 
ToolHandle< IAsgElectronLikelihoodToolm_Medium_Ele { this, "Medium_Ele", "", "" }
 
ToolHandle< IAsgElectronLikelihoodToolm_Tight_Ele { this, "Tight_Ele", "", "" }
 
ToolHandle< IAsgElectronLikelihoodToolm_Loose_FwdEle { this, "Loose_FwdEle", "", "" }
 
ToolHandle< IAsgElectronLikelihoodToolm_Medium_FwdEle { this, "Medium_FwdEle", "", "" }
 
ToolHandle< IAsgElectronLikelihoodToolm_Tight_FwdEle { this, "Tight_FwdEle", "", "" }
 
ToolHandle< IAsgPhotonIsEMSelectorm_Loose_Photon { this, "Loose_Photon", "", "" }
 
ToolHandle< IAsgPhotonIsEMSelectorm_Tight_Photon { this, "Tight_Photon", "", "" }
 
ToolHandle< CP::IIsolationSelectionToolm_IsoFixedCutTight { this, "IsoFixedCutTight", "", "" }
 
ToolHandle< CP::IIsolationSelectionToolm_IsoFixedCutTightCaloOnly { this, "IsoTightCaloOnly", "", "" }
 
ToolHandle< CP::IIsolationSelectionToolm_IsoFixedCutLoose { this, "IsoFixedCutLoose", "", "" }
 
ToolHandle< IMCTruthClassifierm_mcTruthClassifier { this, "MCTruthClassifier", "", "" }
 
SG::ReadHandleKey< xAOD::EventInfom_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }
 
SG::ReadHandleKey< xAOD::TruthParticleContainerm_egTruthParticlesKey { this, "egammaTruthParticlesKey", "", "" }
 
SG::ReadHandleKey< xAOD::TruthParticleContainerm_truthParticlesKey { this, "truthParticlesKey", "", "" }
 
SG::ReadHandleKey< xAOD::ElectronContainerm_ElectronsKey { this, "ElectronsKey", "", "" }
 
SG::ReadHandleKey< xAOD::ElectronContainerm_FwdElectronsKey { this, "FwdElectronsKey", "", "" }
 
SG::ReadHandleKey< xAOD::PhotonContainerm_PhotonsKey { this, "PhotonsKey", "", "" }
 
SG::ReadHandleKey< xAOD::TrackParticleContainerm_InDetTrackParticlesKey { this, "InDetTrackParticlesKey", "InDetTrackParticles", "" }
 
SG::ReadHandleKey< xAOD::TrackParticleContainerm_GSFTrackParticlesKey { this, "GSFTrackParticlesKey", "", "" }
 
int m_CenFwdOverlap [2] = { 0, 0 }
 
TH1D * m_dR1 {}
 
TH1D * m_dR2 {}
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 49 of file EgammaMonitoring.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ EgammaMonitoring()

EgammaMonitoring::EgammaMonitoring ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 23 of file EgammaMonitoring.cxx.

25  : AthAlgorithm(name, pSvcLocator) {}

◆ ~EgammaMonitoring()

EgammaMonitoring::~EgammaMonitoring ( )
inline

Definition at line 148 of file EgammaMonitoring.h.

148 {};

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType  
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType  
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase hndl,
const std::string &  doc,
const SG::VarHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey hndl,
const std::string &  doc,
const SG::VarHandleKeyType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType  
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType  
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode EgammaMonitoring::execute ( )
virtual

Definition at line 523 of file EgammaMonitoring.cxx.

523  {
524 
525  const EventContext &ctx = Gaudi::Hive::currentContext();
526 
527  // Retrieve things from the event store
529  const float mu = eventInfo->averageInteractionsPerCrossing();
530 
531  // Retrieve indet track particles
534 
535  if ("dataZ" == m_sampleType) {
536  return this->ZeeSelection(mu, ctx);
537  }
538 
539  // Retrieve egamma truth particles
541  m_egTruthParticlesKey, ctx);
542 
543  // Retrieve truth particles
545  m_truthParticlesKey, ctx);
546 
547  if ("electron" == m_sampleType) {
548 
552 
553  ATH_MSG_DEBUG("------------ Truth Egamma Container ---------------");
554  for (const auto *egtruth : *egTruthParticles) {
555 
556  if (!egtruth)
557  continue;
558 
559  const xAOD::Electron *electron =
561 
562  if (!electron)
563  continue;
564 
565  clusterPromptAll->fill(*electron, mu);
566  if (egtruth->pt() > 10 * Gaudi::Units::GeV) {
567  clusterPrompt10GeV->fill(*electron, mu);
568  }
569  }
570 
571  ATH_MSG_DEBUG("------------ Truth Particles Container ---------------");
572  unsigned int promptElectronTruthIndex =
574  for (const auto *truth : *truthParticles) {
575 
576  if (!truth) continue;
577  if (std::abs(truth->pdgId()) != 11) continue;
578 
579  auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
582 
583  if (msgLvl(MSG::DEBUG)) {
584 
585  bool haspVtx = truth->hasProdVtx();
586  double rProd = -1;
587  if (haspVtx) {
588  const xAOD::TruthVertex *pvtx = truth->prodVtx();
589  rProd = pvtx->perp();
590  }
591  bool hasdVtx = truth->hasDecayVtx();
592  double rDec = -1;
593  if (hasdVtx) {
594  const xAOD::TruthVertex *dvtx = truth->decayVtx();
595  rDec = dvtx->perp();
596  }
597 
598  ATH_MSG_DEBUG(" ******** Truth electron found: "
599  << truth << " TO " << TO << " TT " << TT
600  << " Rprod = " << rProd << " Rdec = " << rDec
601  << " eventNumber " << eventInfo->eventNumber());
602  }
603 
604  // Check if it is the prompt electron
606  TT == MCTruthPartClassifier::IsoElectron &&
607  MC::isSingleParticle(truth)) {
608  truthPromptElectronAll->fill(truth);
609  promptElectronTruthIndex = truth->index();
610  }
611 
612  // Check that it is not from geant4 (but electron from photon conversion
613  // are kept)
615  truthElectronAll->fill(truth);
616  }
617 
618  ATH_MSG_DEBUG("------------ InDetTracks ---------------");
619 
620  for (const auto *tp : *InDetTPs) {
621 
622  if (!tp)
623  continue;
624 
625  uint8_t nPi = 0;
626  uint8_t nSCT = 0;
627 
628  tp->summaryValue(nPi, xAOD::numberOfPixelHits);
629  tp->summaryValue(nSCT, xAOD::numberOfSCTHits);
630 
631  if ((nPi + nSCT) < 7) continue;
632 
634 
635  if (!truth || std::abs(truth->pdgId()) != 11) continue;
636 
637  auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
641  TT == MCTruthPartClassifier::IsoElectron &&
642  truth->index() == promptElectronTruthIndex) {
643 
644  // we found the track from the prompt electron
645  // let's count it
646  truthPromptElectronWithTrack->fill(truth);
647  break;
648 
649  } else {
650  const xAOD::TruthParticle *firstElTruth =
652  if (!firstElTruth)
653  continue;
654  // this is not a prompt electron, we need to check the parents
655  // but we need to make sure that we double count if already found the
656  // track foundPromptElectron will check that
657 
658  if (firstElTruth->index() == promptElectronTruthIndex) {
659  truthPromptElectronWithTrack->fill(firstElTruth);
660  break;
661  }
662  }
663  }
664 
665  ATH_MSG_DEBUG("------------ GSFTracks ---------------");
666  for (const auto *gsf : *GSFTracks) {
667 
668  if (!gsf) continue;
669 
671 
672  if (!truth) continue;
673 
674  uint8_t nPi = 0;
675  uint8_t nSCT = 0;
676 
677  gsf->summaryValue(nPi, xAOD::numberOfPixelHits);
678  gsf->summaryValue(nSCT, xAOD::numberOfSCTHits);
679 
680  if ((nPi + nSCT) < 7) continue;
681 
682  auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
686  TT == MCTruthPartClassifier::IsoElectron &&
687  truth->index() == promptElectronTruthIndex) {
688 
689  // we found the track from the prompt electron
690  // let's count it
691  truthPromptElectronWithGSFTrack->fill(truth);
692  break;
693  } else {
694  const xAOD::TruthParticle *firstElTruth =
696  if (!firstElTruth)
697  continue;
698  ATH_MSG_DEBUG("********----- Getting Mother-----********");
699  ATH_MSG_DEBUG(" STATUS " << firstElTruth << " index "
700  << firstElTruth->index());
701  // this is not a prompt electron, we need to check the parents
702  // but we need to make sure that we double count if already found the
703  // track foundPromptElectron will check that
704  if (firstElTruth->index() == promptElectronTruthIndex) {
705  truthPromptElectronWithGSFTrack->fill(firstElTruth);
706  break;
707  }
708  }
709  }
710 
711  ATH_MSG_DEBUG("------------ Reco central electrons ---------------");
712  bool foundPromptElectron = false;
713 
714  for (const auto *elrec : *RecoEl) {
715 
716  if (!elrec) continue;
717 
718  bool toFill = false;
719 
720  clusterAll->fill(*elrec, mu);
721  recoElectronAll->fill(*elrec);
722  showerShapesAll->fill(*elrec);
723  isolationAll->fill(*elrec);
724  if (elrec->pt() > 10 * Gaudi::Units::GeV) {
725  cluster10GeV->fill(*elrec, mu);
726  showerShapes10GeV->fill(*elrec);
727  }
728 
729  const xAOD::TruthParticle *truth =
731  if (!truth)
732  continue;
733  truthElectronRecoElectronAll->fill(truth, elrec);
734  if (std::abs(truth->pdgId()) != 11 || foundPromptElectron)
735  continue;
736  const xAOD::TruthParticle *elTruth(nullptr);
737  auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
741  TT == MCTruthPartClassifier::IsoElectron &&
742  truth->index() == promptElectronTruthIndex) {
743  toFill = true;
744  elTruth = truth;
745  } else {
747  if (!firstElTruth) continue;
748  // this is not a prompt electron, we need to check the parents
749  // but we need to make sure that we double count if already found the
750  // track foundPromptElectron will check that
751  if (firstElTruth->index() == promptElectronTruthIndex) {
752  toFill = true;
753  elTruth = firstElTruth;
754  }
755  }
756  if (toFill) {
757  foundPromptElectron = true;
758  truthPromptElectronWithReco->fill(elTruth, elrec);
759  truthPromptElectronWithRecoTrack->fill(elTruth, elrec); // yes the same. This is different for fwd
760  if (m_Loose_Ele->accept(elrec)) truthRecoElectronLoose->fill(elTruth, elrec);
761  if (m_Medium_Ele->accept(elrec)) truthRecoElectronMedium->fill(elTruth, elrec);
762  if (m_Tight_Ele->accept(elrec)) truthRecoElectronTight->fill(elTruth, elrec);
763  }
764  } // RecoEl Loop
765 
766  if (!m_FwdElectronsKey.empty()) {
768  for (const auto *el : *RecoFwdEl) {
769  // This would be very weird ??
770  if (!el) continue;
771  clusterAll->fill(*el, mu);
772  recoElectronAll->fill(*el);
773  showerShapesAll->fill(*el);
774  if (el->pt() > 10 * Gaudi::Units::GeV) {
775  cluster10GeV->fill(*el, mu);
776  showerShapes10GeV->fill(*el);
777  }
778  bool toFill = false;
779 
780  const xAOD::TruthParticle *truth =
782 
783  if (!truth)
784  continue;
785  // truthElectronRecoFwdElectronAll->fill(truth, elrec); // to be done
786 
787  // if the prompt electron is not too far from the reco candidate, which
788  // might be matched to a photon use this prompt as the matched particle
789  // instead
790  if (std::abs(truth->pdgId()) != 11 &&
791  promptElectronTruthIndex < truthParticles->size()) {
792  const xAOD::TruthParticle *vtruth = truthParticles->at(promptElectronTruthIndex);
793  double dR1 = vtruth->p4().DeltaR(el->caloCluster()->p4());
794  double dR2 = truth->p4().DeltaR(el->caloCluster()->p4());
795  m_dR1->Fill(dR1);
796  m_dR2->Fill(dR2);
797  if (dR1 < 0.05) // threshold to optimize
798  truth = vtruth;
799  }
800 
801  if (std::abs(truth->pdgId()) != 11) continue;
802  const xAOD::TruthParticle *elTruth(nullptr);
803  auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
804  if (res.second == MCTruthPartClassifier::SingleElec &&
805  res.first == MCTruthPartClassifier::IsoElectron &&
806  truth->index() == promptElectronTruthIndex) {
807  toFill = true;
808  elTruth = truth;
809  } else {
810  const xAOD::TruthParticle *firstElTruth =
812  if (!firstElTruth) continue;
813  if (firstElTruth->index() == promptElectronTruthIndex) {
814  toFill = true;
815  elTruth = firstElTruth;
816  }
817  }
818  if (toFill) {
819  if (foundPromptElectron) {
820  ATH_MSG_DEBUG("A fwd electron also reconstructed as central "
821  "true eta = "
822  << elTruth->eta()
823  << " event = " << eventInfo->eventNumber());
824  m_CenFwdOverlap[0]++;
825  if (el->nTrackParticles() > 0)
826  m_CenFwdOverlap[1]++;
827  } else {
828  foundPromptElectron = true;
829  truthPromptElectronWithReco->fill(elTruth, el);
830  if (el->nTrackParticles() > 0)
831  truthPromptElectronWithRecoTrack->fill(elTruth, el);
832  if (m_Loose_FwdEle->accept(el))
833  truthRecoElectronLoose->fill(elTruth, el);
834  if (m_Medium_FwdEle->accept(el))
835  truthRecoElectronMedium->fill(elTruth, el);
836  if (m_Tight_FwdEle->accept(el))
837  truthRecoElectronTight->fill(elTruth, el);
838  }
839  }
840  } // loop on fwdEl
841  }
842 
843  } // if electron
844 
845  if ("gamma" == m_sampleType) {
846 
847  ATH_MSG_DEBUG("------------ Photons ---------------");
849 
850  for (const auto *phrec : *RecoPh) {
851 
852  if (!phrec)
853  continue;
854 
855  recoPhotonAll->fill(*phrec);
856  isolationAll->fill(*phrec);
857  showerShapesAll->fill(*phrec);
858  clusterAll->fill(*phrec, mu);
859  if (phrec->pt() > 10 * Gaudi::Units::GeV) {
860  cluster10GeV->fill(*phrec, mu);
861  showerShapes10GeV->fill(*phrec);
862  }
863 
864  } // RecoPh Loop
865 
866  for (const auto *egtruth : *egTruthParticles) {
867 
868  if (!egtruth)
869  continue;
870 
871  truthPhotonAll->fill(*egtruth, mu);
872 
873  bool isTrueConv = xAOD::EgammaHelpers::isTrueConvertedPhoton(egtruth);
874  bool isTrueLateConv =
876  !isTrueConv;
877  const xAOD::Photon *photon = xAOD::EgammaHelpers::getRecoPhoton(egtruth);
879  xAOD::EgammaHelpers::getRecoElectron(egtruth);
880 
881  if (isTrueConv)
882  truthPhotonAllConv->fill(*egtruth, mu);
883  if (isTrueLateConv)
884  truthPhotonAllLateConv->fill(*egtruth, mu);
885  if (!isTrueConv && !isTrueLateConv)
886  truthPhotonAllUnconv->fill(*egtruth, mu);
887 
888  if (photon || electron)
890 
891  if (!photon)
892  continue;
893 
894  truthPhotonRecoPhoton->fill(*egtruth, mu);
896  if (egtruth->pt() > 10 * Gaudi::Units::GeV) {
897  clusterPrompt10GeV->fill(*photon, mu);
898  }
899 
903 
904  if (isTrueConv) {
905 
906  truthPhotonConvPhoton->fill(*egtruth, mu);
907 
908  if (isRecoConv) {
909 
910  truthPhotonConvRecoConv->fill(*egtruth, mu);
911 
912  clusterConvPhoton->fill(*photon, mu);
913 
914  if (convType == xAOD::EgammaParameters::singleSi) {
915  truthPhotonConvRecoConv1Si->fill(*egtruth, mu);
916  clusterConvPhotonSi->fill(*photon, mu);
917  } else if (convType == xAOD::EgammaParameters::singleTRT) {
918  truthPhotonConvRecoConv1TRT->fill(*egtruth, mu);
919  clusterConvPhotonTRT->fill(*photon, mu);
920  } else if (convType == xAOD::EgammaParameters::doubleSi) {
921  truthPhotonConvRecoConv2Si->fill(*egtruth, mu);
923  } else if (convType == xAOD::EgammaParameters::doubleTRT) {
924  truthPhotonConvRecoConv2TRT->fill(*egtruth, mu);
926  } else if (convType == xAOD::EgammaParameters::doubleSiTRT) {
927  truthPhotonConvRecoConv2SiTRT->fill(*egtruth, mu);
929  }
930 
931  if (m_IsoFixedCutTight->accept(*photon))
932  recoPhotonConvIsoFixedCutTight->fill(*egtruth, mu);
933  if (m_IsoFixedCutTightCaloOnly->accept(*photon))
935  if (m_IsoFixedCutLoose->accept(*photon))
936  recoPhotonConvIsoFixedCutLoose->fill(*egtruth, mu);
937  if (m_Loose_Photon->accept(photon))
938  recoPhotonConvLoose->fill(*egtruth, mu);
939  if (m_Tight_Photon->accept(photon))
940  recoPhotonConvTight->fill(*egtruth, mu);
941  } // isRecoConv
942  else {
943  truthPhotonConvRecoUnconv->fill(*egtruth, mu);
944  clusterUnconvPhoton->fill(*photon, mu);
945  }
946 
947  } // isTrueConv
948  // else if (!isTrueLateConv) {
949  else {
950 
951  truthPhotonUnconvPhoton->fill(*egtruth, mu);
952 
953  if (isRecoConv) {
954  truthPhotonUnconvRecoConv->fill(*egtruth, mu);
955 
956  if (convType == xAOD::EgammaParameters::singleSi) {
957  truthPhotonUnconvRecoConv1Si->fill(*egtruth, mu);
958  clusterConvPhotonSi->fill(*photon, mu);
959  } else if (convType == xAOD::EgammaParameters::singleTRT) {
960  truthPhotonUnconvRecoConv1TRT->fill(*egtruth, mu);
961  clusterConvPhotonTRT->fill(*photon, mu);
962  } else if (convType == xAOD::EgammaParameters::doubleSi) {
963  truthPhotonUnconvRecoConv2Si->fill(*egtruth, mu);
965  } else if (convType == xAOD::EgammaParameters::doubleTRT) {
966  truthPhotonUnconvRecoConv2TRT->fill(*egtruth, mu);
968  } else if (convType == xAOD::EgammaParameters::doubleSiTRT) {
969  truthPhotonUnconvRecoConv2SiTRT->fill(*egtruth, mu);
971  }
972  } else
973  truthPhotonUnconvRecoUnconv->fill(*egtruth, mu);
975 
976  if (m_IsoFixedCutTight->accept(*photon))
977  recoPhotonUnconvIsoFixedCutTight->fill(*egtruth, mu);
978  if (m_IsoFixedCutTightCaloOnly->accept(*photon))
980  if (m_IsoFixedCutLoose->accept(*photon))
981  recoPhotonUnconvIsoFixedCutLoose->fill(*egtruth, mu);
982  if (m_Loose_Photon->accept(photon))
983  recoPhotonUnconvLoose->fill(*egtruth, mu);
984  if (m_Tight_Photon->accept(photon))
985  recoPhotonUnconvTight->fill(*egtruth, mu);
986  } // !isTrueLateConv
987  } // egtruth Loop
988 
989  // loop over InDetTrackParticles
990  for (const auto *tp : *InDetTPs) {
991 
992  mapTrkHistograms["InDetTracks"]->fill(*tp, mu);
993  if (matchedToElectron(*tp))
994  mapTrkHistograms["InDetTracksMatchElectron"]->fill(*tp, mu);
995  else {
996  mapTrkHistograms["InDetTracksNotElectron"]->fill(*tp, mu);
997  if (matchedToPion(*tp))
998  mapTrkHistograms["InDetTracksMatchPion"]->fill(*tp, mu);
999  else if (notMatchedToTruth(*tp))
1000  mapTrkHistograms["InDetTracksNotMatched"]->fill(*tp, mu);
1001  }
1002  if (tp->pt() > 3000.) {
1003  mapTrkHistograms["InDetTrackshighpT"]->fill(*tp, mu);
1004  if (matchedToElectron(*tp)) {
1005  mapTrkHistograms["InDetTracksMatchElectronhighpT"]->fill(*tp, mu);
1006  } else {
1007  mapTrkHistograms["InDetTracksNotElectronhighpT"]->fill(*tp, mu);
1008  if (matchedToPion(*tp)) {
1009  mapTrkHistograms["InDetTracksMatchPionhighpT"]->fill(*tp, mu);
1010  } else if (notMatchedToTruth(*tp)) {
1011  mapTrkHistograms["InDetTracksNotMatchedhighpT"]->fill(*tp, mu);
1012  }
1013  }
1014  }
1015 
1016  if (m_hasTRT &&
1017  xAOD::EgammaHelpers::numberOfSiHits(tp) == 0) { // TRTSA tracks
1018  mapTrkHistograms["InDetTracksTRT"]->fill(*tp, mu);
1019  if (matchedToElectron(*tp))
1020  mapTrkHistograms["InDetTracksTRTMatchElectron"]->fill(*tp, mu);
1021  else {
1022  mapTrkHistograms["InDetTracksTRTNotElectron"]->fill(*tp, mu);
1023  if (matchedToPion(*tp))
1024  mapTrkHistograms["InDetTracksTRTMatchPion"]->fill(*tp, mu);
1025  else if (notMatchedToTruth(*tp))
1026  mapTrkHistograms["InDetTracksTRTNotMatched"]->fill(*tp, mu);
1027  }
1028  if (tp->pt() > 3000.) {
1029  mapTrkHistograms["InDetTracksTRThighpT"]->fill(*tp, mu);
1030  if (matchedToElectron(*tp))
1031  mapTrkHistograms["InDetTracksTRTMatchElectronhighpT"]->fill(*tp,
1032  mu);
1033  else {
1034  mapTrkHistograms["InDetTracksTRTNotElectronhighpT"]->fill(*tp, mu);
1035  if (matchedToPion(*tp))
1036  mapTrkHistograms["InDetTracksTRTMatchPionhighpT"]->fill(*tp, mu);
1037  else if (notMatchedToTruth(*tp))
1038  mapTrkHistograms["InDetTracksTRTNotMatchedhighpT"]->fill(*tp, mu);
1039  }
1040  }
1041  }
1042 
1043  } // loop over InDetTPs
1044 
1045  } // if gamma
1046 
1047  return StatusCode::SUCCESS;
1048 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

StatusCode EgammaMonitoring::finalize ( )
virtual

Definition at line 1052 of file EgammaMonitoring.cxx.

1052  {
1053 
1054  if ("electron" == m_sampleType) {
1055 
1056  ATH_MSG_INFO("Number of events with electron reconstructed "
1057  "as both Central and Forward "
1058  << m_CenFwdOverlap[0] << " and with a track for the Forward "
1059  << m_CenFwdOverlap[1]);
1060 
1061  egammaMonitoring::EfficiencyPlot trackEfficiency(
1062  "trackingEfficiency", "/MONITORING/trackingEfficiency/", rootHistSvc);
1063  ATH_CHECK(trackEfficiency.divide(truthPromptElectronWithTrack.get(),
1064  truthPromptElectronAll.get()));
1065  egammaMonitoring::EfficiencyPlot GSFEfficiency(
1066  "GSFEfficiency", "/MONITORING/GSFEfficiency/", rootHistSvc);
1067  ATH_CHECK(GSFEfficiency.divide(truthPromptElectronWithGSFTrack.get(),
1069  egammaMonitoring::EfficiencyPlot matchingEfficiency(
1070  "matchingEfficiency", "/MONITORING/matchingEfficiency/", rootHistSvc);
1071  ATH_CHECK(matchingEfficiency.divide(truthPromptElectronWithRecoTrack.get(),
1073  egammaMonitoring::EfficiencyPlot reconstructionEfficiency(
1074  "reconstructionEfficiency", "/MONITORING/reconstructionEfficiency/",
1075  rootHistSvc);
1076  ATH_CHECK(reconstructionEfficiency.divide(truthPromptElectronWithReco.get(),
1077  truthPromptElectronAll.get()));
1078  egammaMonitoring::EfficiencyPlot recoElectronLooseEfficiency(
1079  "recoElectronLooseLHEfficiency",
1080  "/MONITORING/recoElectronLooseLHEfficiency/", rootHistSvc);
1081  ATH_CHECK(recoElectronLooseEfficiency.divide(truthRecoElectronLoose.get(),
1082  truthPromptElectronAll.get()));
1083  egammaMonitoring::EfficiencyPlot recoElectronMediumEfficiency(
1084  "recoElectronMediumLHEfficiency",
1085  "/MONITORING/recoElectronMediumLHEfficiency/", rootHistSvc);
1086  ATH_CHECK(recoElectronMediumEfficiency.divide(
1088  egammaMonitoring::EfficiencyPlot recoElectronTightEfficiency(
1089  "recoElectronTightLHEfficiency",
1090  "/MONITORING/recoElectronTightLHEfficiency/", rootHistSvc);
1091  ATH_CHECK(recoElectronTightEfficiency.divide(truthRecoElectronTight.get(),
1092  truthPromptElectronAll.get()));
1093 
1094  }
1095 
1096  else if ("gamma" == m_sampleType) {
1097 
1098  egammaMonitoring::EfficiencyPlot truthPhotonRecoPhotonEfficiency(
1099  "truthPhotonRecoPhotonEfficiency",
1100  "/MONITORING/truthPhotonRecoPhotonEfficiency/", rootHistSvc);
1101  ATH_CHECK(truthPhotonRecoPhotonEfficiency.divide(
1102  truthPhotonRecoPhoton.get(), truthPhotonAll.get()));
1103  egammaMonitoring::EfficiencyPlot truthPhotonRecoPhotonOrElectronEfficiency(
1104  "truthPhotonRecoPhotonOrElectronEfficiency",
1105  "/MONITORING/truthPhotonRecoPhotonOrElectronEfficiency/", rootHistSvc);
1106  ATH_CHECK(truthPhotonRecoPhotonOrElectronEfficiency.divide(
1108  egammaMonitoring::EfficiencyPlot truthPhotonConvRecoEfficiency(
1109  "truthPhotonConvRecoEfficiency",
1110  "/MONITORING/truthPhotonConvRecoEfficiency/", rootHistSvc);
1111  ATH_CHECK(truthPhotonConvRecoEfficiency.divide(truthPhotonConvPhoton.get(),
1112  truthPhotonAllConv.get()));
1113  egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoEfficiency(
1114  "truthPhotonUnconvRecoEfficiency",
1115  "/MONITORING/truthPhotonUnconvRecoEfficiency/", rootHistSvc);
1116  ATH_CHECK(truthPhotonUnconvRecoEfficiency.divide(
1118  egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConvEfficiency(
1119  "truthPhotonConvRecoConvEfficiency",
1120  "/MONITORING/truthPhotonConvRecoConvEfficiency/", rootHistSvc);
1121  ATH_CHECK(truthPhotonConvRecoConvEfficiency.divide(
1123  egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv1SiEfficiency(
1124  "truthPhotonConvRecoConv1SiEfficiency",
1125  "/MONITORING/truthPhotonConvRecoConv1SiEfficiency/", rootHistSvc);
1126  ATH_CHECK(truthPhotonConvRecoConv1SiEfficiency.divide(
1128  egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv2SiEfficiency(
1129  "truthPhotonConvRecoConv2SiEfficiency",
1130  "/MONITORING/truthPhotonConvRecoConv2SiEfficiency/", rootHistSvc);
1131  ATH_CHECK(truthPhotonConvRecoConv2SiEfficiency.divide(
1133  egammaMonitoring::EfficiencyPlot truthPhotonConvRecoUnconvEfficiency(
1134  "truthPhotonConvRecoUnconvEfficiency",
1135  "/MONITORING/truthPhotonConvRecoUnconvEfficiency/", rootHistSvc);
1136  ATH_CHECK(truthPhotonConvRecoUnconvEfficiency.divide(
1138  egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConvEfficiency(
1139  "truthPhotonUnconvRecoConvEfficiency",
1140  "/MONITORING/truthPhotonUnconvRecoConvEfficiency/", rootHistSvc);
1141  ATH_CHECK(truthPhotonUnconvRecoConvEfficiency.divide(
1143  egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConv1SiEfficiency(
1144  "truthPhotonUnconvRecoConv1SiEfficiency",
1145  "/MONITORING/truthPhotonUnconvRecoConv1SiEfficiency/", rootHistSvc);
1146  ATH_CHECK(truthPhotonUnconvRecoConv1SiEfficiency.divide(
1148  egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConv2SiEfficiency(
1149  "truthPhotonUnconvRecoConv2SiEfficiency",
1150  "/MONITORING/truthPhotonUnconvRecoConv2SiEfficiency/", rootHistSvc);
1151  ATH_CHECK(truthPhotonUnconvRecoConv2SiEfficiency.divide(
1153  egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoUnconvEfficiency(
1154  "truthPhotonUnconvRecoUnconvEfficiency",
1155  "/MONITORING/truthPhotonUnconvRecoUnconvEfficiency/", rootHistSvc);
1156  ATH_CHECK(truthPhotonUnconvRecoUnconvEfficiency.divide(
1158  egammaMonitoring::EfficiencyPlot truthPhotonRecoConvEfficiency(
1159  "truthPhotonRecoConvEfficiency",
1160  "/MONITORING/truthPhotonRecoConvEfficiency/", rootHistSvc);
1161  ATH_CHECK(truthPhotonRecoConvEfficiency.divide(
1163  egammaMonitoring::EfficiencyPlot truthPhotonRecoUnconvEfficiency(
1164  "truthPhotonRecoUnconvEfficiency",
1165  "/MONITORING/truthPhotonRecoUnconvEfficiency/", rootHistSvc);
1166  ATH_CHECK(truthPhotonRecoUnconvEfficiency.divide(
1168  egammaMonitoring::EfficiencyPlot recoPhotonUnconvIsoFixedCutTightEfficiency(
1169  "recoPhotonUnconvIsoFixedCutTightEfficiency",
1170  "/MONITORING/recoPhotonUnconvIsoFixedCutTightEfficiency/", rootHistSvc);
1171  ATH_CHECK(recoPhotonUnconvIsoFixedCutTightEfficiency.divide(
1175  recoPhotonUnconvIsoFixedCutTightCaloOnlyEfficiency(
1176  "recoPhotonUnconvIsoFixedCutTightCaloOnlyEfficiency",
1177  "/MONITORING/recoPhotonUnconvIsoFixedCutTightCaloOnlyEfficiency/",
1178  rootHistSvc);
1179  ATH_CHECK(recoPhotonUnconvIsoFixedCutTightCaloOnlyEfficiency.divide(
1182  egammaMonitoring::EfficiencyPlot recoPhotonUnconvIsoFixedCutLooseEfficiency(
1183  "recoPhotonUnconvIsoFixedCutLooseEfficiency",
1184  "/MONITORING/recoPhotonUnconvIsoFixedCutLooseEfficiency/", rootHistSvc);
1185  ATH_CHECK(recoPhotonUnconvIsoFixedCutLooseEfficiency.divide(
1188  egammaMonitoring::EfficiencyPlot recoPhotonConvIsoFixedCutTightEfficiency(
1189  "recoPhotonConvIsoFixedCutTightEfficiency",
1190  "/MONITORING/recoPhotonConvIsoFixedCutTightEfficiency/", rootHistSvc);
1191  ATH_CHECK(recoPhotonConvIsoFixedCutTightEfficiency.divide(
1194  recoPhotonConvIsoFixedCutTightCaloOnlyEfficiency(
1195  "recoPhotonConvIsoFixedCutTightCaloOnlyEfficiency",
1196  "/MONITORING/recoPhotonConvIsoFixedCutTightCaloOnlyEfficiency/",
1197  rootHistSvc);
1198  ATH_CHECK(recoPhotonConvIsoFixedCutTightCaloOnlyEfficiency.divide(
1200  truthPhotonConvRecoConv.get()));
1201  egammaMonitoring::EfficiencyPlot recoPhotonConvIsoFixedCutLooseEfficiency(
1202  "recoPhotonConvIsoFixedCutLooseEfficiency",
1203  "/MONITORING/recoPhotonConvIsoFixedCutLooseEfficiency/", rootHistSvc);
1204  ATH_CHECK(recoPhotonConvIsoFixedCutLooseEfficiency.divide(
1206  egammaMonitoring::EfficiencyPlot recoPhotonConvLooseEfficiency(
1207  "recoPhotonConvLooseEfficiency",
1208  "/MONITORING/recoPhotonConvLooseEfficiency/", rootHistSvc);
1209  ATH_CHECK(recoPhotonConvLooseEfficiency.divide(
1211  egammaMonitoring::EfficiencyPlot recoPhotonConvTightEfficiency(
1212  "recoPhotonConvTightEfficiency",
1213  "/MONITORING/recoPhotonConvTightEfficiency/", rootHistSvc);
1214  ATH_CHECK(recoPhotonConvTightEfficiency.divide(
1216  egammaMonitoring::EfficiencyPlot recoPhotonUnconvLooseEfficiency(
1217  "recoPhotonUnconvLooseEfficiency",
1218  "/MONITORING/recoPhotonUnconvLooseEfficiency/", rootHistSvc);
1219  ATH_CHECK(recoPhotonUnconvLooseEfficiency.divide(
1221  egammaMonitoring::EfficiencyPlot recoPhotonUnconvTightEfficiency(
1222  "recoPhotonUnconvTightEfficiency",
1223  "/MONITORING/recoPhotonUnconvTightEfficiency/", rootHistSvc);
1224  ATH_CHECK(recoPhotonUnconvTightEfficiency.divide(
1226 
1227  egammaMonitoring::WidthPlot truthPhotonRecoPhotonWidth(
1228  "truthPhotonRecoPhotonWidth", "/MONITORING/truthPhotonRecoPhotonWidth/",
1229  rootHistSvc);
1230  ATH_CHECK(truthPhotonRecoPhotonWidth.fill(truthPhotonRecoPhoton.get()));
1231  egammaMonitoring::WidthPlot truthPhotonConvPhotonWidth(
1232  "truthPhotonConvPhotonWidth", "/MONITORING/truthPhotonConvPhotonWidth/",
1233  rootHistSvc);
1234  ATH_CHECK(truthPhotonConvPhotonWidth.fill(truthPhotonConvPhoton.get()));
1235  egammaMonitoring::WidthPlot truthPhotonConvRecoConvWidth(
1236  "truthPhotonConvRecoConvWidth",
1237  "/MONITORING/truthPhotonConvRecoConvWidth/", rootHistSvc);
1238  ATH_CHECK(truthPhotonConvRecoConvWidth.fill(truthPhotonConvRecoConv.get()));
1239  egammaMonitoring::WidthPlot truthPhotonConvRecoConv1SiWidth(
1240  "truthPhotonConvRecoConv1SiWidth",
1241  "/MONITORING/truthPhotonConvRecoConv1SiWidth/", rootHistSvc);
1242  ATH_CHECK(
1243  truthPhotonConvRecoConv1SiWidth.fill(truthPhotonConvRecoConv1Si.get()));
1244  egammaMonitoring::WidthPlot truthPhotonConvRecoConv2SiWidth(
1245  "truthPhotonConvRecoConv2SiWidth",
1246  "/MONITORING/truthPhotonConvRecoConv2SiWidth/", rootHistSvc);
1247  ATH_CHECK(
1248  truthPhotonConvRecoConv2SiWidth.fill(truthPhotonConvRecoConv2Si.get()));
1249  if (m_hasTRT) {
1250  egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv1TRTEfficiency(
1251  "truthPhotonConvRecoConv1TRTEfficiency",
1252  "/MONITORING/truthPhotonConvRecoConv1TRTEfficiency/", rootHistSvc);
1253  ATH_CHECK(truthPhotonConvRecoConv1TRTEfficiency.divide(
1255  egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv2TRTEfficiency(
1256  "truthPhotonConvRecoConv2TRTEfficiency",
1257  "/MONITORING/truthPhotonConvRecoConv2TRTEfficiency/", rootHistSvc);
1258  ATH_CHECK(truthPhotonConvRecoConv2TRTEfficiency.divide(
1260  egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv2SiTRTEfficiency(
1261  "truthPhotonConvRecoConv2SiTRTEfficiency",
1262  "/MONITORING/truthPhotonConvRecoConv2SiTRTEfficiency/", rootHistSvc);
1263  ATH_CHECK(truthPhotonConvRecoConv2SiTRTEfficiency.divide(
1265  egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConv1TRTEfficiency(
1266  "truthPhotonUnconvRecoConv1TRTEfficiency",
1267  "/MONITORING/truthPhotonUnconvRecoConv1TRTEfficiency/", rootHistSvc);
1268  ATH_CHECK(truthPhotonUnconvRecoConv1TRTEfficiency.divide(
1270  egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConv2TRTEfficiency(
1271  "truthPhotonUnconvRecoConv2TRTEfficiency",
1272  "/MONITORING/truthPhotonUnconvRecoConv2TRTEfficiency/", rootHistSvc);
1273  ATH_CHECK(truthPhotonUnconvRecoConv2TRTEfficiency.divide(
1276  truthPhotonUnconvRecoConv2SiTRTEfficiency(
1277  "truthPhotonUnconvRecoConv2SiTRTEfficiency",
1278  "/MONITORING/truthPhotonUnconvRecoConv2SiTRTEfficiency/",
1279  rootHistSvc);
1280  ATH_CHECK(truthPhotonUnconvRecoConv2SiTRTEfficiency.divide(
1282  truthPhotonUnconvPhoton.get()));
1283  egammaMonitoring::WidthPlot truthPhotonConvRecoConv1TRTWidth(
1284  "truthPhotonConvRecoConv1TRTWidth",
1285  "/MONITORING/truthPhotonConvRecoConv1TRTWidth/", rootHistSvc);
1286  ATH_CHECK(truthPhotonConvRecoConv1TRTWidth.fill(
1288  egammaMonitoring::WidthPlot truthPhotonConvRecoConv2TRTWidth(
1289  "truthPhotonConvRecoConv2TRTWidth",
1290  "/MONITORING/truthPhotonConvRecoConv2TRTWidth/", rootHistSvc);
1291  ATH_CHECK(truthPhotonConvRecoConv2TRTWidth.fill(
1293  egammaMonitoring::WidthPlot truthPhotonConvRecoConv2SiTRTWidth(
1294  "truthPhotonConvRecoConv2SiTRTWidth",
1295  "/MONITORING/truthPhotonConvRecoConv2SiTRTWidth/", rootHistSvc);
1296  ATH_CHECK(truthPhotonConvRecoConv2SiTRTWidth.fill(
1298  }
1299  egammaMonitoring::WidthPlot truthPhotonConvRecoUnconvWidth(
1300  "truthPhotonConvRecoUnconvWidth",
1301  "/MONITORING/truthPhotonConvRecoUnconvWidth/", rootHistSvc);
1302  ATH_CHECK(
1303  truthPhotonConvRecoUnconvWidth.fill(truthPhotonConvRecoUnconv.get()));
1304  egammaMonitoring::WidthPlot truthPhotonUnconvPhotonWidth(
1305  "truthPhotonUnconvPhotonWidth",
1306  "/MONITORING/truthPhotonUnconvPhotonWidth/", rootHistSvc);
1307  ATH_CHECK(truthPhotonUnconvPhotonWidth.fill(truthPhotonUnconvPhoton.get()));
1308  egammaMonitoring::WidthPlot truthPhotonUnconvRecoConvWidth(
1309  "truthPhotonUnconvRecoConvWidth",
1310  "/MONITORING/truthPhotonUnconvRecoConvWidth/", rootHistSvc);
1311  ATH_CHECK(
1312  truthPhotonUnconvRecoConvWidth.fill(truthPhotonUnconvRecoConv.get()));
1313  egammaMonitoring::WidthPlot truthPhotonUnconvRecoUnconvWidth(
1314  "truthPhotonUnconvRecoUnconvWidth",
1315  "/MONITORING/truthPhotonUnconvRecoUnconvWidth/", rootHistSvc);
1316  ATH_CHECK(truthPhotonUnconvRecoUnconvWidth.fill(
1318  } else if ("dataZ" == m_sampleType) {
1320  }
1321 
1322  return StatusCode::SUCCESS;
1323 }

◆ initialize()

StatusCode EgammaMonitoring::initialize ( )
virtual

Definition at line 29 of file EgammaMonitoring.cxx.

29  {
30  ATH_MSG_INFO("******************** Running over " << m_sampleType
31  << " ******************");
32  ATH_CHECK( (rootHistSvc = service("THistSvc")).isValid() );
33 
34  showerShapesAll = std::make_unique<egammaMonitoring::ShowerShapesHistograms>(
35  "showerShapesAll", "Shower Shapes ", "/MONITORING/showerShapesAll/",
36  rootHistSvc);
37 
39  std::make_unique<egammaMonitoring::ShowerShapesHistograms>(
40  "showerShapes10GeV", "Shower Shapes - 10 GeV",
41  "/MONITORING/showerShapes10GeV/", rootHistSvc);
42 
43  isolationAll = std::make_unique<egammaMonitoring::IsolationHistograms>(
44  "isolationAll", "Isolation ", "/MONITORING/isolationAll/", rootHistSvc);
45 
46  ATH_CHECK(showerShapesAll->initializePlots());
47  ATH_CHECK(showerShapes10GeV->initializePlots());
48  ATH_CHECK(isolationAll->initializePlots(m_sampleType == "electron"));
49 
50  if ("dataZ" != m_sampleType) {
51  clusterAll = std::make_unique<egammaMonitoring::ClusterHistograms>(
52  "clustersAll", "Clusters", "/MONITORING/clusterAll/", rootHistSvc);
53 
54  cluster10GeV = std::make_unique<egammaMonitoring::ClusterHistograms>(
55  "clusters10GeV", "Clusters - 10 GeV", "/MONITORING/cluster10GeV/",
56  rootHistSvc);
57 
58  clusterPromptAll = std::make_unique<egammaMonitoring::ClusterHistograms>(
59  "clustersPromptAll", "Clusters from Prompt",
60  "/MONITORING/clusterPromptAll/", rootHistSvc);
61 
62  clusterPrompt10GeV = std::make_unique<egammaMonitoring::ClusterHistograms>(
63  "clustersPrompt10GeV", "Clusters from Prompt - 10 GeV",
64  "/MONITORING/clusterPrompt10GeV/", rootHistSvc);
65 
66  ATH_CHECK(clusterAll->initializePlots());
67  ATH_CHECK(cluster10GeV->initializePlots());
68  ATH_CHECK(clusterPromptAll->initializePlots());
69  ATH_CHECK(clusterPrompt10GeV->initializePlots());
70  } else {
71  m_clusterReco = std::make_unique<egammaMonitoring::RecoClusterHistograms>(
72  "clustersReco", "Clusters from Z->ee candidates in data",
73  "/MONITORING/recoCluster/", rootHistSvc);
75  std::make_unique<egammaMonitoring::RecoElectronHistograms>(
76  "recoElectronAll", "Reco electrons from Z->ee candidates in data",
77  "/MONITORING/recoZElectron/", rootHistSvc);
78  m_diElectron = std::make_unique<egammaMonitoring::DiObjectHistograms>(
79  "diElectrons", "Z->ee candidates in data", "/MONITORING/diElectrons/",
80  rootHistSvc);
81  ATH_CHECK(m_clusterReco->initializePlots());
82  recoElectronAll->isData();
83  ATH_CHECK(recoElectronAll->initializePlots());
84  ATH_CHECK(m_diElectron->initializePlots());
85  }
86 
87  if ("electron" == m_sampleType) {
88 
90  std::make_unique<egammaMonitoring::RecoElectronHistograms>(
91  "recoElectronAll", "Electrons Reco Electron",
92  "/MONITORING/recoElectronAll/", rootHistSvc);
93 
95  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
96  "truthElectronAll", "All Truth Electrons",
97  "/MONITORING/truthElectronAll/", rootHistSvc);
98 
100  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
101  "truthPromptElectronAll", "All Truth Prompt Electrons",
102  "/MONITORING/truthPromptElectronAll/", rootHistSvc);
103 
105  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
106  "truthElectronRecoElectronAll", "Truth Electrons Reco Electron",
107  "/MONITORING/truthElectronRecoElectronAll/", rootHistSvc);
108 
110  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
111  "truthPromptElectronWithTrack", "Truth Prompt Electrons With Track",
112  "/MONITORING/truthPromptElectronWithTrack/", rootHistSvc);
113 
115  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
116  "truthPromptElectronWithGSFTrack",
117  "Truth Prompt Electrons With GSFTrack",
118  "/MONITORING/truthPromptElectronWithGSFTrack/", rootHistSvc);
119 
121  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
122  "truthPromptElectronWithReco",
123  "Truth Prompt Electrons With GSFTrack or just with a fwd cluster",
124  "/MONITORING/truthPromptElectronWithReco/", rootHistSvc);
125 
127  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
128  "truthPromptElectronWithRecoTrack",
129  "Truth Prompt Electrons With GSFTrack",
130  "/MONITORING/truthPromptElectronWithRecoTrack/", rootHistSvc);
131 
133  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
134  "truthRecoElectronLooseLH", "LLH Electrons Reco Electron",
135  "/MONITORING/truthRecoElectronLooseLH/", rootHistSvc);
136 
138  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
139  "truthRecoElectronMediumLH", "MLH Electrons Reco Electron",
140  "/MONITORING/truthRecoElectronMediumLH/", rootHistSvc);
141 
143  std::make_unique<egammaMonitoring::TruthElectronHistograms>(
144  "truthRecoElectronTightLH", "TLH Electrons Reco Electron",
145  "/MONITORING/truthRecoElectronTightLH/", rootHistSvc);
146 
147  if (!m_FwdElectronsKey.empty()) {
148  recoElectronAll->hasFwd();
149  truthElectronAll->hasFwd();
150  truthPromptElectronAll->hasFwd();
154  truthPromptElectronWithReco->hasFwd();
156  truthRecoElectronLoose->hasFwd();
157  truthRecoElectronMedium->hasFwd();
158  truthRecoElectronTight->hasFwd();
159  }
160 
161  ATH_CHECK(recoElectronAll->initializePlots());
162  ATH_CHECK(truthRecoElectronLoose->initializePlots());
163  ATH_CHECK(truthRecoElectronMedium->initializePlots());
164  ATH_CHECK(truthRecoElectronTight->initializePlots());
165  ATH_CHECK(truthElectronAll->initializePlots(true));
166  ATH_CHECK(truthPromptElectronAll->initializePlots(true));
167  ATH_CHECK(truthElectronRecoElectronAll->initializePlots());
168  ATH_CHECK(truthPromptElectronWithTrack->initializePlots(true));
169  ATH_CHECK(truthPromptElectronWithGSFTrack->initializePlots(true));
170  ATH_CHECK(truthPromptElectronWithReco->initializePlots());
171  ATH_CHECK(truthPromptElectronWithRecoTrack->initializePlots());
172  } // electron Hists
173 
174  if ("gamma" == m_sampleType) {
175 
176  // all reco photons
177  recoPhotonAll = std::make_unique<egammaMonitoring::RecoPhotonHistograms>(
178  "recoPhotonAll", "Reco Photon", "/MONITORING/recoPhotonAll/",
179  rootHistSvc);
180  ATH_CHECK(recoPhotonAll->initializePlots());
181 
182  clusterConvPhoton = std::make_unique<egammaMonitoring::ClusterHistograms>(
183  "clusterConvPhoton", "Clusters from Converted Photons",
184  "/MONITORING/clusterConvPhoton/", rootHistSvc);
185 
186  clusterConvPhotonSi = std::make_unique<egammaMonitoring::ClusterHistograms>(
187  "clusterConvPhotonSi", "Clusters from Converted Photons - Si",
188  "/MONITORING/clusterConvPhotonSi/", rootHistSvc);
189 
191  std::make_unique<egammaMonitoring::ClusterHistograms>(
192  "clusterConvPhotonSiSi", "Clusters from Converted Photons - SiSi",
193  "/MONITORING/clusterConvPhotonSiSi/", rootHistSvc);
194 
195  clusterUnconvPhoton = std::make_unique<egammaMonitoring::ClusterHistograms>(
196  "clusterUnconvPhoton", "Clusters from Converted Photons",
197  "/MONITORING/clusterUnconvPhoton/", rootHistSvc);
198 
199  // Cluster information
200  ATH_CHECK(clusterConvPhoton->initializePlots());
201  ATH_CHECK(clusterConvPhotonSi->initializePlots());
202  ATH_CHECK(clusterConvPhotonSiSi->initializePlots());
203  ATH_CHECK(clusterUnconvPhoton->initializePlots());
204 
205  if (m_hasTRT) {
207  std::make_unique<egammaMonitoring::ClusterHistograms>(
208  "clusterConvPhotonTRT", "Clusters from Converted Photons - TRT",
209  "/MONITORING/clusterConvPhotonTRT/", rootHistSvc);
210 
212  std::make_unique<egammaMonitoring::ClusterHistograms>(
213  "clusterConvPhotonTRTTRT",
214  "Clusters from Converted Photons - TRTTRT",
215  "/MONITORING/clusterConvPhotonTRTTRT/", rootHistSvc);
216 
218  std::make_unique<egammaMonitoring::ClusterHistograms>(
219  "clusterConvPhotonSiTRT",
220  "Clusters from Converted Photons - SiTRT",
221  "/MONITORING/clusterConvPhotonSiTRT/", rootHistSvc);
222 
224  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
225  "truthConvRecoConv1TRT", "truthConvRecoConv1TRT",
226  "/MONITORING/truthConvRecoConv1TRT/", rootHistSvc);
227 
229  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
230  "truthConvRecoConv2TRT", "truthConvRecoConv2TRT",
231  "/MONITORING/truthConvRecoConv2TRT/", rootHistSvc);
232 
234  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
235  "truthConvRecoConv2SiTRT", "truthConvRecoConv2SiTRT",
236  "/MONITORING/truthConvRecoConv2SiTRT/", rootHistSvc);
237 
239  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
240  "truthUnconvRecoConv1TRT", "truthUnconvRecoConv1TRT",
241  "/MONITORING/truthUnconvRecoConv1TRT/", rootHistSvc);
242 
244  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
245  "truthUnconvRecoConv2TRT", "truthUnconvRecoConv2TRT",
246  "/MONITORING/truthUnconvRecoConv2TRT/", rootHistSvc);
247 
249  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
250  "truthUnconvRecoConv2SiTRT", "truthUnconvRecoConv2SiTRT",
251  "/MONITORING/truthUnconvRecoConv2SiTRT/", rootHistSvc);
252 
253  ATH_CHECK(truthPhotonConvRecoConv1TRT->initializePlots());
254  ATH_CHECK(truthPhotonConvRecoConv2TRT->initializePlots());
255  ATH_CHECK(truthPhotonConvRecoConv2SiTRT->initializePlots());
256  ATH_CHECK(truthPhotonUnconvRecoConv1TRT->initializePlots());
257  ATH_CHECK(truthPhotonUnconvRecoConv2TRT->initializePlots());
258  ATH_CHECK(truthPhotonUnconvRecoConv2SiTRT->initializePlots());
259  ATH_CHECK(clusterConvPhotonTRT->initializePlots());
260  ATH_CHECK(clusterConvPhotonTRTTRT->initializePlots());
261  ATH_CHECK(clusterConvPhotonSiTRT->initializePlots());
262  }
263 
264  // All truth
265  truthPhotonAll = std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
266  "truthPhotonAll", "truthPhotonAll", "/MONITORING/truthPhotonAll/",
267  rootHistSvc);
268 
270  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
271  "truthPhotonAllUnconv", "truthPhotonAllUnconv",
272  "/MONITORING/truthPhotonAllUnconv/", rootHistSvc);
273 
275  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
276  "truthPhotonAllConv", "truthPhotonAllConv",
277  "/MONITORING/truthPhotonAllConv/", rootHistSvc);
278 
280  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
281  "truthPhotonAllLateConv", "truthPhotonAllLateConv",
282  "/MONITORING/truthPhotonAllLateConv/", rootHistSvc);
283 
284  // Reco and truth-matched
286  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
287  "truthPhotonRecoPhoton", "truthPhotonRecoPhoton",
288  "/MONITORING/truthPhotonRecoPhoton/", rootHistSvc);
289 
291  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
292  "truthPhotonRecoPhotonOrElectron",
293  "truthPhotonRecoPhotonOrElectron",
294  "/MONITORING/truthPhotonRecoPhotonOrElectron/", rootHistSvc);
295 
297  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
298  "truthConvPhoton", "truthConvPhoton",
299  "/MONITORING/truthConvPhoton/", rootHistSvc);
300 
302  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
303  "truthConvRecoConv", "truthConvRecoConv",
304  "/MONITORING/truthConvRecoConv/", rootHistSvc);
305 
307  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
308  "truthConvRecoConv1Si", "truthConvRecoConv1Si",
309  "/MONITORING/truthConvRecoConv1Si/", rootHistSvc);
310 
312  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
313  "truthConvRecoConv2Si", "truthConvRecoConv2Si",
314  "/MONITORING/truthConvRecoConv2Si/", rootHistSvc);
315 
317  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
318  "truthConvRecoUnconv", "truthConvRecoUnconv",
319  "/MONITORING/truthConvRecoUnconv/", rootHistSvc);
320 
322  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
323  "truthUnconvPhoton", "truthUnconvPhoton",
324  "/MONITORING/truthUnconvPhoton/", rootHistSvc);
325 
327  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
328  "truthUnconvRecoConv", "truthUnconvRecoConv",
329  "/MONITORING/truthUnconvRecoConv/", rootHistSvc);
330 
332  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
333  "truthUnconvRecoConv1Si", "truthUnconvRecoConv1Si",
334  "/MONITORING/truthUnconvRecoConv1Si/", rootHistSvc);
335 
337  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
338  "truthUnconvRecoConv2Si", "truthUnconvRecoConv2Si",
339  "/MONITORING/truthUnconvRecoConv2Si/", rootHistSvc);
340 
342  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
343  "truthUnconvRecoUnconv", "truthUnconvRecoUnconv",
344  "/MONITORING/truthUnconvRecoUnconv/", rootHistSvc);
345 
347  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
348  "recoPhotonUnconvLoose", "Loose Photons Reco Photon",
349  "/MONITORING/recoPhotonUnconvLoose/", rootHistSvc);
350 
352  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
353  "recoPhotonUnconvTight", "Tight Photons Reco Photon",
354  "/MONITORING/recoPhotonUnconvTight/", rootHistSvc);
355 
357  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
358  "recoPhotonConvLoose", "Loose Photons Reco Photon",
359  "/MONITORING/recoPhotonConvLoose/", rootHistSvc);
360 
362  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
363  "recoPhotonConvTight", "Tight Photons Reco Photon",
364  "/MONITORING/recoPhotonConvTight/", rootHistSvc);
365 
367  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
368  "recoPhotonUnconvIsoFixedCutTight",
369  "Isolation Fixed Cut Tight Photons Reco Photon",
370  "/MONITORING/recoPhotonUnconvIsoFixedCutTight/", rootHistSvc);
371 
373  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
374  "recoPhotonUnconvIsoFixedCutTightCaloOnly",
375  "Isolation Fixed Cut Tight Calo Only Photons Reco Photon",
376  "/MONITORING/recoPhotonUnconvIsoFixedCutTightCaloOnly/",
377  rootHistSvc);
378 
380  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
381  "recoPhotonUnconvIsoFixedCutLoose",
382  "Isolation Fixed Cut Loose Photons Reco Photon",
383  "/MONITORING/recoPhotonUnconvIsoFixedCutLoose/", rootHistSvc);
384 
386  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
387  "recoPhotonConvIsoFixedCutTight",
388  "Isolation Fixed Cut Tight Photons Reco Photon",
389  "/MONITORING/recoPhotonConvIsoFixedCutTight/", rootHistSvc);
390 
392  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
393  "recoPhotonConvIsoFixedCutTightCaloOnly",
394  "Isolation Fixed Cut Tight Calo Only Photons Reco Photon",
395  "/MONITORING/recoPhotonConvIsoFixedCutTightCaloOnly/", rootHistSvc);
396 
398  std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
399  "recoPhotonConvIsoFixedCutLoose",
400  "Isolation Fixed Cut Loose Photons Reco Photon",
401  "/MONITORING/recoPhotonConvIsoFixedCutLoose/", rootHistSvc);
402 
403  // for the track monitoring, consider
404  // 4 track types (TRTSA or not, highpt or not) and
405  // 4 truth matching types (all / e / not e / pion / no truth match)
406  static const std::string typeMatch[5] = {"", "MatchElectron", "NotElectron",
407  "MatchPion", "NotMatched"};
408  static const std::string typeTrk[2] = {"", "TRT"};
409  static const std::string ptTrk[2] = {"", "highpT"};
410  static const std::string ctypeMatch[5] = {
411  "", " match to electrons", " not matched to electrons",
412  " match to pions", " not matched"};
413  static const std::string ctypeTrk[2] = {"", " TRTSA"};
414  static const std::string cptTrk[2] = {"", " pT > 3 GeV"};
415 
416  for (int im = 0; im < 5; im++) {
417  std::string mN = typeMatch[im];
418  for (int it = 0; it < (m_hasTRT ? 2 : 1); it++) {
419  std::string tN = typeTrk[it];
420  for (int ip = 0; ip < 2; ip++) {
421  std::string pN = ptTrk[ip];
422 
423  std::string nN =
424  "InDetTracks" + typeTrk[it] + typeMatch[im] + ptTrk[ip];
425  std::string fN = "/MONITORING/" + nN + "/";
426  std::string cN =
427  "InDet Tracks" + ctypeTrk[it] + ctypeMatch[im] + cptTrk[ip];
428 
429  ATH_MSG_INFO("Creating histograms for " << nN);
430  mapTrkHistograms[nN] =
431  std::make_unique<egammaMonitoring::TrackHistograms>(
432  nN.c_str(), cN.c_str(), fN.c_str(), rootHistSvc);
433  ATH_CHECK(mapTrkHistograms[nN]->initializePlots());
434  }
435  }
436  }
437 
438  ATH_CHECK(truthPhotonAll->initializePlots());
439  ATH_CHECK(truthPhotonAllUnconv->initializePlots());
440  ATH_CHECK(truthPhotonAllConv->initializePlots());
441  ATH_CHECK(truthPhotonAllLateConv->initializePlots());
442  ATH_CHECK(truthPhotonRecoPhoton->initializePlots());
443  ATH_CHECK(truthPhotonRecoPhotonOrElectron->initializePlots());
444 
445  ATH_CHECK(truthPhotonConvPhoton->initializePlots());
446  ATH_CHECK(truthPhotonConvRecoConv->initializePlots());
447  ATH_CHECK(truthPhotonConvRecoConv1Si->initializePlots());
448  ATH_CHECK(truthPhotonConvRecoConv2Si->initializePlots());
449  ATH_CHECK(truthPhotonConvRecoUnconv->initializePlots());
450 
451  ATH_CHECK(truthPhotonUnconvPhoton->initializePlots());
452  ATH_CHECK(truthPhotonUnconvRecoConv->initializePlots());
453  ATH_CHECK(truthPhotonUnconvRecoConv1Si->initializePlots());
454  ATH_CHECK(truthPhotonUnconvRecoConv2Si->initializePlots());
455  ATH_CHECK(truthPhotonUnconvRecoUnconv->initializePlots());
456 
457  ATH_CHECK(recoPhotonUnconvLoose->initializePlots());
458  ATH_CHECK(recoPhotonUnconvTight->initializePlots());
459  ATH_CHECK(recoPhotonConvLoose->initializePlots());
460  ATH_CHECK(recoPhotonConvTight->initializePlots());
461  ATH_CHECK(recoPhotonUnconvIsoFixedCutTight->initializePlots());
463  ATH_CHECK(recoPhotonUnconvIsoFixedCutLoose->initializePlots());
464  ATH_CHECK(recoPhotonConvIsoFixedCutTight->initializePlots());
466  ATH_CHECK(recoPhotonConvIsoFixedCutLoose->initializePlots());
467 
468  } // gamma Hists
469 
470  if (m_sampleType != "gamma") {
473  }
474 
475  if ("electron" == m_sampleType) {
476  //*****************ID selectors (3 levels)********************
477  ATH_CHECK(m_Loose_Ele.retrieve());
478  ATH_CHECK(m_Medium_Ele.retrieve());
479  ATH_CHECK(m_Tight_Ele.retrieve());
480 
482 
483  if (!m_FwdElectronsKey.empty()) {
484  m_dR1 = new TH1D("dR1", ";#Delta R;Events", 1000, 0, 0.1);
485  ATH_CHECK(rootHistSvc->regHist("/MONITORING/Check/dR1", m_dR1));
486  m_dR2 = new TH1D("dR2", ";#Delta R;Events", 1000, 0, 0.1);
487  ATH_CHECK(rootHistSvc->regHist("/MONITORING/Check/dR2", m_dR2));
488 
489  ATH_CHECK(m_Loose_FwdEle.retrieve());
490  ATH_CHECK(m_Medium_FwdEle.retrieve());
491  ATH_CHECK(m_Tight_FwdEle.retrieve());
492  }
493  }
494 
495  if ("gamma" == m_sampleType) {
496  //*****************ID selectors (2 levels)********************
497  ATH_CHECK(m_Loose_Photon.retrieve());
498  ATH_CHECK(m_Tight_Photon.retrieve());
499 
500  //*****************Iso Requirements********************
501  ATH_CHECK(m_IsoFixedCutTight.retrieve());
503  ATH_CHECK(m_IsoFixedCutLoose.retrieve());
504 
505  ATH_CHECK(m_PhotonsKey.initialize());
506  }
507 
508  //***************** The handles used whatever the sample********************
511 
512  if (m_sampleType != "dataZ") {
515 
516  //*****************MC Truth Classifier Requirement********************
517  ATH_CHECK(m_mcTruthClassifier.retrieve());
518  }
519 
520  return StatusCode::SUCCESS;
521 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ matchedToElectron()

bool EgammaMonitoring::matchedToElectron ( const xAOD::TrackParticle tp)
staticprivate

Definition at line 1325 of file EgammaMonitoring.cxx.

1325  {
1327  return truth && abs(truth->pdgId()) == 11;
1328 }

◆ matchedToPion()

bool EgammaMonitoring::matchedToPion ( const xAOD::TrackParticle tp)
staticprivate

Definition at line 1330 of file EgammaMonitoring.cxx.

1330  {
1332  return truth && abs(truth->pdgId()) == 211;
1333 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ notMatchedToTruth()

bool EgammaMonitoring::notMatchedToTruth ( const xAOD::TrackParticle tp)
staticprivate

Definition at line 1335 of file EgammaMonitoring.cxx.

1335  {
1337  return !truth;
1338 }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ ZeePostProc()

StatusCode EgammaMonitoring::ZeePostProc ( )
private

Definition at line 1384 of file EgammaMonitoring.cxx.

1384  {
1385 
1386  TH1D *hRef = (TH1D *)m_diElectron->histoMap["mass"];
1387  double xmi = 66, xma = 116, eps = 0.01;
1388  int ib1 = hRef->FindBin(xmi + eps);
1389  int ib2 = hRef->FindBin(xma - eps);
1390  TH1D *hmee = new TH1D("mee", ";m_{ee} [GeV];Events / 0.5 GeV", ib2 - ib1 + 1,
1391  xmi, xma);
1392  for (int ib = ib1; ib <= ib2; ib++) {
1393  double c = hRef->GetBinContent(ib);
1394  double ec = hRef->GetBinError(ib);
1395  hmee->SetBinContent(ib - ib1 + 1, c);
1396  hmee->SetBinError(ib - ib1 + 1, ec);
1397  }
1398  ATH_CHECK(rootHistSvc->regHist("/MONITORING/Data/mee", hmee));
1399 
1400  TString vsX[3] = {"Et", "Etetale0p8", "Eta"};
1401  TString coo[3] = {"x", "x", "y"};
1402  for (int iL = 0; iL < 5; iL++) {
1403  TH3D *nRef;
1404  if (iL < 4)
1405  nRef = m_clusterReco->m_histo3DMap[Form("hNcellsvseteta_Lr%i", iL)];
1406  else
1407  nRef = recoElectronAll->histo3DMap["eteta_eop"];
1408  for (int iX = 0; iX < 3; iX++) {
1409  if (iL == 4 && iX == 2)
1410  continue;
1411  // nCells vs eta
1412  if (iX == 1) {
1413  int ieta08 = nRef->GetYaxis()->FindBin(0.79);
1414  nRef->GetYaxis()->SetRange(1, ieta08);
1415  } else if (iX == 2) {
1416  nRef->GetYaxis()->SetRange(1, 25);
1417  }
1418  TH2D *nRefvsX = (TH2D *)nRef->Project3D(Form("z%s", coo[iX].Data()));
1419  TString pN;
1420  if (iL < 4)
1421  pN = Form("pn%ivs%s", iL, vsX[iX].Data());
1422  else
1423  pN = Form("pEopvs%s", vsX[iX].Data());
1424  TProfile *pRefvsX = nRefvsX->ProfileX(pN.Data());
1425  pRefvsX->SetTitle(pN.Data());
1426  pRefvsX->GetXaxis()->SetTitle(iX < 2 ? "E_{T} [GeV]" : "|#eta|");
1427  pRefvsX->GetYaxis()->SetTitle(iL < 4 ? Form("nCells_Lr%i", iL) : "E/p");
1428  ATH_CHECK(rootHistSvc->regHist(
1429  Form("/MONITORING/Data/%s", pRefvsX->GetName()), pRefvsX));
1430  delete nRefvsX;
1431  }
1432  }
1433  return StatusCode::SUCCESS;
1434 }

◆ ZeeSelection()

StatusCode EgammaMonitoring::ZeeSelection ( float  mu,
const EventContext &  ctx 
)
private

Definition at line 1340 of file EgammaMonitoring.cxx.

1340  {
1343  ctx);
1344 
1345  const xAOD::Electron *e1 = nullptr, *e2 = nullptr;
1346  double pTL = -9e9, pTSL = -9e9;
1347  for (const auto *el : *RecoEl) {
1348  double pt = el->pt();
1349  if (pt < 15e3)
1350  continue;
1351  if (pt > pTL) {
1352  e2 = e1;
1353  pTSL = pTL;
1354  e1 = el;
1355  pTL = pt;
1356  } else if (pt > pTSL) {
1357  e2 = el;
1358  pTSL = pt;
1359  }
1360  }
1361 
1362  if (!e2)
1363  return StatusCode::SUCCESS;
1364 
1365  m_diElectron->fill(*e1, *e2, mu);
1366 
1367  m_clusterReco->fill(*e1);
1368  m_clusterReco->fill(*e2);
1369  recoElectronAll->fill(*e1);
1370  recoElectronAll->fill(*e2);
1371 
1372  showerShapesAll->fill(*e1);
1373  showerShapesAll->fill(*e2);
1374  if (e1->pt() > 10 * Gaudi::Units::GeV)
1375  showerShapes10GeV->fill(*e1);
1376  if (e2->pt() > 10 * Gaudi::Units::GeV)
1377  showerShapes10GeV->fill(*e2);
1378  isolationAll->fill(*e1);
1379  isolationAll->fill(*e2);
1380 
1381  return StatusCode::SUCCESS;
1382 }

Member Data Documentation

◆ cluster10GeV

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::cluster10GeV

Definition at line 57 of file EgammaMonitoring.h.

◆ clusterAll

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterAll

Definition at line 56 of file EgammaMonitoring.h.

◆ clusterConvPhoton

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterConvPhoton

Definition at line 94 of file EgammaMonitoring.h.

◆ clusterConvPhotonSi

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterConvPhotonSi

Definition at line 95 of file EgammaMonitoring.h.

◆ clusterConvPhotonSiSi

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterConvPhotonSiSi

Definition at line 96 of file EgammaMonitoring.h.

◆ clusterConvPhotonSiTRT

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterConvPhotonSiTRT

Definition at line 99 of file EgammaMonitoring.h.

◆ clusterConvPhotonTRT

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterConvPhotonTRT

Definition at line 97 of file EgammaMonitoring.h.

◆ clusterConvPhotonTRTTRT

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterConvPhotonTRTTRT

Definition at line 98 of file EgammaMonitoring.h.

◆ clusterPrompt10GeV

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterPrompt10GeV

Definition at line 60 of file EgammaMonitoring.h.

◆ clusterPromptAll

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterPromptAll

Definition at line 59 of file EgammaMonitoring.h.

◆ clusterUnconvPhoton

std::unique_ptr<egammaMonitoring::ClusterHistograms> EgammaMonitoring::clusterUnconvPhoton

Definition at line 100 of file EgammaMonitoring.h.

◆ isolationAll

std::unique_ptr<egammaMonitoring::IsolationHistograms> EgammaMonitoring::isolationAll

Definition at line 65 of file EgammaMonitoring.h.

◆ m_CenFwdOverlap

int EgammaMonitoring::m_CenFwdOverlap[2] = { 0, 0 }
private

Definition at line 228 of file EgammaMonitoring.h.

◆ m_clusterReco

std::unique_ptr<egammaMonitoring::RecoClusterHistograms> EgammaMonitoring::m_clusterReco

Definition at line 68 of file EgammaMonitoring.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_diElectron

std::unique_ptr<egammaMonitoring::DiObjectHistograms> EgammaMonitoring::m_diElectron

Definition at line 69 of file EgammaMonitoring.h.

◆ m_dR1

TH1D* EgammaMonitoring::m_dR1 {}
private

Definition at line 230 of file EgammaMonitoring.h.

◆ m_dR2

TH1D* EgammaMonitoring::m_dR2 {}
private

Definition at line 231 of file EgammaMonitoring.h.

◆ m_egTruthParticlesKey

SG::ReadHandleKey<xAOD::TruthParticleContainer> EgammaMonitoring::m_egTruthParticlesKey { this, "egammaTruthParticlesKey", "", "" }
private

Definition at line 200 of file EgammaMonitoring.h.

◆ m_ElectronsKey

SG::ReadHandleKey<xAOD::ElectronContainer> EgammaMonitoring::m_ElectronsKey { this, "ElectronsKey", "", "" }
private

Definition at line 206 of file EgammaMonitoring.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> EgammaMonitoring::m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }
private

Definition at line 197 of file EgammaMonitoring.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_FwdElectronsKey

SG::ReadHandleKey<xAOD::ElectronContainer> EgammaMonitoring::m_FwdElectronsKey { this, "FwdElectronsKey", "", "" }
private

Definition at line 209 of file EgammaMonitoring.h.

◆ m_GSFTrackParticlesKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> EgammaMonitoring::m_GSFTrackParticlesKey { this, "GSFTrackParticlesKey", "", "" }
private

Definition at line 218 of file EgammaMonitoring.h.

◆ m_hasTRT

Gaudi::Property<bool> EgammaMonitoring::m_hasTRT { this, "hasTRT", true, "is there a TRT in the ID" }
private

is it run 3 or run 4 and later ?

Definition at line 160 of file EgammaMonitoring.h.

◆ m_InDetTrackParticlesKey

SG::ReadHandleKey<xAOD::TrackParticleContainer> EgammaMonitoring::m_InDetTrackParticlesKey { this, "InDetTrackParticlesKey", "InDetTrackParticles", "" }
private

Definition at line 215 of file EgammaMonitoring.h.

◆ m_IsoFixedCutLoose

ToolHandle<CP::IIsolationSelectionTool> EgammaMonitoring::m_IsoFixedCutLoose { this, "IsoFixedCutLoose", "", "" }
private

Definition at line 189 of file EgammaMonitoring.h.

◆ m_IsoFixedCutTight

ToolHandle<CP::IIsolationSelectionTool> EgammaMonitoring::m_IsoFixedCutTight { this, "IsoFixedCutTight", "", "" }
private

Definition at line 185 of file EgammaMonitoring.h.

◆ m_IsoFixedCutTightCaloOnly

ToolHandle<CP::IIsolationSelectionTool> EgammaMonitoring::m_IsoFixedCutTightCaloOnly { this, "IsoTightCaloOnly", "", "" }
private

Definition at line 187 of file EgammaMonitoring.h.

◆ m_Loose_Ele

ToolHandle<IAsgElectronLikelihoodTool> EgammaMonitoring::m_Loose_Ele { this, "Loose_Ele", "", "" }
private

Selector tools.

Definition at line 165 of file EgammaMonitoring.h.

◆ m_Loose_FwdEle

ToolHandle<IAsgElectronLikelihoodTool> EgammaMonitoring::m_Loose_FwdEle { this, "Loose_FwdEle", "", "" }
private

Definition at line 171 of file EgammaMonitoring.h.

◆ m_Loose_Photon

ToolHandle<IAsgPhotonIsEMSelector> EgammaMonitoring::m_Loose_Photon { this, "Loose_Photon", "", "" }
private

Definition at line 179 of file EgammaMonitoring.h.

◆ m_mcTruthClassifier

ToolHandle<IMCTruthClassifier> EgammaMonitoring::m_mcTruthClassifier { this, "MCTruthClassifier", "", "" }
private

Definition at line 193 of file EgammaMonitoring.h.

◆ m_Medium_Ele

ToolHandle<IAsgElectronLikelihoodTool> EgammaMonitoring::m_Medium_Ele { this, "Medium_Ele", "", "" }
private

Definition at line 167 of file EgammaMonitoring.h.

◆ m_Medium_FwdEle

ToolHandle<IAsgElectronLikelihoodTool> EgammaMonitoring::m_Medium_FwdEle { this, "Medium_FwdEle", "", "" }
private

Definition at line 173 of file EgammaMonitoring.h.

◆ m_PhotonsKey

SG::ReadHandleKey<xAOD::PhotonContainer> EgammaMonitoring::m_PhotonsKey { this, "PhotonsKey", "", "" }
private

Definition at line 212 of file EgammaMonitoring.h.

◆ m_sampleType

Gaudi::Property<std::string> EgammaMonitoring::m_sampleType { this, "sampleType", "Unknown", "electron or gamma" }
private

Sample name ///.

Definition at line 156 of file EgammaMonitoring.h.

◆ m_Tight_Ele

ToolHandle<IAsgElectronLikelihoodTool> EgammaMonitoring::m_Tight_Ele { this, "Tight_Ele", "", "" }
private

Definition at line 169 of file EgammaMonitoring.h.

◆ m_Tight_FwdEle

ToolHandle<IAsgElectronLikelihoodTool> EgammaMonitoring::m_Tight_FwdEle { this, "Tight_FwdEle", "", "" }
private

Definition at line 175 of file EgammaMonitoring.h.

◆ m_Tight_Photon

ToolHandle<IAsgPhotonIsEMSelector> EgammaMonitoring::m_Tight_Photon { this, "Tight_Photon", "", "" }
private

Definition at line 181 of file EgammaMonitoring.h.

◆ m_truthParticlesKey

SG::ReadHandleKey<xAOD::TruthParticleContainer> EgammaMonitoring::m_truthParticlesKey { this, "truthParticlesKey", "", "" }
private

Definition at line 203 of file EgammaMonitoring.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

◆ mapTrkHistograms

std::map<std::string,std::unique_ptr<egammaMonitoring::TrackHistograms> > EgammaMonitoring::mapTrkHistograms

Definition at line 142 of file EgammaMonitoring.h.

◆ recoElectronAll

std::unique_ptr<egammaMonitoring::RecoElectronHistograms> EgammaMonitoring::recoElectronAll

Definition at line 72 of file EgammaMonitoring.h.

◆ recoPhotonAll

std::unique_ptr<egammaMonitoring::RecoPhotonHistograms> EgammaMonitoring::recoPhotonAll

Definition at line 102 of file EgammaMonitoring.h.

◆ recoPhotonConvIsoFixedCutLoose

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonConvIsoFixedCutLoose

Definition at line 140 of file EgammaMonitoring.h.

◆ recoPhotonConvIsoFixedCutTight

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonConvIsoFixedCutTight

Definition at line 137 of file EgammaMonitoring.h.

◆ recoPhotonConvIsoFixedCutTightCaloOnly

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonConvIsoFixedCutTightCaloOnly

Definition at line 139 of file EgammaMonitoring.h.

◆ recoPhotonConvLoose

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonConvLoose

Definition at line 129 of file EgammaMonitoring.h.

◆ recoPhotonConvTight

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonConvTight

Definition at line 130 of file EgammaMonitoring.h.

◆ recoPhotonUnconvIsoFixedCutLoose

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonUnconvIsoFixedCutLoose

Definition at line 136 of file EgammaMonitoring.h.

◆ recoPhotonUnconvIsoFixedCutTight

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonUnconvIsoFixedCutTight

Definition at line 132 of file EgammaMonitoring.h.

◆ recoPhotonUnconvIsoFixedCutTightCaloOnly

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonUnconvIsoFixedCutTightCaloOnly

Definition at line 134 of file EgammaMonitoring.h.

◆ recoPhotonUnconvLoose

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonUnconvLoose

Definition at line 127 of file EgammaMonitoring.h.

◆ recoPhotonUnconvTight

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::recoPhotonUnconvTight

Definition at line 128 of file EgammaMonitoring.h.

◆ rootHistSvc

SmartIF<ITHistSvc> EgammaMonitoring::rootHistSvc

Tools and services ///.

Definition at line 53 of file EgammaMonitoring.h.

◆ showerShapes10GeV

std::unique_ptr<egammaMonitoring::ShowerShapesHistograms> EgammaMonitoring::showerShapes10GeV

Definition at line 64 of file EgammaMonitoring.h.

◆ showerShapesAll

std::unique_ptr<egammaMonitoring::ShowerShapesHistograms> EgammaMonitoring::showerShapesAll

Definition at line 63 of file EgammaMonitoring.h.

◆ truthElectronAll

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthElectronAll

Definition at line 73 of file EgammaMonitoring.h.

◆ truthElectronRecoElectronAll

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthElectronRecoElectronAll

Definition at line 77 of file EgammaMonitoring.h.

◆ truthPhotonAll

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonAll

Definition at line 103 of file EgammaMonitoring.h.

◆ truthPhotonAllConv

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonAllConv

Definition at line 105 of file EgammaMonitoring.h.

◆ truthPhotonAllLateConv

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonAllLateConv

Definition at line 106 of file EgammaMonitoring.h.

◆ truthPhotonAllUnconv

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonAllUnconv

Definition at line 104 of file EgammaMonitoring.h.

◆ truthPhotonConvPhoton

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonConvPhoton

Definition at line 110 of file EgammaMonitoring.h.

◆ truthPhotonConvRecoConv

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonConvRecoConv

Definition at line 111 of file EgammaMonitoring.h.

◆ truthPhotonConvRecoConv1Si

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonConvRecoConv1Si

Definition at line 112 of file EgammaMonitoring.h.

◆ truthPhotonConvRecoConv1TRT

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonConvRecoConv1TRT

Definition at line 113 of file EgammaMonitoring.h.

◆ truthPhotonConvRecoConv2Si

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonConvRecoConv2Si

Definition at line 114 of file EgammaMonitoring.h.

◆ truthPhotonConvRecoConv2SiTRT

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonConvRecoConv2SiTRT

Definition at line 116 of file EgammaMonitoring.h.

◆ truthPhotonConvRecoConv2TRT

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonConvRecoConv2TRT

Definition at line 115 of file EgammaMonitoring.h.

◆ truthPhotonConvRecoUnconv

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonConvRecoUnconv

Definition at line 117 of file EgammaMonitoring.h.

◆ truthPhotonRecoPhoton

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonRecoPhoton

Definition at line 107 of file EgammaMonitoring.h.

◆ truthPhotonRecoPhotonOrElectron

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonRecoPhotonOrElectron

Definition at line 109 of file EgammaMonitoring.h.

◆ truthPhotonUnconvPhoton

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonUnconvPhoton

Definition at line 118 of file EgammaMonitoring.h.

◆ truthPhotonUnconvRecoConv

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonUnconvRecoConv

Definition at line 119 of file EgammaMonitoring.h.

◆ truthPhotonUnconvRecoConv1Si

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonUnconvRecoConv1Si

Definition at line 120 of file EgammaMonitoring.h.

◆ truthPhotonUnconvRecoConv1TRT

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonUnconvRecoConv1TRT

Definition at line 121 of file EgammaMonitoring.h.

◆ truthPhotonUnconvRecoConv2Si

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonUnconvRecoConv2Si

Definition at line 122 of file EgammaMonitoring.h.

◆ truthPhotonUnconvRecoConv2SiTRT

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonUnconvRecoConv2SiTRT

Definition at line 125 of file EgammaMonitoring.h.

◆ truthPhotonUnconvRecoConv2TRT

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonUnconvRecoConv2TRT

Definition at line 123 of file EgammaMonitoring.h.

◆ truthPhotonUnconvRecoUnconv

std::unique_ptr<egammaMonitoring::IHistograms> EgammaMonitoring::truthPhotonUnconvRecoUnconv

Definition at line 126 of file EgammaMonitoring.h.

◆ truthPromptElectronAll

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthPromptElectronAll

Definition at line 75 of file EgammaMonitoring.h.

◆ truthPromptElectronWithGSFTrack

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthPromptElectronWithGSFTrack

Definition at line 81 of file EgammaMonitoring.h.

◆ truthPromptElectronWithReco

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthPromptElectronWithReco

Definition at line 83 of file EgammaMonitoring.h.

◆ truthPromptElectronWithRecoTrack

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthPromptElectronWithRecoTrack

Definition at line 85 of file EgammaMonitoring.h.

◆ truthPromptElectronWithTrack

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthPromptElectronWithTrack

Definition at line 79 of file EgammaMonitoring.h.

◆ truthRecoElectronLoose

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthRecoElectronLoose

Definition at line 87 of file EgammaMonitoring.h.

◆ truthRecoElectronMedium

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthRecoElectronMedium

Definition at line 89 of file EgammaMonitoring.h.

◆ truthRecoElectronTight

std::unique_ptr<egammaMonitoring::TruthElectronHistograms> EgammaMonitoring::truthRecoElectronTight

Definition at line 91 of file EgammaMonitoring.h.


The documentation for this class was generated from the following files:
EgammaMonitoring::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: EgammaMonitoring.h:198
EgammaMonitoring::recoPhotonConvTight
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonConvTight
Definition: EgammaMonitoring.h:130
EgammaMonitoring::truthPhotonUnconvRecoConv
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonUnconvRecoConv
Definition: EgammaMonitoring.h:119
EgammaMonitoring::m_IsoFixedCutTight
ToolHandle< CP::IIsolationSelectionTool > m_IsoFixedCutTight
Definition: EgammaMonitoring.h:186
EgammaMonitoring::mapTrkHistograms
std::map< std::string, std::unique_ptr< egammaMonitoring::TrackHistograms > > mapTrkHistograms
Definition: EgammaMonitoring.h:142
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
xAOD::EgammaHelpers::getRecoPhoton
const xAOD::Photon * getRecoPhoton(const xAOD::TruthParticle *particle)
return the reco photon associated to the given TruthParticle (if any)
Definition: EgammaTruthxAODHelpers.cxx:54
EgammaMonitoring::truthPhotonConvRecoUnconv
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonConvRecoUnconv
Definition: EgammaMonitoring.h:117
EgammaMonitoring::truthPhotonUnconvRecoUnconv
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonUnconvRecoUnconv
Definition: EgammaMonitoring.h:126
EgammaMonitoring::m_IsoFixedCutLoose
ToolHandle< CP::IIsolationSelectionTool > m_IsoFixedCutLoose
Definition: EgammaMonitoring.h:190
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
EgammaMonitoring::clusterPrompt10GeV
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterPrompt10GeV
Definition: EgammaMonitoring.h:60
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
EgammaMonitoring::matchedToPion
static bool matchedToPion(const xAOD::TrackParticle &tp)
Definition: EgammaMonitoring.cxx:1330
EgammaMonitoring::recoPhotonUnconvLoose
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonUnconvLoose
Definition: EgammaMonitoring.h:127
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
EgammaMonitoring::notMatchedToTruth
static bool notMatchedToTruth(const xAOD::TrackParticle &tp)
Definition: EgammaMonitoring.cxx:1335
EgammaMonitoring::recoPhotonConvIsoFixedCutTight
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonConvIsoFixedCutTight
Definition: EgammaMonitoring.h:137
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
EgammaMonitoring::truthPhotonAllConv
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonAllConv
Definition: EgammaMonitoring.h:105
Data
@ Data
Definition: BaseObject.h:11
EgammaMonitoring::m_egTruthParticlesKey
SG::ReadHandleKey< xAOD::TruthParticleContainer > m_egTruthParticlesKey
Definition: EgammaMonitoring.h:201
skel.it
it
Definition: skel.GENtoEVGEN.py:396
EgammaMonitoring::truthPhotonConvRecoConv
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonConvRecoConv
Definition: EgammaMonitoring.h:111
test_pyathena.pt
pt
Definition: test_pyathena.py:11
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
PlotCalibFromCool.ib
ib
Definition: PlotCalibFromCool.py:419
EgammaMonitoring::m_Medium_FwdEle
ToolHandle< IAsgElectronLikelihoodTool > m_Medium_FwdEle
Definition: EgammaMonitoring.h:174
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
python.atlas_oh.im
im
Definition: atlas_oh.py:167
ParticleTest.tp
tp
Definition: ParticleTest.py:25
SingleElec
@ SingleElec
Definition: TruthClasses.h:54
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
EgammaMonitoring::truthPhotonUnconvRecoConv2TRT
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonUnconvRecoConv2TRT
Definition: EgammaMonitoring.h:123
xAOD
ICaloAffectedTool is abstract interface for tools checking if 4 mom is in calo affected region.
Definition: ICaloAffectedTool.h:24
xAOD::numberOfPixelHits
@ numberOfPixelHits
these are the pixel hits, including the b-layer [unit8_t].
Definition: TrackingPrimitives.h:259
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
xAOD::EgammaParameters::ConversionType
ConversionType
Definition: EgammaEnums.h:268
isValid
bool isValid(const T &p)
Av: we implement here an ATLAS-sepcific convention: all particles which are 99xxxxx are fine.
Definition: AtlasPID.h:620
const
bool const RAWDATA *ch2 const
Definition: LArRodBlockPhysicsV0.cxx:560
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
python.compareTCTs.nRef
nRef
Definition: compareTCTs.py:115
EgammaMonitoring::m_truthParticlesKey
SG::ReadHandleKey< xAOD::TruthParticleContainer > m_truthParticlesKey
Definition: EgammaMonitoring.h:204
EgammaMonitoring::m_mcTruthClassifier
ToolHandle< IMCTruthClassifier > m_mcTruthClassifier
Definition: EgammaMonitoring.h:194
EgammaMonitoring::ZeeSelection
StatusCode ZeeSelection(float mu, const EventContext &ctx)
Definition: EgammaMonitoring.cxx:1340
EgammaMonitoring::m_GSFTrackParticlesKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_GSFTrackParticlesKey
Definition: EgammaMonitoring.h:219
xAOD::EgammaHelpers::getBkgElectronMother
const xAOD::TruthParticle * getBkgElectronMother(const xAOD::Electron *el, const bool allTheWayBack=true)
Helper wrapper function for calling the function above extracting the truth from a reco electron.
Definition: EgammaTruthxAODHelpers.cxx:133
Photon
Class describing an photon
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
EgammaMonitoring::m_PhotonsKey
SG::ReadHandleKey< xAOD::PhotonContainer > m_PhotonsKey
Definition: EgammaMonitoring.h:213
EgammaMonitoring::recoPhotonUnconvIsoFixedCutLoose
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonUnconvIsoFixedCutLoose
Definition: EgammaMonitoring.h:136
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
EgammaMonitoring::truthPromptElectronWithGSFTrack
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthPromptElectronWithGSFTrack
Definition: EgammaMonitoring.h:81
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
EgammaMonitoring::m_Tight_Photon
ToolHandle< IAsgPhotonIsEMSelector > m_Tight_Photon
Definition: EgammaMonitoring.h:182
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
EgammaMonitoring::clusterAll
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterAll
Definition: EgammaMonitoring.h:56
EgammaMonitoring::truthPromptElectronWithRecoTrack
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthPromptElectronWithRecoTrack
Definition: EgammaMonitoring.h:85
EgammaMonitoring::truthRecoElectronTight
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthRecoElectronTight
Definition: EgammaMonitoring.h:91
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
xAOD::EgammaHelpers::isConvertedPhoton
bool isConvertedPhoton(const xAOD::Egamma *eg, bool excludeTRT=false)
is the object a converted photon
Definition: EgammaxAODHelpers.cxx:25
AthCommonDataStore
Definition: AthCommonDataStore.h:52
EgammaMonitoring::truthPhotonUnconvPhoton
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonUnconvPhoton
Definition: EgammaMonitoring.h:118
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
EgammaMonitoring::truthPhotonConvRecoConv2Si
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonConvRecoConv2Si
Definition: EgammaMonitoring.h:114
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
EgammaMonitoring::rootHistSvc
SmartIF< ITHistSvc > rootHistSvc
Tools and services ///.
Definition: EgammaMonitoring.h:53
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
EgammaMonitoring::truthPhotonUnconvRecoConv1TRT
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonUnconvRecoConv1TRT
Definition: EgammaMonitoring.h:121
EgammaMonitoring::m_Tight_Ele
ToolHandle< IAsgElectronLikelihoodTool > m_Tight_Ele
Definition: EgammaMonitoring.h:170
EgammaMonitoring::m_diElectron
std::unique_ptr< egammaMonitoring::DiObjectHistograms > m_diElectron
Definition: EgammaMonitoring.h:69
EgammaMonitoring::m_dR1
TH1D * m_dR1
Definition: EgammaMonitoring.h:230
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
EgammaMonitoring::showerShapes10GeV
std::unique_ptr< egammaMonitoring::ShowerShapesHistograms > showerShapes10GeV
Definition: EgammaMonitoring.h:64
EgammaMonitoring::ZeePostProc
StatusCode ZeePostProc()
Definition: EgammaMonitoring.cxx:1384
EgammaMonitoring::recoElectronAll
std::unique_ptr< egammaMonitoring::RecoElectronHistograms > recoElectronAll
Definition: EgammaMonitoring.h:72
EgammaMonitoring::m_Tight_FwdEle
ToolHandle< IAsgElectronLikelihoodTool > m_Tight_FwdEle
Definition: EgammaMonitoring.h:176
EgammaMonitoring::recoPhotonUnconvIsoFixedCutTightCaloOnly
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonUnconvIsoFixedCutTightCaloOnly
Definition: EgammaMonitoring.h:134
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
EgammaMonitoring::m_CenFwdOverlap
int m_CenFwdOverlap[2]
Definition: EgammaMonitoring.h:228
ParticleOrigin
ParticleOrigin
Definition: TruthClasses.h:51
EgammaMonitoring::truthPhotonUnconvRecoConv1Si
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonUnconvRecoConv1Si
Definition: EgammaMonitoring.h:120
xAOD::TruthParticle_v1
Class describing a truth particle in the MC record.
Definition: TruthParticle_v1.h:37
EgammaMonitoring::isolationAll
std::unique_ptr< egammaMonitoring::IsolationHistograms > isolationAll
Definition: EgammaMonitoring.h:65
EgammaMonitoring::clusterConvPhotonSi
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterConvPhotonSi
Definition: EgammaMonitoring.h:95
xAOD::TruthVertex_v1::perp
float perp() const
Vertex transverse distance from the beam line.
Definition: TruthVertex_v1.cxx:163
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:14
EgammaMonitoring::clusterPromptAll
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterPromptAll
Definition: EgammaMonitoring.h:59
xAOD::EgammaParameters::doubleSi
@ doubleSi
two tracks, both with Si hits
Definition: EgammaEnums.h:279
plotIsoValidation.el
el
Definition: plotIsoValidation.py:197
EgammaMonitoring::m_dR2
TH1D * m_dR2
Definition: EgammaMonitoring.h:231
EgammaMonitoring::truthPromptElectronAll
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthPromptElectronAll
Definition: EgammaMonitoring.h:75
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
EgammaMonitoring::showerShapesAll
std::unique_ptr< egammaMonitoring::ShowerShapesHistograms > showerShapesAll
Definition: EgammaMonitoring.h:63
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
EgammaMonitoring::m_IsoFixedCutTightCaloOnly
ToolHandle< CP::IIsolationSelectionTool > m_IsoFixedCutTightCaloOnly
Definition: EgammaMonitoring.h:188
EgammaMonitoring::clusterUnconvPhoton
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterUnconvPhoton
Definition: EgammaMonitoring.h:100
EgammaMonitoring::matchedToElectron
static bool matchedToElectron(const xAOD::TrackParticle &tp)
Definition: EgammaMonitoring.cxx:1325
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
MC::isSingleParticle
bool isSingleParticle(const T &p)
Identify a particlegun particle.
Definition: HepMCHelpers.h:74
EgammaMonitoring::truthPhotonAllUnconv
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonAllUnconv
Definition: EgammaMonitoring.h:104
EgammaMonitoring::clusterConvPhoton
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterConvPhoton
Definition: EgammaMonitoring.h:94
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
EgammaMonitoring::m_sampleType
Gaudi::Property< std::string > m_sampleType
Sample name ///.
Definition: EgammaMonitoring.h:157
EgammaMonitoring::truthPhotonConvRecoConv2SiTRT
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonConvRecoConv2SiTRT
Definition: EgammaMonitoring.h:116
EgammaMonitoring::truthPhotonAll
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonAll
Definition: EgammaMonitoring.h:103
EgammaMonitoring::truthPhotonAllLateConv
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonAllLateConv
Definition: EgammaMonitoring.h:106
EgammaMonitoring::clusterConvPhotonSiSi
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterConvPhotonSiSi
Definition: EgammaMonitoring.h:96
EgammaMonitoring::recoPhotonConvIsoFixedCutLoose
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonConvIsoFixedCutLoose
Definition: EgammaMonitoring.h:140
xAOD::EgammaParameters::doubleSiTRT
@ doubleSiTRT
two tracks, only one with Si hits
Definition: EgammaEnums.h:285
EgammaMonitoring::clusterConvPhotonTRTTRT
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterConvPhotonTRTTRT
Definition: EgammaMonitoring.h:98
xAOD::EgammaParameters::singleTRT
@ singleTRT
one track only, no Si hits (TRT only)
Definition: EgammaEnums.h:276
EgammaMonitoring::truthPhotonUnconvRecoConv2Si
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonUnconvRecoConv2Si
Definition: EgammaMonitoring.h:122
EgammaMonitoring::truthPhotonRecoPhoton
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonRecoPhoton
Definition: EgammaMonitoring.h:107
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
fill
void fill(H5::Group &out_file, size_t iterations)
Definition: test-hdf5-writer.cxx:95
EgammaMonitoring::truthPhotonConvRecoConv2TRT
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonConvRecoConv2TRT
Definition: EgammaMonitoring.h:115
Athena::Units
Definition: Units.h:45
EgammaMonitoring::m_InDetTrackParticlesKey
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_InDetTrackParticlesKey
Definition: EgammaMonitoring.h:216
xAOD::EgammaHelpers::isTrueConvertedPhoton
bool isTrueConvertedPhoton(const xAOD::Photon *ph, float maxRadius=800.)
is the object matched to a true converted photon with R < maxRadius
Definition: EgammaTruthxAODHelpers.cxx:69
xAOD::TruthVertex_v1
Class describing a truth vertex in the MC record.
Definition: TruthVertex_v1.h:37
EgammaMonitoring::m_Medium_Ele
ToolHandle< IAsgElectronLikelihoodTool > m_Medium_Ele
Definition: EgammaMonitoring.h:168
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
EgammaMonitoring::m_FwdElectronsKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_FwdElectronsKey
Definition: EgammaMonitoring.h:210
xAOD::EgammaParameters::singleSi
@ singleSi
one track only, with Si hits
Definition: EgammaEnums.h:273
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
EgammaMonitoring::m_hasTRT
Gaudi::Property< bool > m_hasTRT
is it run 3 or run 4 and later ?
Definition: EgammaMonitoring.h:161
xAOD::TruthHelpers::getTruthParticle
const xAOD::TruthParticle * getTruthParticle(const xAOD::IParticle &p)
Return the truthParticle associated to the given IParticle (if any)
Definition: xAODTruthHelpers.cxx:25
xAOD::EgammaHelpers::getRecoElectron
const xAOD::Electron * getRecoElectron(const xAOD::TruthParticle *)
return the reco electron associated to the given TruthParticle (if any)
Definition: EgammaTruthxAODHelpers.cxx:31
EgammaMonitoring::truthElectronRecoElectronAll
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthElectronRecoElectronAll
Definition: EgammaMonitoring.h:77
xAOD::EgammaHelpers::numberOfSiHits
std::size_t numberOfSiHits(const xAOD::TrackParticle *tp)
return the number of Si hits in the track particle
Definition: ElectronxAODHelpers.cxx:66
xAOD::Electron_v1
Definition: Electron_v1.h:34
EgammaMonitoring::m_Loose_Photon
ToolHandle< IAsgPhotonIsEMSelector > m_Loose_Photon
Definition: EgammaMonitoring.h:180
EgammaMonitoring::recoPhotonAll
std::unique_ptr< egammaMonitoring::RecoPhotonHistograms > recoPhotonAll
Definition: EgammaMonitoring.h:102
EgammaMonitoring::truthPromptElectronWithTrack
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthPromptElectronWithTrack
Definition: EgammaMonitoring.h:79
EgammaMonitoring::clusterConvPhotonTRT
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterConvPhotonTRT
Definition: EgammaMonitoring.h:97
checkCorrelInHIST.iX
int iX
Definition: checkCorrelInHIST.py:491
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
EgammaMonitoring::truthElectronAll
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthElectronAll
Definition: EgammaMonitoring.h:73
EgammaMonitoring::truthPhotonConvPhoton
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonConvPhoton
Definition: EgammaMonitoring.h:110
xAOD::photon
@ photon
Definition: TrackingPrimitives.h:199
a
TList * a
Definition: liststreamerinfos.cxx:10
egammaMonitoring::EfficiencyPlot
Definition: EfficiencyPlot.h:16
h
EgammaMonitoring::truthPhotonConvRecoConv1TRT
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonConvRecoConv1TRT
Definition: EgammaMonitoring.h:113
EgammaMonitoring::recoPhotonUnconvIsoFixedCutTight
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonUnconvIsoFixedCutTight
Definition: EgammaMonitoring.h:132
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
EgammaMonitoring::truthPromptElectronWithReco
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthPromptElectronWithReco
Definition: EgammaMonitoring.h:83
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
EgammaMonitoring::truthPhotonConvRecoConv1Si
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonConvRecoConv1Si
Definition: EgammaMonitoring.h:112
EgammaMonitoring::m_ElectronsKey
SG::ReadHandleKey< xAOD::ElectronContainer > m_ElectronsKey
Definition: EgammaMonitoring.h:207
DEBUG
#define DEBUG
Definition: page_access.h:11
EgammaMonitoring::truthPhotonUnconvRecoConv2SiTRT
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonUnconvRecoConv2SiTRT
Definition: EgammaMonitoring.h:125
Electron
Class describing an electron.
NonPrimary
@ NonPrimary
Definition: TruthClasses.h:29
EgammaMonitoring::clusterConvPhotonSiTRT
std::unique_ptr< egammaMonitoring::ClusterHistograms > clusterConvPhotonSiTRT
Definition: EgammaMonitoring.h:99
egammaMonitoring::WidthPlot
Definition: WidthPlot.h:15
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
xAOD::EgammaHelpers::conversionType
xAOD::EgammaParameters::ConversionType conversionType(const xAOD::Photon *ph)
return the photon conversion type (see EgammaEnums)
Definition: PhotonxAODHelpers.cxx:27
EgammaMonitoring::m_clusterReco
std::unique_ptr< egammaMonitoring::RecoClusterHistograms > m_clusterReco
Definition: EgammaMonitoring.h:68
EgammaMonitoring::truthPhotonRecoPhotonOrElectron
std::unique_ptr< egammaMonitoring::IHistograms > truthPhotonRecoPhotonOrElectron
Definition: EgammaMonitoring.h:109
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
Gaudi
=============================================================================
Definition: CaloGPUClusterAndCellDataMonitorOptions.h:273
xAOD::numberOfSCTHits
@ numberOfSCTHits
number of hits in SCT [unit8_t].
Definition: TrackingPrimitives.h:268
EgammaMonitoring::truthRecoElectronLoose
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthRecoElectronLoose
Definition: EgammaMonitoring.h:87
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
xAOD::EgammaParameters::doubleTRT
@ doubleTRT
two tracks, none with Si hits (TRT only)
Definition: EgammaEnums.h:282
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
EgammaMonitoring::truthRecoElectronMedium
std::unique_ptr< egammaMonitoring::TruthElectronHistograms > truthRecoElectronMedium
Definition: EgammaMonitoring.h:89
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
xAOD::TruthParticle_v1::p4
virtual FourMom_t p4() const override final
The full 4-momentum of the particle.
Definition: TruthParticle_v1.cxx:196
EgammaMonitoring::m_Loose_Ele
ToolHandle< IAsgElectronLikelihoodTool > m_Loose_Ele
Selector tools.
Definition: EgammaMonitoring.h:166
Analysis::TT
@ TT
Definition: JpsiFinder.h:36
xAOD::TruthParticle_v1::pdgId
int pdgId() const
PDG ID code.
EgammaMonitoring::m_Loose_FwdEle
ToolHandle< IAsgElectronLikelihoodTool > m_Loose_FwdEle
Definition: EgammaMonitoring.h:172
ParticleType
ParticleType
Definition: TruthClasses.h:8
CaloNoise_fillDB.mu
mu
Definition: CaloNoise_fillDB.py:53
EgammaMonitoring::recoPhotonConvIsoFixedCutTightCaloOnly
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonConvIsoFixedCutTightCaloOnly
Definition: EgammaMonitoring.h:139
python.compressB64.c
def c
Definition: compressB64.py:93
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
EgammaMonitoring::recoPhotonConvLoose
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonConvLoose
Definition: EgammaMonitoring.h:129
EgammaMonitoring::cluster10GeV
std::unique_ptr< egammaMonitoring::ClusterHistograms > cluster10GeV
Definition: EgammaMonitoring.h:57
fitman.k
k
Definition: fitman.py:528
EgammaMonitoring::recoPhotonUnconvTight
std::unique_ptr< egammaMonitoring::IHistograms > recoPhotonUnconvTight
Definition: EgammaMonitoring.h:128
ServiceHandle< ICondSvc >