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
ITHistSvc *	rootHistSvc = nullptr
	Tools and services ///. More...
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterAll
std::unique_ptr< egammaMonitoring::ClusterHistograms >	cluster10GeV
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterPromptAll
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterPrompt10GeV
std::unique_ptr< egammaMonitoring::ShowerShapesHistograms >	showerShapesAll
std::unique_ptr< egammaMonitoring::ShowerShapesHistograms >	showerShapes10GeV
std::unique_ptr< egammaMonitoring::IsolationHistograms >	isolationAll
std::unique_ptr< egammaMonitoring::RecoClusterHistograms >	m_clusterReco
std::unique_ptr< egammaMonitoring::DiObjectHistograms >	m_diElectron
std::unique_ptr< egammaMonitoring::RecoElectronHistograms >	recoElectronAll
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthElectronAll
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthPromptElectronAll
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthElectronRecoElectronAll
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthPromptElectronWithTrack
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthPromptElectronWithGSFTrack
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthPromptElectronWithReco
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthPromptElectronWithRecoTrack
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthRecoElectronLoose
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthRecoElectronMedium
std::unique_ptr< egammaMonitoring::TruthElectronHistograms >	truthRecoElectronTight
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterConvPhoton
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterConvPhotonSi
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterConvPhotonSiSi
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterConvPhotonTRT
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterConvPhotonTRTTRT
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterConvPhotonSiTRT
std::unique_ptr< egammaMonitoring::ClusterHistograms >	clusterUnconvPhoton
std::unique_ptr< egammaMonitoring::RecoPhotonHistograms >	recoPhotonAll
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonAll
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonAllUnconv
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonAllConv
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonAllLateConv
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonRecoPhoton
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonRecoPhotonOrElectron
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonConvPhoton
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonConvRecoConv
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonConvRecoConv1Si
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonConvRecoConv1TRT
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonConvRecoConv2Si
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonConvRecoConv2TRT
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonConvRecoConv2SiTRT
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonConvRecoUnconv
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonUnconvPhoton
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonUnconvRecoConv
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonUnconvRecoConv1Si
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonUnconvRecoConv1TRT
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonUnconvRecoConv2Si
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonUnconvRecoConv2TRT
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonUnconvRecoConv2SiTRT
std::unique_ptr< egammaMonitoring::IHistograms >	truthPhotonUnconvRecoUnconv
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonUnconvLoose
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonUnconvTight
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonConvLoose
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonConvTight
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonUnconvIsoFixedCutTight
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonUnconvIsoFixedCutTightCaloOnly
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonUnconvIsoFixedCutLoose
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonConvIsoFixedCutTight
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonConvIsoFixedCutTightCaloOnly
std::unique_ptr< egammaMonitoring::IHistograms >	recoPhotonConvIsoFixedCutLoose
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< StoreGateSvc >	StoreGateSvc_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< IAsgElectronLikelihoodTool >	m_Loose_Ele { this, "Loose_Ele", "", "" }
	Selector tools. More...
ToolHandle< IAsgElectronLikelihoodTool >	m_Medium_Ele { this, "Medium_Ele", "", "" }
ToolHandle< IAsgElectronLikelihoodTool >	m_Tight_Ele { this, "Tight_Ele", "", "" }
ToolHandle< IAsgElectronLikelihoodTool >	m_Loose_FwdEle { this, "Loose_FwdEle", "", "" }
ToolHandle< IAsgElectronLikelihoodTool >	m_Medium_FwdEle { this, "Medium_FwdEle", "", "" }
ToolHandle< IAsgElectronLikelihoodTool >	m_Tight_FwdEle { this, "Tight_FwdEle", "", "" }
ToolHandle< IAsgPhotonIsEMSelector >	m_Loose_Photon { this, "Loose_Photon", "", "" }
ToolHandle< IAsgPhotonIsEMSelector >	m_Tight_Photon { this, "Tight_Photon", "", "" }
ToolHandle< CP::IIsolationSelectionTool >	m_IsoFixedCutTight { this, "IsoFixedCutTight", "", "" }
ToolHandle< CP::IIsolationSelectionTool >	m_IsoFixedCutTightCaloOnly { this, "IsoTightCaloOnly", "", "" }
ToolHandle< CP::IIsolationSelectionTool >	m_IsoFixedCutLoose { this, "IsoFixedCutLoose", "", "" }
ToolHandle< IMCTruthClassifier >	m_mcTruthClassifier { this, "MCTruthClassifier", "", "" }
SG::ReadHandleKey< xAOD::EventInfo >	m_eventInfoKey { this, "EventInfoKey", "EventInfo", "" }
SG::ReadHandleKey< xAOD::TruthParticleContainer >	m_egTruthParticlesKey { this, "egammaTruthParticlesKey", "", "" }
SG::ReadHandleKey< xAOD::TruthParticleContainer >	m_truthParticlesKey { this, "truthParticlesKey", "", "" }
SG::ReadHandleKey< xAOD::ElectronContainer >	m_ElectronsKey { this, "ElectronsKey", "", "" }
SG::ReadHandleKey< xAOD::ElectronContainer >	m_FwdElectronsKey { this, "FwdElectronsKey", "", "" }
SG::ReadHandleKey< xAOD::PhotonContainer >	m_PhotonsKey { this, "PhotonsKey", "", "" }
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_InDetTrackParticlesKey { this, "InDetTrackParticlesKey", "InDetTrackParticles", "" }
SG::ReadHandleKey< xAOD::TrackParticleContainer >	m_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 47 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 24 of file EgammaMonitoring.cxx.

    : AthAlgorithm(name, pSvcLocator) {}

~EgammaMonitoring()

EgammaMonitoring::~EgammaMonitoring ( )

inline

Definition at line 146 of file EgammaMonitoring.h.

{};

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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
  }

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.

  {
    return PBASE::declareProperty(t);
  }

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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

  {
    this->declare(hndl.vhKey());
    hndl.vhKey().setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

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

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation 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.

  {
    this->declare(hndl);
    hndl.setOwner(this);
 
    return PBASE::declareProperty(name,hndl,doc);
  }

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.

  {
 
    // std::ostringstream ost;
    // ost << Algorithm::name() << " VHKA declareProp: " << name 
    //     << " size: " << hndArr.keys().size() 
    //     << " mode: " << hndArr.mode() 
    //     << "  vhka size: " << m_vhka.size()
    //     << "\n";
    // debug() << ost.str() << endmsg;
 
    hndArr.setOwner(this);
    m_vhka.push_back(&hndArr);
 
    Gaudi::Details::PropertyBase* p =  PBASE::declareProperty(name, hndArr, doc);
    if (p != 0) {
      p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
    } else {
      ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray " 
                    << name);
    }
 
    return p;
 
  }

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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

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

name	Name of the property.
property	Object holding the property value.
doc	Documentation 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.

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

declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                 {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

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.

{ 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.

{ 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.

{ return m_evtStore; }

execute()

StatusCode EgammaMonitoring::execute ( )

virtual

Definition at line 524 of file EgammaMonitoring.cxx.

                                     {
 
  const EventContext &ctx = Gaudi::Hive::currentContext();
 
  // Retrieve things from the event store
  SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey, ctx);
  const float mu = eventInfo->averageInteractionsPerCrossing();
 
  // Retrieve indet track particles
  SG::ReadHandle<xAOD::TrackParticleContainer> InDetTPs(
      m_InDetTrackParticlesKey, ctx);
 
  if ("dataZ" == m_sampleType) {
    return this->ZeeSelection(mu, ctx);
  }
 
  // Retrieve egamma truth particles
  SG::ReadHandle<xAOD::TruthParticleContainer> egTruthParticles(
      m_egTruthParticlesKey, ctx);
 
  // Retrieve truth particles
  SG::ReadHandle<xAOD::TruthParticleContainer> truthParticles(
      m_truthParticlesKey, ctx);
 
  if ("electron" == m_sampleType) {
 
    SG::ReadHandle<xAOD::ElectronContainer> RecoEl(m_ElectronsKey, ctx);
    SG::ReadHandle<xAOD::TrackParticleContainer> GSFTracks(
        m_GSFTrackParticlesKey, ctx);
 
    ATH_MSG_DEBUG("------------ Truth Egamma Container ---------------");
    for (const auto *egtruth : *egTruthParticles) {
 
      if (!egtruth)
        continue;
 
      const xAOD::Electron *electron =
          xAOD::EgammaHelpers::getRecoElectron(egtruth);
 
      if (!electron)
        continue;
 
      clusterPromptAll->fill(*electron, mu);
      if (egtruth->pt() > 10 * Gaudi::Units::GeV) {
        clusterPrompt10GeV->fill(*electron, mu);
      }
    }
 
    ATH_MSG_DEBUG("------------ Truth Particles Container ---------------");
    unsigned int promptElectronTruthIndex =
        std::numeric_limits<unsigned int>::max();
    for (const auto *truth : *truthParticles) {
 
      if (!truth)
        continue;
      if (std::abs(truth->pdgId()) != 11)
        continue;
 
      auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
      MCTruthPartClassifier::ParticleOrigin TO = res.second;
      MCTruthPartClassifier::ParticleType TT = res.first;
 
      if (msgLvl(MSG::DEBUG)) {
 
        bool haspVtx = truth->hasProdVtx();
        double rProd = -1;
        if (haspVtx) {
          const xAOD::TruthVertex *pvtx = truth->prodVtx();
          rProd = pvtx->perp();
        }
        bool hasdVtx = truth->hasDecayVtx();
        double rDec = -1;
        if (hasdVtx) {
          const xAOD::TruthVertex *dvtx = truth->decayVtx();
          rDec = dvtx->perp();
        }
 
        ATH_MSG_DEBUG(" ******** Truth electron found: "
                      << truth << " TO  " << TO << " TT   " << TT
                      << " Rprod = " << rProd << " Rdec = " << rDec
                      << " eventNumber  " << eventInfo->eventNumber());
      }
 
      // Check if it is the prompt electron
      if (TO == MCTruthPartClassifier::SingleElec &&
          TT == MCTruthPartClassifier::IsoElectron &&
          MC::isSingleParticle(truth)) {
        truthPromptElectronAll->fill(truth);
        promptElectronTruthIndex = truth->index();
      }
 
      // Check that it is not from geant4 (but electron from photon conversion
      // are kept)
      if (TT != MCTruthPartClassifier::NonPrimary)
        truthElectronAll->fill(truth);
    }
 
    ATH_MSG_DEBUG("------------ InDetTracks ---------------");
 
    for (const auto *tp : *InDetTPs) {
 
      if (!tp)
        continue;
 
      uint8_t nPi = 0;
      uint8_t nSCT = 0;
 
      tp->summaryValue(nPi, xAOD::numberOfPixelHits);
      tp->summaryValue(nSCT, xAOD::numberOfSCTHits);
 
      if ((nPi + nSCT) < 7)
        continue;
 
      const xAOD::TruthParticle *truth =
          xAOD::TruthHelpers::getTruthParticle(*tp);
 
      if (!truth || std::abs(truth->pdgId()) != 11)
        continue;
 
      auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
      MCTruthPartClassifier::ParticleOrigin TO = res.second;
      MCTruthPartClassifier::ParticleType TT = res.first;
      if (TO == MCTruthPartClassifier::SingleElec &&
          TT == MCTruthPartClassifier::IsoElectron &&
          truth->index() == promptElectronTruthIndex) {
 
        // we found the track from the prompt electron
        // let's count it
        truthPromptElectronWithTrack->fill(truth);
        break;
 
      } else {
        const xAOD::TruthParticle *firstElTruth =
            xAOD::EgammaHelpers::getBkgElectronMother(truth);
        if (!firstElTruth)
          continue;
        // this is not a prompt electron, we need to check the parents
        // but we need to make sure that we double count if already found the
        // track foundPromptElectron will check that
 
        if (firstElTruth->index() == promptElectronTruthIndex) {
          truthPromptElectronWithTrack->fill(firstElTruth);
          break;
        }
      }
    }
 
    ATH_MSG_DEBUG("------------ GSFTracks ---------------");
    for (const auto *gsf : *GSFTracks) {
 
      if (!gsf)
        continue;
 
      const xAOD::TruthParticle *truth =
          xAOD::TruthHelpers::getTruthParticle(*gsf);
 
      if (!truth)
        continue;
 
      uint8_t nPi = 0;
      uint8_t nSCT = 0;
 
      gsf->summaryValue(nPi, xAOD::numberOfPixelHits);
      gsf->summaryValue(nSCT, xAOD::numberOfSCTHits);
 
      if ((nPi + nSCT) < 7)
        continue;
 
      auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
      MCTruthPartClassifier::ParticleOrigin TO = res.second;
      MCTruthPartClassifier::ParticleType TT = res.first;
      if (msgLvl(MSG::DEBUG)) {
        auto res2 = m_mcTruthClassifier->checkOrigOfBkgElec(truth);
        MCTruthPartClassifier::ParticleOrigin bkgTO = res2.second;
        MCTruthPartClassifier::ParticleType bkgTT = res2.first;
        ATH_MSG_DEBUG(" ** Truth particle associated to track Found: "
                      << truth << " index    " << truth->index() << " bkg T0  "
                      << bkgTO << " bkg TT   " << bkgTT << " T0  " << TO
                      << " TT   " << TT << " eventNumber  "
                      << eventInfo->eventNumber());
      }
      if (TO == MCTruthPartClassifier::SingleElec &&
          TT == MCTruthPartClassifier::IsoElectron &&
          truth->index() == promptElectronTruthIndex) {
 
        // we found the track from the prompt electron
        // let's count it
        truthPromptElectronWithGSFTrack->fill(truth);
        break;
      } else {
        const xAOD::TruthParticle *firstElTruth =
            xAOD::EgammaHelpers::getBkgElectronMother(truth);
        if (!firstElTruth)
          continue;
        ATH_MSG_DEBUG("********----- Getting Mother-----********");
        ATH_MSG_DEBUG(" STATUS  " << firstElTruth << " index    "
                                  << firstElTruth->index());
        // this is not a prompt electron, we need to check the parents
        // but we need to make sure that we double count if already found the
        // track foundPromptElectron will check that
        if (firstElTruth->index() == promptElectronTruthIndex) {
          truthPromptElectronWithGSFTrack->fill(firstElTruth);
          break;
        }
      }
    }
 
    ATH_MSG_DEBUG("------------ Reco central electrons ---------------");
    bool foundPromptElectron = false;
 
    for (const auto *elrec : *RecoEl) {
 
      if (!elrec)
        continue;
 
      bool toFill = false;
 
      clusterAll->fill(*elrec, mu);
      recoElectronAll->fill(*elrec);
      showerShapesAll->fill(*elrec);
      isolationAll->fill(*elrec);
      if (elrec->pt() > 10 * Gaudi::Units::GeV) {
        cluster10GeV->fill(*elrec, mu);
        showerShapes10GeV->fill(*elrec);
      }
 
      const xAOD::TruthParticle *truth =
          xAOD::TruthHelpers::getTruthParticle(*elrec);
      if (!truth)
        continue;
      truthElectronRecoElectronAll->fill(truth, elrec);
      if (std::abs(truth->pdgId()) != 11 || foundPromptElectron)
        continue;
      const xAOD::TruthParticle *elTruth(nullptr);
      auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
      MCTruthPartClassifier::ParticleOrigin TO = res.second;
      MCTruthPartClassifier::ParticleType TT = res.first;
      if (TO == MCTruthPartClassifier::SingleElec &&
          TT == MCTruthPartClassifier::IsoElectron &&
          truth->index() == promptElectronTruthIndex) {
        toFill = true;
        elTruth = truth;
      } else {
        const xAOD::TruthParticle *firstElTruth =
            xAOD::EgammaHelpers::getBkgElectronMother(truth);
        if (!firstElTruth)
          continue;
        // this is not a prompt electron, we need to check the parents
        // but we need to make sure that we double count if already found the
        // track foundPromptElectron will check that
        if (firstElTruth->index() == promptElectronTruthIndex) {
          toFill = true;
          elTruth = firstElTruth;
        }
      }
      if (toFill) {
        foundPromptElectron = true;
        truthPromptElectronWithReco->fill(elTruth, elrec);
        truthPromptElectronWithRecoTrack->fill(
            elTruth, elrec); // yes the same. This is different for fwd
        if (m_Loose_Ele->accept(elrec))
          truthRecoElectronLoose->fill(elTruth, elrec);
        if (m_Medium_Ele->accept(elrec))
          truthRecoElectronMedium->fill(elTruth, elrec);
        if (m_Tight_Ele->accept(elrec))
          truthRecoElectronTight->fill(elTruth, elrec);
      }
    } // RecoEl Loop
 
    if (!m_FwdElectronsKey.empty()) {
      SG::ReadHandle<xAOD::ElectronContainer> RecoFwdEl(m_FwdElectronsKey, ctx);
      for (const auto *el : *RecoFwdEl) {
        // This would be very weird ??
        if (!el)
          continue;
 
        clusterAll->fill(*el, mu);
        recoElectronAll->fill(*el);
        showerShapesAll->fill(*el);
        if (el->pt() > 10 * Gaudi::Units::GeV) {
          cluster10GeV->fill(*el, mu);
          showerShapes10GeV->fill(*el);
        }
        bool toFill = false;
 
        const xAOD::TruthParticle *truth =
            xAOD::TruthHelpers::getTruthParticle(*el);
 
        if (!truth)
          continue;
        // truthElectronRecoFwdElectronAll->fill(truth, elrec); // to be done
 
        // if the prompt electron is not too far from the reco candidate, which
        // might be matched to a photon use this prompt as the matched particle
        // instead
        if (std::abs(truth->pdgId()) != 11 &&
            promptElectronTruthIndex < truthParticles->size()) {
          const xAOD::TruthParticle *vtruth =
              truthParticles->at(promptElectronTruthIndex);
          double dR1 = vtruth->p4().DeltaR(el->caloCluster()->p4());
          double dR2 = truth->p4().DeltaR(el->caloCluster()->p4());
          m_dR1->Fill(dR1);
          m_dR2->Fill(dR2);
          if (dR1 < 0.05) // threshold to optimize
            truth = vtruth;
        }
 
        if (std::abs(truth->pdgId()) != 11)
          continue;
        const xAOD::TruthParticle *elTruth(nullptr);
        auto res = m_mcTruthClassifier->particleTruthClassifier(truth);
        if (res.second == MCTruthPartClassifier::SingleElec &&
            res.first == MCTruthPartClassifier::IsoElectron &&
            truth->index() == promptElectronTruthIndex) {
          toFill = true;
          elTruth = truth;
        } else {
          const xAOD::TruthParticle *firstElTruth =
              xAOD::EgammaHelpers::getBkgElectronMother(truth);
          if (!firstElTruth)
            continue;
          if (firstElTruth->index() == promptElectronTruthIndex) {
            toFill = true;
            elTruth = firstElTruth;
          }
        }
        if (toFill) {
          if (foundPromptElectron) {
            ATH_MSG_DEBUG("A fwd electron also reconstructed as central "
                          "true eta = "
                          << elTruth->eta()
                          << " event = " << eventInfo->eventNumber());
            m_CenFwdOverlap[0]++;
            if (el->nTrackParticles() > 0)
              m_CenFwdOverlap[1]++;
          } else {
            foundPromptElectron = true;
            truthPromptElectronWithReco->fill(elTruth, el);
            if (el->nTrackParticles() > 0)
              truthPromptElectronWithRecoTrack->fill(elTruth, el);
            if (m_Loose_FwdEle->accept(el))
              truthRecoElectronLoose->fill(elTruth, el);
            if (m_Medium_FwdEle->accept(el))
              truthRecoElectronMedium->fill(elTruth, el);
            if (m_Tight_FwdEle->accept(el))
              truthRecoElectronTight->fill(elTruth, el);
          }
        }
      } // loop on fwdEl
    }
 
  } // if electron
 
  if ("gamma" == m_sampleType) {
 
    ATH_MSG_DEBUG("------------ Photons ---------------");
    SG::ReadHandle<xAOD::PhotonContainer> RecoPh(m_PhotonsKey, ctx);
 
    for (const auto *phrec : *RecoPh) {
 
      if (!phrec)
        continue;
 
      recoPhotonAll->fill(*phrec);
      isolationAll->fill(*phrec);
      showerShapesAll->fill(*phrec);
      clusterAll->fill(*phrec, mu);
      if (phrec->pt() > 10 * Gaudi::Units::GeV) {
        cluster10GeV->fill(*phrec, mu);
        showerShapes10GeV->fill(*phrec);
      }
 
    } // RecoPh Loop
 
    for (const auto *egtruth : *egTruthParticles) {
 
      if (!egtruth)
        continue;
 
      truthPhotonAll->fill(*egtruth, mu);
 
      bool isTrueConv = xAOD::EgammaHelpers::isTrueConvertedPhoton(egtruth);
      bool isTrueLateConv =
          xAOD::EgammaHelpers::isTrueConvertedPhoton(egtruth, 1200) and
          !isTrueConv;
      const xAOD::Photon *photon = xAOD::EgammaHelpers::getRecoPhoton(egtruth);
      const xAOD::Electron *electron =
          xAOD::EgammaHelpers::getRecoElectron(egtruth);
 
      if (isTrueConv)
        truthPhotonAllConv->fill(*egtruth, mu);
      if (isTrueLateConv)
        truthPhotonAllLateConv->fill(*egtruth, mu);
      if (!isTrueConv && !isTrueLateConv)
        truthPhotonAllUnconv->fill(*egtruth, mu);
 
      if (photon || electron)
        truthPhotonRecoPhotonOrElectron->fill(*egtruth, mu);
 
      if (!photon)
        continue;
 
      truthPhotonRecoPhoton->fill(*egtruth, mu);
      clusterPromptAll->fill(*photon, mu);
      if (egtruth->pt() > 10 * Gaudi::Units::GeV) {
        clusterPrompt10GeV->fill(*photon, mu);
      }
 
      bool isRecoConv = xAOD::EgammaHelpers::isConvertedPhoton(photon);
      xAOD::EgammaParameters::ConversionType convType =
          xAOD::EgammaHelpers::conversionType(photon);
 
      if (isTrueConv) {
 
        truthPhotonConvPhoton->fill(*egtruth, mu);
 
        if (isRecoConv) {
 
          truthPhotonConvRecoConv->fill(*egtruth, mu);
 
          clusterConvPhoton->fill(*photon, mu);
 
          if (convType == xAOD::EgammaParameters::singleSi) {
            truthPhotonConvRecoConv1Si->fill(*egtruth, mu);
            clusterConvPhotonSi->fill(*photon, mu);
          } else if (convType == xAOD::EgammaParameters::singleTRT) {
            truthPhotonConvRecoConv1TRT->fill(*egtruth, mu);
            clusterConvPhotonTRT->fill(*photon, mu);
          } else if (convType == xAOD::EgammaParameters::doubleSi) {
            truthPhotonConvRecoConv2Si->fill(*egtruth, mu);
            clusterConvPhotonSiSi->fill(*photon, mu);
          } else if (convType == xAOD::EgammaParameters::doubleTRT) {
            truthPhotonConvRecoConv2TRT->fill(*egtruth, mu);
            clusterConvPhotonTRTTRT->fill(*photon, mu);
          } else if (convType == xAOD::EgammaParameters::doubleSiTRT) {
            truthPhotonConvRecoConv2SiTRT->fill(*egtruth, mu);
            clusterConvPhotonSiTRT->fill(*photon, mu);
          }
 
          if (m_IsoFixedCutTight->accept(*photon))
            recoPhotonConvIsoFixedCutTight->fill(*egtruth, mu);
          if (m_IsoFixedCutTightCaloOnly->accept(*photon))
            recoPhotonConvIsoFixedCutTightCaloOnly->fill(*egtruth, mu);
          if (m_IsoFixedCutLoose->accept(*photon))
            recoPhotonConvIsoFixedCutLoose->fill(*egtruth, mu);
          if (m_Loose_Photon->accept(photon))
            recoPhotonConvLoose->fill(*egtruth, mu);
          if (m_Tight_Photon->accept(photon))
            recoPhotonConvTight->fill(*egtruth, mu);
        } // isRecoConv
        else {
          truthPhotonConvRecoUnconv->fill(*egtruth, mu);
          clusterUnconvPhoton->fill(*photon, mu);
        }
 
      } // isTrueConv
      // else if (!isTrueLateConv) {
      else {
 
        truthPhotonUnconvPhoton->fill(*egtruth, mu);
 
        if (isRecoConv) {
          truthPhotonUnconvRecoConv->fill(*egtruth, mu);
 
          if (convType == xAOD::EgammaParameters::singleSi) {
            truthPhotonUnconvRecoConv1Si->fill(*egtruth, mu);
            clusterConvPhotonSi->fill(*photon, mu);
          } else if (convType == xAOD::EgammaParameters::singleTRT) {
            truthPhotonUnconvRecoConv1TRT->fill(*egtruth, mu);
            clusterConvPhotonTRT->fill(*photon, mu);
          } else if (convType == xAOD::EgammaParameters::doubleSi) {
            truthPhotonUnconvRecoConv2Si->fill(*egtruth, mu);
            clusterConvPhotonSiSi->fill(*photon, mu);
          } else if (convType == xAOD::EgammaParameters::doubleTRT) {
            truthPhotonUnconvRecoConv2TRT->fill(*egtruth, mu);
            clusterConvPhotonTRTTRT->fill(*photon, mu);
          } else if (convType == xAOD::EgammaParameters::doubleSiTRT) {
            truthPhotonUnconvRecoConv2SiTRT->fill(*egtruth, mu);
            clusterConvPhotonSiTRT->fill(*photon, mu);
          }
        } else
          truthPhotonUnconvRecoUnconv->fill(*egtruth, mu);
 
        if (m_IsoFixedCutTight->accept(*photon))
          recoPhotonUnconvIsoFixedCutTight->fill(*egtruth, mu);
        if (m_IsoFixedCutTightCaloOnly->accept(*photon))
          recoPhotonUnconvIsoFixedCutTightCaloOnly->fill(*egtruth, mu);
        if (m_IsoFixedCutLoose->accept(*photon))
          recoPhotonUnconvIsoFixedCutLoose->fill(*egtruth, mu);
        if (m_Loose_Photon->accept(photon))
          recoPhotonUnconvLoose->fill(*egtruth, mu);
        if (m_Tight_Photon->accept(photon))
          recoPhotonUnconvTight->fill(*egtruth, mu);
      } // !isTrueLateConv
    }   // egtruth Loop
 
    // loop over InDetTrackParticles
    for (const auto *tp : *InDetTPs) {
 
      mapTrkHistograms["InDetTracks"]->fill(*tp, mu);
      if (matchedToElectron(*tp))
        mapTrkHistograms["InDetTracksMatchElectron"]->fill(*tp, mu);
      else {
        mapTrkHistograms["InDetTracksNotElectron"]->fill(*tp, mu);
        if (matchedToPion(*tp))
          mapTrkHistograms["InDetTracksMatchPion"]->fill(*tp, mu);
        else if (notMatchedToTruth(*tp))
          mapTrkHistograms["InDetTracksNotMatched"]->fill(*tp, mu);
      }
      if (tp->pt() > 3000.) {
        mapTrkHistograms["InDetTrackshighpT"]->fill(*tp, mu);
        if (matchedToElectron(*tp)) {
          mapTrkHistograms["InDetTracksMatchElectronhighpT"]->fill(*tp, mu);
        } else {
          mapTrkHistograms["InDetTracksNotElectronhighpT"]->fill(*tp, mu);
          if (matchedToPion(*tp)) {
            mapTrkHistograms["InDetTracksMatchPionhighpT"]->fill(*tp, mu);
          } else if (notMatchedToTruth(*tp)) {
            mapTrkHistograms["InDetTracksNotMatchedhighpT"]->fill(*tp, mu);
          }
        }
      }
 
      if (m_hasTRT &&
          xAOD::EgammaHelpers::numberOfSiHits(tp) == 0) { // TRTSA tracks
        mapTrkHistograms["InDetTracksTRT"]->fill(*tp, mu);
        if (matchedToElectron(*tp))
          mapTrkHistograms["InDetTracksTRTMatchElectron"]->fill(*tp, mu);
        else {
          mapTrkHistograms["InDetTracksTRTNotElectron"]->fill(*tp, mu);
          if (matchedToPion(*tp))
            mapTrkHistograms["InDetTracksTRTMatchPion"]->fill(*tp, mu);
          else if (notMatchedToTruth(*tp))
            mapTrkHistograms["InDetTracksTRTNotMatched"]->fill(*tp, mu);
        }
        if (tp->pt() > 3000.) {
          mapTrkHistograms["InDetTracksTRThighpT"]->fill(*tp, mu);
          if (matchedToElectron(*tp))
            mapTrkHistograms["InDetTracksTRTMatchElectronhighpT"]->fill(*tp,
                                                                        mu);
          else {
            mapTrkHistograms["InDetTracksTRTNotElectronhighpT"]->fill(*tp, mu);
            if (matchedToPion(*tp))
              mapTrkHistograms["InDetTracksTRTMatchPionhighpT"]->fill(*tp, mu);
            else if (notMatchedToTruth(*tp))
              mapTrkHistograms["InDetTracksTRTNotMatchedhighpT"]->fill(*tp, mu);
          }
        }
      }
 
    } // loop over InDetTPs
 
  } // if gamma
 
  return StatusCode::SUCCESS;
}

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.

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

finalize()

StatusCode EgammaMonitoring::finalize ( )

virtual

Definition at line 1084 of file EgammaMonitoring.cxx.

                                      {
 
  if ("electron" == m_sampleType) {
 
    ATH_MSG_INFO("Number of events with electron reconstructed "
                 "as both Central and Forward "
                 << m_CenFwdOverlap[0] << " and with a track for the Forward "
                 << m_CenFwdOverlap[1]);
 
    egammaMonitoring::EfficiencyPlot trackEfficiency(
        "trackingEfficiency", "/MONITORING/trackingEfficiency/", rootHistSvc);
    ATH_CHECK(trackEfficiency.divide(truthPromptElectronWithTrack.get(),
                                     truthPromptElectronAll.get()));
    egammaMonitoring::EfficiencyPlot GSFEfficiency(
        "GSFEfficiency", "/MONITORING/GSFEfficiency/", rootHistSvc);
    ATH_CHECK(GSFEfficiency.divide(truthPromptElectronWithGSFTrack.get(),
                                   truthPromptElectronWithTrack.get()));
    egammaMonitoring::EfficiencyPlot matchingEfficiency(
        "matchingEfficiency", "/MONITORING/matchingEfficiency/", rootHistSvc);
    ATH_CHECK(matchingEfficiency.divide(truthPromptElectronWithRecoTrack.get(),
                                        truthPromptElectronWithGSFTrack.get()));
    egammaMonitoring::EfficiencyPlot reconstructionEfficiency(
        "reconstructionEfficiency", "/MONITORING/reconstructionEfficiency/",
        rootHistSvc);
    ATH_CHECK(reconstructionEfficiency.divide(truthPromptElectronWithReco.get(),
                                              truthPromptElectronAll.get()));
    egammaMonitoring::EfficiencyPlot recoElectronLooseEfficiency(
        "recoElectronLooseLHEfficiency",
        "/MONITORING/recoElectronLooseLHEfficiency/", rootHistSvc);
    ATH_CHECK(recoElectronLooseEfficiency.divide(truthRecoElectronLoose.get(),
                                                 truthPromptElectronAll.get()));
    egammaMonitoring::EfficiencyPlot recoElectronMediumEfficiency(
        "recoElectronMediumLHEfficiency",
        "/MONITORING/recoElectronMediumLHEfficiency/", rootHistSvc);
    ATH_CHECK(recoElectronMediumEfficiency.divide(
        truthRecoElectronMedium.get(), truthPromptElectronAll.get()));
    egammaMonitoring::EfficiencyPlot recoElectronTightEfficiency(
        "recoElectronTightLHEfficiency",
        "/MONITORING/recoElectronTightLHEfficiency/", rootHistSvc);
    ATH_CHECK(recoElectronTightEfficiency.divide(truthRecoElectronTight.get(),
                                                 truthPromptElectronAll.get()));
 
  }
 
  else if ("gamma" == m_sampleType) {
 
    egammaMonitoring::EfficiencyPlot truthPhotonRecoPhotonEfficiency(
        "truthPhotonRecoPhotonEfficiency",
        "/MONITORING/truthPhotonRecoPhotonEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonRecoPhotonEfficiency.divide(
        truthPhotonRecoPhoton.get(), truthPhotonAll.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonRecoPhotonOrElectronEfficiency(
        "truthPhotonRecoPhotonOrElectronEfficiency",
        "/MONITORING/truthPhotonRecoPhotonOrElectronEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonRecoPhotonOrElectronEfficiency.divide(
        truthPhotonRecoPhotonOrElectron.get(), truthPhotonAll.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonConvRecoEfficiency(
        "truthPhotonConvRecoEfficiency",
        "/MONITORING/truthPhotonConvRecoEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonConvRecoEfficiency.divide(truthPhotonConvPhoton.get(),
                                                   truthPhotonAllConv.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoEfficiency(
        "truthPhotonUnconvRecoEfficiency",
        "/MONITORING/truthPhotonUnconvRecoEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonUnconvRecoEfficiency.divide(
        truthPhotonUnconvPhoton.get(), truthPhotonAllUnconv.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConvEfficiency(
        "truthPhotonConvRecoConvEfficiency",
        "/MONITORING/truthPhotonConvRecoConvEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonConvRecoConvEfficiency.divide(
        truthPhotonConvRecoConv.get(), truthPhotonConvPhoton.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv1SiEfficiency(
        "truthPhotonConvRecoConv1SiEfficiency",
        "/MONITORING/truthPhotonConvRecoConv1SiEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonConvRecoConv1SiEfficiency.divide(
        truthPhotonConvRecoConv1Si.get(), truthPhotonConvPhoton.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv2SiEfficiency(
        "truthPhotonConvRecoConv2SiEfficiency",
        "/MONITORING/truthPhotonConvRecoConv2SiEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonConvRecoConv2SiEfficiency.divide(
        truthPhotonConvRecoConv2Si.get(), truthPhotonConvPhoton.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonConvRecoUnconvEfficiency(
        "truthPhotonConvRecoUnconvEfficiency",
        "/MONITORING/truthPhotonConvRecoUnconvEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonConvRecoUnconvEfficiency.divide(
        truthPhotonConvRecoUnconv.get(), truthPhotonConvPhoton.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConvEfficiency(
        "truthPhotonUnconvRecoConvEfficiency",
        "/MONITORING/truthPhotonUnconvRecoConvEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonUnconvRecoConvEfficiency.divide(
        truthPhotonUnconvRecoConv.get(), truthPhotonUnconvPhoton.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConv1SiEfficiency(
        "truthPhotonUnconvRecoConv1SiEfficiency",
        "/MONITORING/truthPhotonUnconvRecoConv1SiEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonUnconvRecoConv1SiEfficiency.divide(
        truthPhotonUnconvRecoConv1Si.get(), truthPhotonUnconvPhoton.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConv2SiEfficiency(
        "truthPhotonUnconvRecoConv2SiEfficiency",
        "/MONITORING/truthPhotonUnconvRecoConv2SiEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonUnconvRecoConv2SiEfficiency.divide(
        truthPhotonUnconvRecoConv2Si.get(), truthPhotonUnconvPhoton.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoUnconvEfficiency(
        "truthPhotonUnconvRecoUnconvEfficiency",
        "/MONITORING/truthPhotonUnconvRecoUnconvEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonUnconvRecoUnconvEfficiency.divide(
        truthPhotonUnconvRecoUnconv.get(), truthPhotonUnconvPhoton.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonRecoConvEfficiency(
        "truthPhotonRecoConvEfficiency",
        "/MONITORING/truthPhotonRecoConvEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonRecoConvEfficiency.divide(
        truthPhotonConvRecoConv.get(), truthPhotonRecoPhoton.get()));
    egammaMonitoring::EfficiencyPlot truthPhotonRecoUnconvEfficiency(
        "truthPhotonRecoUnconvEfficiency",
        "/MONITORING/truthPhotonRecoUnconvEfficiency/", rootHistSvc);
    ATH_CHECK(truthPhotonRecoUnconvEfficiency.divide(
        truthPhotonUnconvRecoUnconv.get(), truthPhotonRecoPhoton.get()));
    egammaMonitoring::EfficiencyPlot recoPhotonUnconvIsoFixedCutTightEfficiency(
        "recoPhotonUnconvIsoFixedCutTightEfficiency",
        "/MONITORING/recoPhotonUnconvIsoFixedCutTightEfficiency/", rootHistSvc);
    ATH_CHECK(recoPhotonUnconvIsoFixedCutTightEfficiency.divide(
        recoPhotonUnconvIsoFixedCutTight.get(),
        truthPhotonUnconvRecoUnconv.get()));
    egammaMonitoring::EfficiencyPlot
        recoPhotonUnconvIsoFixedCutTightCaloOnlyEfficiency(
            "recoPhotonUnconvIsoFixedCutTightCaloOnlyEfficiency",
            "/MONITORING/recoPhotonUnconvIsoFixedCutTightCaloOnlyEfficiency/",
            rootHistSvc);
    ATH_CHECK(recoPhotonUnconvIsoFixedCutTightCaloOnlyEfficiency.divide(
        recoPhotonUnconvIsoFixedCutTightCaloOnly.get(),
        truthPhotonUnconvRecoUnconv.get()));
    egammaMonitoring::EfficiencyPlot recoPhotonUnconvIsoFixedCutLooseEfficiency(
        "recoPhotonUnconvIsoFixedCutLooseEfficiency",
        "/MONITORING/recoPhotonUnconvIsoFixedCutLooseEfficiency/", rootHistSvc);
    ATH_CHECK(recoPhotonUnconvIsoFixedCutLooseEfficiency.divide(
        recoPhotonUnconvIsoFixedCutLoose.get(),
        truthPhotonUnconvRecoUnconv.get()));
    egammaMonitoring::EfficiencyPlot recoPhotonConvIsoFixedCutTightEfficiency(
        "recoPhotonConvIsoFixedCutTightEfficiency",
        "/MONITORING/recoPhotonConvIsoFixedCutTightEfficiency/", rootHistSvc);
    ATH_CHECK(recoPhotonConvIsoFixedCutTightEfficiency.divide(
        recoPhotonConvIsoFixedCutTight.get(), truthPhotonConvRecoConv.get()));
    egammaMonitoring::EfficiencyPlot
        recoPhotonConvIsoFixedCutTightCaloOnlyEfficiency(
            "recoPhotonConvIsoFixedCutTightCaloOnlyEfficiency",
            "/MONITORING/recoPhotonConvIsoFixedCutTightCaloOnlyEfficiency/",
            rootHistSvc);
    ATH_CHECK(recoPhotonConvIsoFixedCutTightCaloOnlyEfficiency.divide(
        recoPhotonConvIsoFixedCutTightCaloOnly.get(),
        truthPhotonConvRecoConv.get()));
    egammaMonitoring::EfficiencyPlot recoPhotonConvIsoFixedCutLooseEfficiency(
        "recoPhotonConvIsoFixedCutLooseEfficiency",
        "/MONITORING/recoPhotonConvIsoFixedCutLooseEfficiency/", rootHistSvc);
    ATH_CHECK(recoPhotonConvIsoFixedCutLooseEfficiency.divide(
        recoPhotonConvIsoFixedCutLoose.get(), truthPhotonConvRecoConv.get()));
    egammaMonitoring::EfficiencyPlot recoPhotonConvLooseEfficiency(
        "recoPhotonConvLooseEfficiency",
        "/MONITORING/recoPhotonConvLooseEfficiency/", rootHistSvc);
    ATH_CHECK(recoPhotonConvLooseEfficiency.divide(
        recoPhotonConvLoose.get(), truthPhotonConvRecoConv.get()));
    egammaMonitoring::EfficiencyPlot recoPhotonConvTightEfficiency(
        "recoPhotonConvTightEfficiency",
        "/MONITORING/recoPhotonConvTightEfficiency/", rootHistSvc);
    ATH_CHECK(recoPhotonConvTightEfficiency.divide(
        recoPhotonConvTight.get(), truthPhotonConvRecoConv.get()));
    egammaMonitoring::EfficiencyPlot recoPhotonUnconvLooseEfficiency(
        "recoPhotonUnconvLooseEfficiency",
        "/MONITORING/recoPhotonUnconvLooseEfficiency/", rootHistSvc);
    ATH_CHECK(recoPhotonUnconvLooseEfficiency.divide(
        recoPhotonUnconvLoose.get(), truthPhotonUnconvRecoUnconv.get()));
    egammaMonitoring::EfficiencyPlot recoPhotonUnconvTightEfficiency(
        "recoPhotonUnconvTightEfficiency",
        "/MONITORING/recoPhotonUnconvTightEfficiency/", rootHistSvc);
    ATH_CHECK(recoPhotonUnconvTightEfficiency.divide(
        recoPhotonUnconvTight.get(), truthPhotonUnconvRecoUnconv.get()));
 
    egammaMonitoring::WidthPlot truthPhotonRecoPhotonWidth(
        "truthPhotonRecoPhotonWidth", "/MONITORING/truthPhotonRecoPhotonWidth/",
        rootHistSvc);
    ATH_CHECK(truthPhotonRecoPhotonWidth.fill(truthPhotonRecoPhoton.get()));
    egammaMonitoring::WidthPlot truthPhotonConvPhotonWidth(
        "truthPhotonConvPhotonWidth", "/MONITORING/truthPhotonConvPhotonWidth/",
        rootHistSvc);
    ATH_CHECK(truthPhotonConvPhotonWidth.fill(truthPhotonConvPhoton.get()));
    egammaMonitoring::WidthPlot truthPhotonConvRecoConvWidth(
        "truthPhotonConvRecoConvWidth",
        "/MONITORING/truthPhotonConvRecoConvWidth/", rootHistSvc);
    ATH_CHECK(truthPhotonConvRecoConvWidth.fill(truthPhotonConvRecoConv.get()));
    egammaMonitoring::WidthPlot truthPhotonConvRecoConv1SiWidth(
        "truthPhotonConvRecoConv1SiWidth",
        "/MONITORING/truthPhotonConvRecoConv1SiWidth/", rootHistSvc);
    ATH_CHECK(
        truthPhotonConvRecoConv1SiWidth.fill(truthPhotonConvRecoConv1Si.get()));
    egammaMonitoring::WidthPlot truthPhotonConvRecoConv2SiWidth(
        "truthPhotonConvRecoConv2SiWidth",
        "/MONITORING/truthPhotonConvRecoConv2SiWidth/", rootHistSvc);
    ATH_CHECK(
        truthPhotonConvRecoConv2SiWidth.fill(truthPhotonConvRecoConv2Si.get()));
    if (m_hasTRT) {
      egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv1TRTEfficiency(
          "truthPhotonConvRecoConv1TRTEfficiency",
          "/MONITORING/truthPhotonConvRecoConv1TRTEfficiency/", rootHistSvc);
      ATH_CHECK(truthPhotonConvRecoConv1TRTEfficiency.divide(
          truthPhotonConvRecoConv1TRT.get(), truthPhotonConvPhoton.get()));
      egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv2TRTEfficiency(
          "truthPhotonConvRecoConv2TRTEfficiency",
          "/MONITORING/truthPhotonConvRecoConv2TRTEfficiency/", rootHistSvc);
      ATH_CHECK(truthPhotonConvRecoConv2TRTEfficiency.divide(
          truthPhotonConvRecoConv2TRT.get(), truthPhotonConvPhoton.get()));
      egammaMonitoring::EfficiencyPlot truthPhotonConvRecoConv2SiTRTEfficiency(
          "truthPhotonConvRecoConv2SiTRTEfficiency",
          "/MONITORING/truthPhotonConvRecoConv2SiTRTEfficiency/", rootHistSvc);
      ATH_CHECK(truthPhotonConvRecoConv2SiTRTEfficiency.divide(
          truthPhotonConvRecoConv2SiTRT.get(), truthPhotonConvPhoton.get()));
      egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConv1TRTEfficiency(
          "truthPhotonUnconvRecoConv1TRTEfficiency",
          "/MONITORING/truthPhotonUnconvRecoConv1TRTEfficiency/", rootHistSvc);
      ATH_CHECK(truthPhotonUnconvRecoConv1TRTEfficiency.divide(
          truthPhotonUnconvRecoConv1TRT.get(), truthPhotonUnconvPhoton.get()));
      egammaMonitoring::EfficiencyPlot truthPhotonUnconvRecoConv2TRTEfficiency(
          "truthPhotonUnconvRecoConv2TRTEfficiency",
          "/MONITORING/truthPhotonUnconvRecoConv2TRTEfficiency/", rootHistSvc);
      ATH_CHECK(truthPhotonUnconvRecoConv2TRTEfficiency.divide(
          truthPhotonUnconvRecoConv2TRT.get(), truthPhotonUnconvPhoton.get()));
      egammaMonitoring::EfficiencyPlot
          truthPhotonUnconvRecoConv2SiTRTEfficiency(
              "truthPhotonUnconvRecoConv2SiTRTEfficiency",
              "/MONITORING/truthPhotonUnconvRecoConv2SiTRTEfficiency/",
              rootHistSvc);
      ATH_CHECK(truthPhotonUnconvRecoConv2SiTRTEfficiency.divide(
          truthPhotonUnconvRecoConv2SiTRT.get(),
          truthPhotonUnconvPhoton.get()));
      egammaMonitoring::WidthPlot truthPhotonConvRecoConv1TRTWidth(
          "truthPhotonConvRecoConv1TRTWidth",
          "/MONITORING/truthPhotonConvRecoConv1TRTWidth/", rootHistSvc);
      ATH_CHECK(truthPhotonConvRecoConv1TRTWidth.fill(
          truthPhotonConvRecoConv1TRT.get()));
      egammaMonitoring::WidthPlot truthPhotonConvRecoConv2TRTWidth(
          "truthPhotonConvRecoConv2TRTWidth",
          "/MONITORING/truthPhotonConvRecoConv2TRTWidth/", rootHistSvc);
      ATH_CHECK(truthPhotonConvRecoConv2TRTWidth.fill(
          truthPhotonConvRecoConv2TRT.get()));
      egammaMonitoring::WidthPlot truthPhotonConvRecoConv2SiTRTWidth(
          "truthPhotonConvRecoConv2SiTRTWidth",
          "/MONITORING/truthPhotonConvRecoConv2SiTRTWidth/", rootHistSvc);
      ATH_CHECK(truthPhotonConvRecoConv2SiTRTWidth.fill(
          truthPhotonConvRecoConv2SiTRT.get()));
    }
    egammaMonitoring::WidthPlot truthPhotonConvRecoUnconvWidth(
        "truthPhotonConvRecoUnconvWidth",
        "/MONITORING/truthPhotonConvRecoUnconvWidth/", rootHistSvc);
    ATH_CHECK(
        truthPhotonConvRecoUnconvWidth.fill(truthPhotonConvRecoUnconv.get()));
    egammaMonitoring::WidthPlot truthPhotonUnconvPhotonWidth(
        "truthPhotonUnconvPhotonWidth",
        "/MONITORING/truthPhotonUnconvPhotonWidth/", rootHistSvc);
    ATH_CHECK(truthPhotonUnconvPhotonWidth.fill(truthPhotonUnconvPhoton.get()));
    egammaMonitoring::WidthPlot truthPhotonUnconvRecoConvWidth(
        "truthPhotonUnconvRecoConvWidth",
        "/MONITORING/truthPhotonUnconvRecoConvWidth/", rootHistSvc);
    ATH_CHECK(
        truthPhotonUnconvRecoConvWidth.fill(truthPhotonUnconvRecoConv.get()));
    egammaMonitoring::WidthPlot truthPhotonUnconvRecoUnconvWidth(
        "truthPhotonUnconvRecoUnconvWidth",
        "/MONITORING/truthPhotonUnconvRecoUnconvWidth/", rootHistSvc);
    ATH_CHECK(truthPhotonUnconvRecoUnconvWidth.fill(
        truthPhotonUnconvRecoUnconv.get()));
  } else if ("dataZ" == m_sampleType) {
    ATH_CHECK(ZeePostProc());
  }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode EgammaMonitoring::initialize ( )

virtual

Definition at line 30 of file EgammaMonitoring.cxx.

                                        {
  ATH_MSG_INFO("********************  Running over " << m_sampleType
                                                     << " ******************");
  ATH_CHECK(service("THistSvc", rootHistSvc));
 
  showerShapesAll = std::make_unique<egammaMonitoring::ShowerShapesHistograms>(
      "showerShapesAll", "Shower Shapes ", "/MONITORING/showerShapesAll/",
      rootHistSvc);
 
  showerShapes10GeV =
      std::make_unique<egammaMonitoring::ShowerShapesHistograms>(
          "showerShapes10GeV", "Shower Shapes - 10 GeV",
          "/MONITORING/showerShapes10GeV/", rootHistSvc);
 
  isolationAll = std::make_unique<egammaMonitoring::IsolationHistograms>(
      "isolationAll", "Isolation ", "/MONITORING/isolationAll/", rootHistSvc);
 
  ATH_CHECK(showerShapesAll->initializePlots());
  ATH_CHECK(showerShapes10GeV->initializePlots());
  ATH_CHECK(isolationAll->initializePlots(m_sampleType == "electron"));
 
  if ("dataZ" != m_sampleType) {
    clusterAll = std::make_unique<egammaMonitoring::ClusterHistograms>(
        "clustersAll", "Clusters", "/MONITORING/clusterAll/", rootHistSvc);
 
    cluster10GeV = std::make_unique<egammaMonitoring::ClusterHistograms>(
        "clusters10GeV", "Clusters - 10 GeV", "/MONITORING/cluster10GeV/",
        rootHistSvc);
 
    clusterPromptAll = std::make_unique<egammaMonitoring::ClusterHistograms>(
        "clustersPromptAll", "Clusters from Prompt",
        "/MONITORING/clusterPromptAll/", rootHistSvc);
 
    clusterPrompt10GeV = std::make_unique<egammaMonitoring::ClusterHistograms>(
        "clustersPrompt10GeV", "Clusters from Prompt - 10 GeV",
        "/MONITORING/clusterPrompt10GeV/", rootHistSvc);
 
    ATH_CHECK(clusterAll->initializePlots());
    ATH_CHECK(cluster10GeV->initializePlots());
    ATH_CHECK(clusterPromptAll->initializePlots());
    ATH_CHECK(clusterPrompt10GeV->initializePlots());
  } else {
    m_clusterReco = std::make_unique<egammaMonitoring::RecoClusterHistograms>(
        "clustersReco", "Clusters from Z->ee candidates in data",
        "/MONITORING/recoCluster/", rootHistSvc);
    recoElectronAll =
        std::make_unique<egammaMonitoring::RecoElectronHistograms>(
            "recoElectronAll", "Reco electrons from Z->ee candidates in data",
            "/MONITORING/recoZElectron/", rootHistSvc);
    m_diElectron = std::make_unique<egammaMonitoring::DiObjectHistograms>(
        "diElectrons", "Z->ee candidates in data", "/MONITORING/diElectrons/",
        rootHistSvc);
    ATH_CHECK(m_clusterReco->initializePlots());
    recoElectronAll->isData();
    ATH_CHECK(recoElectronAll->initializePlots());
    ATH_CHECK(m_diElectron->initializePlots());
  }
 
  if ("electron" == m_sampleType) {
 
    recoElectronAll =
        std::make_unique<egammaMonitoring::RecoElectronHistograms>(
            "recoElectronAll", "Electrons Reco Electron",
            "/MONITORING/recoElectronAll/", rootHistSvc);
 
    truthElectronAll =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthElectronAll", "All Truth Electrons",
            "/MONITORING/truthElectronAll/", rootHistSvc);
 
    truthPromptElectronAll =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthPromptElectronAll", "All Truth Prompt Electrons",
            "/MONITORING/truthPromptElectronAll/", rootHistSvc);
 
    truthElectronRecoElectronAll =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthElectronRecoElectronAll", "Truth Electrons Reco Electron",
            "/MONITORING/truthElectronRecoElectronAll/", rootHistSvc);
 
    truthPromptElectronWithTrack =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthPromptElectronWithTrack", "Truth Prompt Electrons With Track",
            "/MONITORING/truthPromptElectronWithTrack/", rootHistSvc);
 
    truthPromptElectronWithGSFTrack =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthPromptElectronWithGSFTrack",
            "Truth Prompt Electrons With GSFTrack",
            "/MONITORING/truthPromptElectronWithGSFTrack/", rootHistSvc);
 
    truthPromptElectronWithReco =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthPromptElectronWithReco",
            "Truth Prompt Electrons With GSFTrack or just with a fwd cluster",
            "/MONITORING/truthPromptElectronWithReco/", rootHistSvc);
 
    truthPromptElectronWithRecoTrack =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthPromptElectronWithRecoTrack",
            "Truth Prompt Electrons With GSFTrack",
            "/MONITORING/truthPromptElectronWithRecoTrack/", rootHistSvc);
 
    truthRecoElectronLoose =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthRecoElectronLooseLH", "LLH Electrons Reco Electron",
            "/MONITORING/truthRecoElectronLooseLH/", rootHistSvc);
 
    truthRecoElectronMedium =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthRecoElectronMediumLH", "MLH Electrons Reco Electron",
            "/MONITORING/truthRecoElectronMediumLH/", rootHistSvc);
 
    truthRecoElectronTight =
        std::make_unique<egammaMonitoring::TruthElectronHistograms>(
            "truthRecoElectronTightLH", "TLH Electrons Reco Electron",
            "/MONITORING/truthRecoElectronTightLH/", rootHistSvc);
 
    if (!m_FwdElectronsKey.empty()) {
      recoElectronAll->hasFwd();
      truthElectronAll->hasFwd();
      truthPromptElectronAll->hasFwd();
      truthElectronRecoElectronAll->hasFwd();
      truthPromptElectronWithTrack->hasFwd();
      truthPromptElectronWithGSFTrack->hasFwd();
      truthPromptElectronWithReco->hasFwd();
      truthPromptElectronWithRecoTrack->hasFwd();
      truthRecoElectronLoose->hasFwd();
      truthRecoElectronMedium->hasFwd();
      truthRecoElectronTight->hasFwd();
    }
 
    ATH_CHECK(recoElectronAll->initializePlots());
    ATH_CHECK(truthRecoElectronLoose->initializePlots());
    ATH_CHECK(truthRecoElectronMedium->initializePlots());
    ATH_CHECK(truthRecoElectronTight->initializePlots());
    ATH_CHECK(truthElectronAll->initializePlots(true));
    ATH_CHECK(truthPromptElectronAll->initializePlots(true));
    ATH_CHECK(truthElectronRecoElectronAll->initializePlots());
    ATH_CHECK(truthPromptElectronWithTrack->initializePlots(true));
    ATH_CHECK(truthPromptElectronWithGSFTrack->initializePlots(true));
    ATH_CHECK(truthPromptElectronWithReco->initializePlots());
    ATH_CHECK(truthPromptElectronWithRecoTrack->initializePlots());
  } // electron Hists
 
  if ("gamma" == m_sampleType) {
 
    // all reco photons
    recoPhotonAll = std::make_unique<egammaMonitoring::RecoPhotonHistograms>(
        "recoPhotonAll", "Reco Photon", "/MONITORING/recoPhotonAll/",
        rootHistSvc);
    ATH_CHECK(recoPhotonAll->initializePlots());
 
    clusterConvPhoton = std::make_unique<egammaMonitoring::ClusterHistograms>(
        "clusterConvPhoton", "Clusters from Converted Photons",
        "/MONITORING/clusterConvPhoton/", rootHistSvc);
 
    clusterConvPhotonSi = std::make_unique<egammaMonitoring::ClusterHistograms>(
        "clusterConvPhotonSi", "Clusters from Converted Photons - Si",
        "/MONITORING/clusterConvPhotonSi/", rootHistSvc);
 
    clusterConvPhotonSiSi =
        std::make_unique<egammaMonitoring::ClusterHistograms>(
            "clusterConvPhotonSiSi", "Clusters from Converted Photons - SiSi",
            "/MONITORING/clusterConvPhotonSiSi/", rootHistSvc);
 
    clusterUnconvPhoton = std::make_unique<egammaMonitoring::ClusterHistograms>(
        "clusterUnconvPhoton", "Clusters from Converted Photons",
        "/MONITORING/clusterUnconvPhoton/", rootHistSvc);
 
    // Cluster information
    ATH_CHECK(clusterConvPhoton->initializePlots());
    ATH_CHECK(clusterConvPhotonSi->initializePlots());
    ATH_CHECK(clusterConvPhotonSiSi->initializePlots());
    ATH_CHECK(clusterUnconvPhoton->initializePlots());
 
    if (m_hasTRT) {
      clusterConvPhotonTRT =
          std::make_unique<egammaMonitoring::ClusterHistograms>(
              "clusterConvPhotonTRT", "Clusters from Converted Photons - TRT",
              "/MONITORING/clusterConvPhotonTRT/", rootHistSvc);
 
      clusterConvPhotonTRTTRT =
          std::make_unique<egammaMonitoring::ClusterHistograms>(
              "clusterConvPhotonTRTTRT",
              "Clusters from Converted Photons - TRTTRT",
              "/MONITORING/clusterConvPhotonTRTTRT/", rootHistSvc);
 
      clusterConvPhotonSiTRT =
          std::make_unique<egammaMonitoring::ClusterHistograms>(
              "clusterConvPhotonSiTRT",
              "Clusters from Converted Photons - SiTRT",
              "/MONITORING/clusterConvPhotonSiTRT/", rootHistSvc);
 
      truthPhotonConvRecoConv1TRT =
          std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
              "truthConvRecoConv1TRT", "truthConvRecoConv1TRT",
              "/MONITORING/truthConvRecoConv1TRT/", rootHistSvc);
 
      truthPhotonConvRecoConv2TRT =
          std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
              "truthConvRecoConv2TRT", "truthConvRecoConv2TRT",
              "/MONITORING/truthConvRecoConv2TRT/", rootHistSvc);
 
      truthPhotonConvRecoConv2SiTRT =
          std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
              "truthConvRecoConv2SiTRT", "truthConvRecoConv2SiTRT",
              "/MONITORING/truthConvRecoConv2SiTRT/", rootHistSvc);
 
      truthPhotonUnconvRecoConv1TRT =
          std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
              "truthUnconvRecoConv1TRT", "truthUnconvRecoConv1TRT",
              "/MONITORING/truthUnconvRecoConv1TRT/", rootHistSvc);
 
      truthPhotonUnconvRecoConv2TRT =
          std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
              "truthUnconvRecoConv2TRT", "truthUnconvRecoConv2TRT",
              "/MONITORING/truthUnconvRecoConv2TRT/", rootHistSvc);
 
      truthPhotonUnconvRecoConv2SiTRT =
          std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
              "truthUnconvRecoConv2SiTRT", "truthUnconvRecoConv2SiTRT",
              "/MONITORING/truthUnconvRecoConv2SiTRT/", rootHistSvc);
 
      ATH_CHECK(truthPhotonConvRecoConv1TRT->initializePlots());
      ATH_CHECK(truthPhotonConvRecoConv2TRT->initializePlots());
      ATH_CHECK(truthPhotonConvRecoConv2SiTRT->initializePlots());
      ATH_CHECK(truthPhotonUnconvRecoConv1TRT->initializePlots());
      ATH_CHECK(truthPhotonUnconvRecoConv2TRT->initializePlots());
      ATH_CHECK(truthPhotonUnconvRecoConv2SiTRT->initializePlots());
      ATH_CHECK(clusterConvPhotonTRT->initializePlots());
      ATH_CHECK(clusterConvPhotonTRTTRT->initializePlots());
      ATH_CHECK(clusterConvPhotonSiTRT->initializePlots());
    }
 
    // All truth
    truthPhotonAll = std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
        "truthPhotonAll", "truthPhotonAll", "/MONITORING/truthPhotonAll/",
        rootHistSvc);
 
    truthPhotonAllUnconv =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthPhotonAllUnconv", "truthPhotonAllUnconv",
            "/MONITORING/truthPhotonAllUnconv/", rootHistSvc);
 
    truthPhotonAllConv =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthPhotonAllConv", "truthPhotonAllConv",
            "/MONITORING/truthPhotonAllConv/", rootHistSvc);
 
    truthPhotonAllLateConv =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthPhotonAllLateConv", "truthPhotonAllLateConv",
            "/MONITORING/truthPhotonAllLateConv/", rootHistSvc);
 
    // Reco and truth-matched
    truthPhotonRecoPhoton =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthPhotonRecoPhoton", "truthPhotonRecoPhoton",
            "/MONITORING/truthPhotonRecoPhoton/", rootHistSvc);
 
    truthPhotonRecoPhotonOrElectron =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthPhotonRecoPhotonOrElectron",
            "truthPhotonRecoPhotonOrElectron",
            "/MONITORING/truthPhotonRecoPhotonOrElectron/", rootHistSvc);
 
    truthPhotonConvPhoton =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthConvPhoton", "truthConvPhoton",
            "/MONITORING/truthConvPhoton/", rootHistSvc);
 
    truthPhotonConvRecoConv =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthConvRecoConv", "truthConvRecoConv",
            "/MONITORING/truthConvRecoConv/", rootHistSvc);
 
    truthPhotonConvRecoConv1Si =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthConvRecoConv1Si", "truthConvRecoConv1Si",
            "/MONITORING/truthConvRecoConv1Si/", rootHistSvc);
 
    truthPhotonConvRecoConv2Si =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthConvRecoConv2Si", "truthConvRecoConv2Si",
            "/MONITORING/truthConvRecoConv2Si/", rootHistSvc);
 
    truthPhotonConvRecoUnconv =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthConvRecoUnconv", "truthConvRecoUnconv",
            "/MONITORING/truthConvRecoUnconv/", rootHistSvc);
 
    truthPhotonUnconvPhoton =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthUnconvPhoton", "truthUnconvPhoton",
            "/MONITORING/truthUnconvPhoton/", rootHistSvc);
 
    truthPhotonUnconvRecoConv =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthUnconvRecoConv", "truthUnconvRecoConv",
            "/MONITORING/truthUnconvRecoConv/", rootHistSvc);
 
    truthPhotonUnconvRecoConv1Si =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthUnconvRecoConv1Si", "truthUnconvRecoConv1Si",
            "/MONITORING/truthUnconvRecoConv1Si/", rootHistSvc);
 
    truthPhotonUnconvRecoConv2Si =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthUnconvRecoConv2Si", "truthUnconvRecoConv2Si",
            "/MONITORING/truthUnconvRecoConv2Si/", rootHistSvc);
 
    truthPhotonUnconvRecoUnconv =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "truthUnconvRecoUnconv", "truthUnconvRecoUnconv",
            "/MONITORING/truthUnconvRecoUnconv/", rootHistSvc);
 
    recoPhotonUnconvLoose =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonUnconvLoose", "Loose Photons Reco Photon",
            "/MONITORING/recoPhotonUnconvLoose/", rootHistSvc);
 
    recoPhotonUnconvTight =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonUnconvTight", "Tight Photons Reco Photon",
            "/MONITORING/recoPhotonUnconvTight/", rootHistSvc);
 
    recoPhotonConvLoose =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonConvLoose", "Loose Photons Reco Photon",
            "/MONITORING/recoPhotonConvLoose/", rootHistSvc);
 
    recoPhotonConvTight =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonConvTight", "Tight Photons Reco Photon",
            "/MONITORING/recoPhotonConvTight/", rootHistSvc);
 
    recoPhotonUnconvIsoFixedCutTight =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonUnconvIsoFixedCutTight",
            "Isolation Fixed Cut Tight Photons Reco Photon",
            "/MONITORING/recoPhotonUnconvIsoFixedCutTight/", rootHistSvc);
 
    recoPhotonUnconvIsoFixedCutTightCaloOnly =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonUnconvIsoFixedCutTightCaloOnly",
            "Isolation Fixed Cut Tight Calo Only Photons Reco Photon",
            "/MONITORING/recoPhotonUnconvIsoFixedCutTightCaloOnly/",
            rootHistSvc);
 
    recoPhotonUnconvIsoFixedCutLoose =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonUnconvIsoFixedCutLoose",
            "Isolation Fixed Cut Loose Photons Reco Photon",
            "/MONITORING/recoPhotonUnconvIsoFixedCutLoose/", rootHistSvc);
 
    recoPhotonConvIsoFixedCutTight =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonConvIsoFixedCutTight",
            "Isolation Fixed Cut Tight Photons Reco Photon",
            "/MONITORING/recoPhotonConvIsoFixedCutTight/", rootHistSvc);
 
    recoPhotonConvIsoFixedCutTightCaloOnly =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonConvIsoFixedCutTightCaloOnly",
            "Isolation Fixed Cut Tight Calo Only Photons Reco Photon",
            "/MONITORING/recoPhotonConvIsoFixedCutTightCaloOnly/", rootHistSvc);
 
    recoPhotonConvIsoFixedCutLoose =
        std::make_unique<egammaMonitoring::TruthPhotonHistograms>(
            "recoPhotonConvIsoFixedCutLoose",
            "Isolation Fixed Cut Loose Photons Reco Photon",
            "/MONITORING/recoPhotonConvIsoFixedCutLoose/", rootHistSvc);
 
    // for the track monitoring, consider
    // 4 track types (TRTSA or not, highpt or not) and
    // 4 truth matching types (all / e / not e / pion / no truth match)
    static const std::string typeMatch[5] = {"", "MatchElectron", "NotElectron",
                                             "MatchPion", "NotMatched"};
    static const std::string typeTrk[2] = {"", "TRT"};
    static const std::string ptTrk[2] = {"", "highpT"};
    static const std::string ctypeMatch[5] = {
        "", " match to electrons", " not matched to electrons",
        " match to pions", " not matched"};
    static const std::string ctypeTrk[2] = {"", " TRTSA"};
    static const std::string cptTrk[2] = {"", " pT > 3 GeV"};
 
    for (int im = 0; im < 5; im++) {
      std::string mN = typeMatch[im];
      for (int it = 0; it < (m_hasTRT ? 2 : 1); it++) {
        std::string tN = typeTrk[it];
        for (int ip = 0; ip < 2; ip++) {
          std::string pN = ptTrk[ip];
 
          std::string nN =
              "InDetTracks" + typeTrk[it] + typeMatch[im] + ptTrk[ip];
          std::string fN = "/MONITORING/" + nN + "/";
          std::string cN =
              "InDet Tracks" + ctypeTrk[it] + ctypeMatch[im] + cptTrk[ip];
 
          ATH_MSG_INFO("Creating histograms for " << nN);
          mapTrkHistograms[nN] =
              std::make_unique<egammaMonitoring::TrackHistograms>(
                  nN.c_str(), cN.c_str(), fN.c_str(), rootHistSvc);
          ATH_CHECK(mapTrkHistograms[nN]->initializePlots());
        }
      }
    }
 
    ATH_CHECK(truthPhotonAll->initializePlots());
    ATH_CHECK(truthPhotonAllUnconv->initializePlots());
    ATH_CHECK(truthPhotonAllConv->initializePlots());
    ATH_CHECK(truthPhotonAllLateConv->initializePlots());
    ATH_CHECK(truthPhotonRecoPhoton->initializePlots());
    ATH_CHECK(truthPhotonRecoPhotonOrElectron->initializePlots());
 
    ATH_CHECK(truthPhotonConvPhoton->initializePlots());
    ATH_CHECK(truthPhotonConvRecoConv->initializePlots());
    ATH_CHECK(truthPhotonConvRecoConv1Si->initializePlots());
    ATH_CHECK(truthPhotonConvRecoConv2Si->initializePlots());
    ATH_CHECK(truthPhotonConvRecoUnconv->initializePlots());
 
    ATH_CHECK(truthPhotonUnconvPhoton->initializePlots());
    ATH_CHECK(truthPhotonUnconvRecoConv->initializePlots());
    ATH_CHECK(truthPhotonUnconvRecoConv1Si->initializePlots());
    ATH_CHECK(truthPhotonUnconvRecoConv2Si->initializePlots());
    ATH_CHECK(truthPhotonUnconvRecoUnconv->initializePlots());
 
    ATH_CHECK(recoPhotonUnconvLoose->initializePlots());
    ATH_CHECK(recoPhotonUnconvTight->initializePlots());
    ATH_CHECK(recoPhotonConvLoose->initializePlots());
    ATH_CHECK(recoPhotonConvTight->initializePlots());
    ATH_CHECK(recoPhotonUnconvIsoFixedCutTight->initializePlots());
    ATH_CHECK(recoPhotonUnconvIsoFixedCutTightCaloOnly->initializePlots());
    ATH_CHECK(recoPhotonUnconvIsoFixedCutLoose->initializePlots());
    ATH_CHECK(recoPhotonConvIsoFixedCutTight->initializePlots());
    ATH_CHECK(recoPhotonConvIsoFixedCutTightCaloOnly->initializePlots());
    ATH_CHECK(recoPhotonConvIsoFixedCutLoose->initializePlots());
 
  } // gamma Hists
 
  if (m_sampleType != "gamma") {
    ATH_CHECK(m_ElectronsKey.initialize());
    ATH_CHECK(m_GSFTrackParticlesKey.initialize());
  }
 
  if ("electron" == m_sampleType) {
    //*****************ID selectors (3 levels)********************
    ATH_CHECK(m_Loose_Ele.retrieve());
    ATH_CHECK(m_Medium_Ele.retrieve());
    ATH_CHECK(m_Tight_Ele.retrieve());
 
    ATH_CHECK(m_FwdElectronsKey.initialize(!m_FwdElectronsKey.empty()));
 
    if (!m_FwdElectronsKey.empty()) {
      m_dR1 = new TH1D("dR1", ";#Delta R;Events", 1000, 0, 0.1);
      ATH_CHECK(rootHistSvc->regHist("/MONITORING/Check/dR1", m_dR1));
      m_dR2 = new TH1D("dR2", ";#Delta R;Events", 1000, 0, 0.1);
      ATH_CHECK(rootHistSvc->regHist("/MONITORING/Check/dR2", m_dR2));
 
      ATH_CHECK(m_Loose_FwdEle.retrieve());
      ATH_CHECK(m_Medium_FwdEle.retrieve());
      ATH_CHECK(m_Tight_FwdEle.retrieve());
    }
  }
 
  if ("gamma" == m_sampleType) {
    //*****************ID selectors (2 levels)********************
    ATH_CHECK(m_Loose_Photon.retrieve());
    ATH_CHECK(m_Tight_Photon.retrieve());
 
    //*****************Iso Requirements********************
    ATH_CHECK(m_IsoFixedCutTight.retrieve());
    ATH_CHECK(m_IsoFixedCutTightCaloOnly.retrieve());
    ATH_CHECK(m_IsoFixedCutLoose.retrieve());
 
    ATH_CHECK(m_PhotonsKey.initialize());
  }
 
  //***************** The handles used whatever the sample********************
  ATH_CHECK(m_eventInfoKey.initialize());
  ATH_CHECK(m_InDetTrackParticlesKey.initialize());
 
  if (m_sampleType != "dataZ") {
    ATH_CHECK(m_egTruthParticlesKey.initialize());
    ATH_CHECK(m_truthParticlesKey.initialize());
 
    //*****************MC Truth Classifier Requirement********************
    ATH_CHECK(m_mcTruthClassifier.retrieve());
  }
 
  return StatusCode::SUCCESS;
}

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 1357 of file EgammaMonitoring.cxx.

                                                                    {
  const xAOD::TruthParticle *truth = xAOD::TruthHelpers::getTruthParticle(tp);
  return truth && abs(truth->pdgId()) == 11;
}

matchedToPion()

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

staticprivate

Definition at line 1362 of file EgammaMonitoring.cxx.

                                                                {
  const xAOD::TruthParticle *truth = xAOD::TruthHelpers::getTruthParticle(tp);
  return truth && abs(truth->pdgId()) == 211;
}

msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

notMatchedToTruth()

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

staticprivate

Definition at line 1367 of file EgammaMonitoring.cxx.

                                                                    {
  const xAOD::TruthParticle *truth = xAOD::TruthHelpers::getTruthParticle(tp);
  return !truth;
}

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.

  {
    h.renounce();
    PBASE::renounce (h);
  }

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.

                                                          {
    handlesArray.renounce();
  }

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.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;
}

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.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

ZeePostProc()

StatusCode EgammaMonitoring::ZeePostProc ( )

private

Definition at line 1416 of file EgammaMonitoring.cxx.

                                         {
 
  TH1D *hRef = (TH1D *)m_diElectron->histoMap["mass"];
  double xmi = 66, xma = 116, eps = 0.01;
  int ib1 = hRef->FindBin(xmi + eps);
  int ib2 = hRef->FindBin(xma - eps);
  TH1D *hmee = new TH1D("mee", ";m_{ee} [GeV];Events / 0.5 GeV", ib2 - ib1 + 1,
                        xmi, xma);
  for (int ib = ib1; ib <= ib2; ib++) {
    double c = hRef->GetBinContent(ib);
    double ec = hRef->GetBinError(ib);
    hmee->SetBinContent(ib - ib1 + 1, c);
    hmee->SetBinError(ib - ib1 + 1, ec);
  }
  ATH_CHECK(rootHistSvc->regHist("/MONITORING/Data/mee", hmee));
 
  TString vsX[3] = {"Et", "Etetale0p8", "Eta"};
  TString coo[3] = {"x", "x", "y"};
  for (int iL = 0; iL < 5; iL++) {
    TH3D *nRef;
    if (iL < 4)
      nRef = m_clusterReco->m_histo3DMap[Form("hNcellsvseteta_Lr%i", iL)];
    else
      nRef = recoElectronAll->histo3DMap["eteta_eop"];
    for (int iX = 0; iX < 3; iX++) {
      if (iL == 4 && iX == 2)
        continue;
      // nCells vs eta
      if (iX == 1) {
        int ieta08 = nRef->GetYaxis()->FindBin(0.79);
        nRef->GetYaxis()->SetRange(1, ieta08);
      } else if (iX == 2) {
        nRef->GetYaxis()->SetRange(1, 25);
      }
      TH2D *nRefvsX = (TH2D *)nRef->Project3D(Form("z%s", coo[iX].Data()));
      TString pN;
      if (iL < 4)
        pN = Form("pn%ivs%s", iL, vsX[iX].Data());
      else
        pN = Form("pEopvs%s", vsX[iX].Data());
      TProfile *pRefvsX = nRefvsX->ProfileX(pN.Data());
      pRefvsX->SetTitle(pN.Data());
      pRefvsX->GetXaxis()->SetTitle(iX < 2 ? "E_{T} [GeV]" : "|#eta|");
      pRefvsX->GetYaxis()->SetTitle(iL < 4 ? Form("nCells_Lr%i", iL) : "E/p");
      ATH_CHECK(rootHistSvc->regHist(
          Form("/MONITORING/Data/%s", pRefvsX->GetName()), pRefvsX));
      delete nRefvsX;
    }
  }
  return StatusCode::SUCCESS;
}

ZeeSelection()

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

private

Definition at line 1372 of file EgammaMonitoring.cxx.

                                                                           {
  SG::ReadHandle<xAOD::ElectronContainer> RecoEl(m_ElectronsKey, ctx);
  SG::ReadHandle<xAOD::TrackParticleContainer> GSFTracks(m_GSFTrackParticlesKey,
                                                         ctx);
 
  const xAOD::Electron *e1 = nullptr, *e2 = nullptr;
  double pTL = -9e9, pTSL = -9e9;
  for (const auto *el : *RecoEl) {
    double pt = el->pt();
    if (pt < 15e3)
      continue;
    if (pt > pTL) {
      e2 = e1;
      pTSL = pTL;
      e1 = el;
      pTL = pt;
    } else if (pt > pTSL) {
      e2 = el;
      pTSL = pt;
    }
  }
 
  if (!e2)
    return StatusCode::SUCCESS;
 
  m_diElectron->fill(*e1, *e2, mu);
 
  m_clusterReco->fill(*e1);
  m_clusterReco->fill(*e2);
  recoElectronAll->fill(*e1);
  recoElectronAll->fill(*e2);
 
  showerShapesAll->fill(*e1);
  showerShapesAll->fill(*e2);
  if (e1->pt() > 10 * Gaudi::Units::GeV)
    showerShapes10GeV->fill(*e1);
  if (e2->pt() > 10 * Gaudi::Units::GeV)
    showerShapes10GeV->fill(*e2);
  isolationAll->fill(*e1);
  isolationAll->fill(*e2);
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

cluster10GeV

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

Definition at line 55 of file EgammaMonitoring.h.

clusterAll

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

Definition at line 54 of file EgammaMonitoring.h.

clusterConvPhoton

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

Definition at line 92 of file EgammaMonitoring.h.

clusterConvPhotonSi

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

Definition at line 93 of file EgammaMonitoring.h.

clusterConvPhotonSiSi

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

Definition at line 94 of file EgammaMonitoring.h.

clusterConvPhotonSiTRT

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

Definition at line 97 of file EgammaMonitoring.h.

clusterConvPhotonTRT

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

Definition at line 95 of file EgammaMonitoring.h.

clusterConvPhotonTRTTRT

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

Definition at line 96 of file EgammaMonitoring.h.

clusterPrompt10GeV

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

Definition at line 58 of file EgammaMonitoring.h.

clusterPromptAll

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

Definition at line 57 of file EgammaMonitoring.h.

clusterUnconvPhoton

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

Definition at line 98 of file EgammaMonitoring.h.

isolationAll

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

Definition at line 63 of file EgammaMonitoring.h.

m_CenFwdOverlap

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

private

Definition at line 226 of file EgammaMonitoring.h.

m_clusterReco

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

Definition at line 66 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 67 of file EgammaMonitoring.h.

m_dR1

TH1D* EgammaMonitoring::m_dR1 {}

private

Definition at line 228 of file EgammaMonitoring.h.

m_dR2

TH1D* EgammaMonitoring::m_dR2 {}

private

Definition at line 229 of file EgammaMonitoring.h.

m_egTruthParticlesKey

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

private

Definition at line 198 of file EgammaMonitoring.h.

m_ElectronsKey

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

private

Definition at line 204 of file EgammaMonitoring.h.

m_eventInfoKey

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

private

Definition at line 195 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 207 of file EgammaMonitoring.h.

m_GSFTrackParticlesKey

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

private

Definition at line 216 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 158 of file EgammaMonitoring.h.

m_InDetTrackParticlesKey

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

private

Definition at line 213 of file EgammaMonitoring.h.

m_IsoFixedCutLoose

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

private

Definition at line 187 of file EgammaMonitoring.h.

m_IsoFixedCutTight

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

private

Definition at line 183 of file EgammaMonitoring.h.

m_IsoFixedCutTightCaloOnly

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

private

Definition at line 185 of file EgammaMonitoring.h.

m_Loose_Ele

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

private

Selector tools.

Definition at line 163 of file EgammaMonitoring.h.

m_Loose_FwdEle

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

private

Definition at line 169 of file EgammaMonitoring.h.

m_Loose_Photon

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

private

Definition at line 177 of file EgammaMonitoring.h.

m_mcTruthClassifier

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

private

Definition at line 191 of file EgammaMonitoring.h.

m_Medium_Ele

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

private

Definition at line 165 of file EgammaMonitoring.h.

m_Medium_FwdEle

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

private

Definition at line 171 of file EgammaMonitoring.h.

m_PhotonsKey

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

private

Definition at line 210 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 154 of file EgammaMonitoring.h.

m_Tight_Ele

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

private

Definition at line 167 of file EgammaMonitoring.h.

m_Tight_FwdEle

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

private

Definition at line 173 of file EgammaMonitoring.h.

m_Tight_Photon

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

private

Definition at line 179 of file EgammaMonitoring.h.

m_truthParticlesKey

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

private

Definition at line 201 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 140 of file EgammaMonitoring.h.

recoElectronAll

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

Definition at line 70 of file EgammaMonitoring.h.

recoPhotonAll

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

Definition at line 100 of file EgammaMonitoring.h.

recoPhotonConvIsoFixedCutLoose

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

Definition at line 138 of file EgammaMonitoring.h.

recoPhotonConvIsoFixedCutTight

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

Definition at line 135 of file EgammaMonitoring.h.

recoPhotonConvIsoFixedCutTightCaloOnly

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

Definition at line 137 of file EgammaMonitoring.h.

recoPhotonConvLoose

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

Definition at line 127 of file EgammaMonitoring.h.

recoPhotonConvTight

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

Definition at line 128 of file EgammaMonitoring.h.

recoPhotonUnconvIsoFixedCutLoose

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

Definition at line 134 of file EgammaMonitoring.h.

recoPhotonUnconvIsoFixedCutTight

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

Definition at line 130 of file EgammaMonitoring.h.

recoPhotonUnconvIsoFixedCutTightCaloOnly

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

Definition at line 132 of file EgammaMonitoring.h.

recoPhotonUnconvLoose

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

Definition at line 125 of file EgammaMonitoring.h.

recoPhotonUnconvTight

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

Definition at line 126 of file EgammaMonitoring.h.

rootHistSvc

ITHistSvc* EgammaMonitoring::rootHistSvc = nullptr

Tools and services ///.

Definition at line 51 of file EgammaMonitoring.h.

showerShapes10GeV

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

Definition at line 62 of file EgammaMonitoring.h.

showerShapesAll

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

Definition at line 61 of file EgammaMonitoring.h.

truthElectronAll

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

Definition at line 71 of file EgammaMonitoring.h.

truthElectronRecoElectronAll

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

Definition at line 75 of file EgammaMonitoring.h.

truthPhotonAll

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

Definition at line 101 of file EgammaMonitoring.h.

truthPhotonAllConv

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

Definition at line 103 of file EgammaMonitoring.h.

truthPhotonAllLateConv

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

Definition at line 104 of file EgammaMonitoring.h.

truthPhotonAllUnconv

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

Definition at line 102 of file EgammaMonitoring.h.

truthPhotonConvPhoton

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

Definition at line 108 of file EgammaMonitoring.h.

truthPhotonConvRecoConv

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

Definition at line 109 of file EgammaMonitoring.h.

truthPhotonConvRecoConv1Si

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

Definition at line 110 of file EgammaMonitoring.h.

truthPhotonConvRecoConv1TRT

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

Definition at line 111 of file EgammaMonitoring.h.

truthPhotonConvRecoConv2Si

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

Definition at line 112 of file EgammaMonitoring.h.

truthPhotonConvRecoConv2SiTRT

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

Definition at line 114 of file EgammaMonitoring.h.

truthPhotonConvRecoConv2TRT

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

Definition at line 113 of file EgammaMonitoring.h.

truthPhotonConvRecoUnconv

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

Definition at line 115 of file EgammaMonitoring.h.

truthPhotonRecoPhoton

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

Definition at line 105 of file EgammaMonitoring.h.

truthPhotonRecoPhotonOrElectron

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

Definition at line 107 of file EgammaMonitoring.h.

truthPhotonUnconvPhoton

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

Definition at line 116 of file EgammaMonitoring.h.

truthPhotonUnconvRecoConv

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

Definition at line 117 of file EgammaMonitoring.h.

truthPhotonUnconvRecoConv1Si

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

Definition at line 118 of file EgammaMonitoring.h.

truthPhotonUnconvRecoConv1TRT

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

Definition at line 119 of file EgammaMonitoring.h.

truthPhotonUnconvRecoConv2Si

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

Definition at line 120 of file EgammaMonitoring.h.

truthPhotonUnconvRecoConv2SiTRT

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

Definition at line 123 of file EgammaMonitoring.h.

truthPhotonUnconvRecoConv2TRT

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

Definition at line 121 of file EgammaMonitoring.h.

truthPhotonUnconvRecoUnconv

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

Definition at line 124 of file EgammaMonitoring.h.

truthPromptElectronAll

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

Definition at line 73 of file EgammaMonitoring.h.

truthPromptElectronWithGSFTrack

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

Definition at line 79 of file EgammaMonitoring.h.

truthPromptElectronWithReco

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

Definition at line 81 of file EgammaMonitoring.h.

truthPromptElectronWithRecoTrack

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

Definition at line 83 of file EgammaMonitoring.h.

truthPromptElectronWithTrack

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

Definition at line 77 of file EgammaMonitoring.h.

truthRecoElectronLoose

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

Definition at line 85 of file EgammaMonitoring.h.

truthRecoElectronMedium

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

Definition at line 87 of file EgammaMonitoring.h.

truthRecoElectronTight

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

Definition at line 89 of file EgammaMonitoring.h.

---

The documentation for this class was generated from the following files:

• EgammaMonitoring.h
• EgammaMonitoring.cxx