#include <EgammaObjectCollectionMaker.h>

Inheritance diagram for top::EgammaObjectCollectionMaker:

Collaboration diagram for top::EgammaObjectCollectionMaker:

Public Member Functions
	EgammaObjectCollectionMaker (const std::string &name)

virtual	~EgammaObjectCollectionMaker ()

	EgammaObjectCollectionMaker (const EgammaObjectCollectionMaker &rhs)=delete

	EgammaObjectCollectionMaker (EgammaObjectCollectionMaker &&rhs)=delete

EgammaObjectCollectionMaker &	operator= (const EgammaObjectCollectionMaker &rhs)=delete

StatusCode	initialize ()
	Dummy implementation of the initialisation function. More...

StatusCode	executePhotons (bool)

StatusCode	executeElectrons (bool)

StatusCode	executeFwdElectrons (bool)

StatusCode	printoutPhotons ()

StatusCode	printoutElectrons ()

StatusCode	printoutFwdElectrons ()

virtual const std::list< CP::SystematicSet > &	specifiedSystematicsPhotons () const

virtual const std::list< CP::SystematicSet > &	specifiedSystematicsElectrons () const

virtual const std::list< CP::SystematicSet > &	specifiedSystematicsFwdElectrons () const

const std::list< CP::SystematicSet > &	recommendedSystematicsPhotons () const

const std::list< CP::SystematicSet > &	recommendedSystematicsElectrons () const

const std::list< CP::SystematicSet > &	recommendedSystematicsFwdElectrons () const

virtual void	print () const
	Print the state of the tool. 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	sysInitialize () override
	Perform system initialization for an algorithm. 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

Protected Member Functions
virtual void	specifiedSystematicsPhotons (const std::set< std::string > &specifiedSystematics)

virtual void	specifiedSystematicsElectrons (const std::set< std::string > &specifiedSystematics)

virtual void	specifiedSystematicsFwdElectrons (const std::set< std::string > &specifiedSystematics)

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

Private Attributes
std::shared_ptr< top::TopConfig >	m_config

std::list< CP::SystematicSet >	m_specifiedSystematicsPhotons

std::list< CP::SystematicSet >	m_specifiedSystematicsElectrons

std::list< CP::SystematicSet >	m_specifiedSystematicsFwdElectrons

std::list< CP::SystematicSet >	m_recommendedSystematicsPhotons

std::list< CP::SystematicSet >	m_recommendedSystematicsElectrons

std::list< CP::SystematicSet >	m_recommendedSystematicsFwdElectrons

ToolHandle< CP::IEgammaCalibrationAndSmearingTool >	m_calibrationTool

ToolHandle< IElectronPhotonShowerShapeFudgeTool >	m_photonFudgeTool

std::unordered_map< std::string, ToolHandle< CP::IIsolationSelectionTool > >	m_electronIsolationTools
	– Isolation –/// More...

std::unordered_map< std::string, ToolHandle< CP::IIsolationSelectionTool > >	m_photonIsolationTools

ToolHandle< CP::IIsolationCorrectionTool >	m_isolationCorr

bool	calibrateElectrons

bool	calibrateFwdElectrons

bool	calibratePhotons

bool	m_recomputePhotonFudge

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 45 of file EgammaObjectCollectionMaker.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ EgammaObjectCollectionMaker() [1/3]

top::EgammaObjectCollectionMaker::EgammaObjectCollectionMaker ( const std::string & name )

explicit

Definition at line 25 of file EgammaObjectCollectionMaker.cxx.

                                                                                 :
     asg::AsgTool(name),
     m_config(nullptr),
  
     m_specifiedSystematicsPhotons(),
     m_specifiedSystematicsElectrons(),
     m_specifiedSystematicsFwdElectrons(),
     m_recommendedSystematicsPhotons(),
     m_recommendedSystematicsElectrons(),
     m_recommendedSystematicsFwdElectrons(),
  
     m_calibrationTool("EgammaCalibrationAndSmearingTool"),
     m_photonFudgeTool("PhotonFudgeTool"),
  
     m_isolationCorr("IsolationCorrectionTool") {
     declareProperty("config", m_config);
   }

◆ ~EgammaObjectCollectionMaker()

virtual top::EgammaObjectCollectionMaker::~EgammaObjectCollectionMaker ( )

inlinevirtual

Definition at line 48 of file EgammaObjectCollectionMaker.h.

48 {}

◆ EgammaObjectCollectionMaker() [2/3]

top::EgammaObjectCollectionMaker::EgammaObjectCollectionMaker ( const EgammaObjectCollectionMaker & rhs )

delete

◆ EgammaObjectCollectionMaker() [3/3]

top::EgammaObjectCollectionMaker::EgammaObjectCollectionMaker ( EgammaObjectCollectionMaker && rhs )

delete

Member Function Documentation

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::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< AlgTool > >::detStore ( ) const

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ executeElectrons()

StatusCode top::EgammaObjectCollectionMaker::executeElectrons ( bool executeNominal )

– Get base electrons from xAOD –///

– Loop over all systematics –///

– if executeNominal, skip other systematics (and vice-versa) –///

– Tell tool which systematic to use -///

– Shallow copy of the xAOD –///

– Loop over the xAOD Container –///

– Isolation selection –///

– set links to original objects- needed for MET calculation –///

Definition at line 193 of file EgammaObjectCollectionMaker.cxx.

                                                                               {
     const xAOD::EventInfo* eventInfo(nullptr);
  
     top::check(evtStore()->retrieve(eventInfo, m_config->sgKeyEventInfo()), "Failed to retrieve EventInfo");
     float beam_pos_sigma_x = eventInfo->beamPosSigmaX();
     float beam_pos_sigma_y = eventInfo->beamPosSigmaY();
     float beam_pos_sigma_xy = eventInfo->beamPosSigmaXY();
  
     const xAOD::ElectronContainer* xaod(nullptr);
     top::check(evtStore()->retrieve(xaod, m_config->sgKeyElectrons()), "Failed to retrieve Electrons");
  
     for (auto systematic : m_specifiedSystematicsElectrons) {
       if (executeNominal && !m_config->isSystNominal(m_config->systematicName(systematic.hash()))) continue;
       if (!executeNominal && m_config->isSystNominal(m_config->systematicName(systematic.hash()))) continue;
  
       top::check(m_calibrationTool->applySystematicVariation(systematic), "Failed to applySystematicVariation");
  
       std::pair< xAOD::ElectronContainer*, xAOD::ShallowAuxContainer* > shallow_xaod_copy = xAOD::shallowCopyContainer(
         *xaod);
  
       for (auto electron : *(shallow_xaod_copy.first)) {
         // Apply correction to object
         // should not affect derivations if there is no CC or track thinning
         if (electron->caloCluster() != nullptr && electron->trackParticle() != nullptr) { // derivations might remove CC
                                                                                           // and tracks for low pt
                                                                                           // electrons
           if (calibrateElectrons) {
             top::check(m_calibrationTool->applyCorrection(*electron), "Failed to applyCorrection");
             // TODO -- revert back once the isolation corrections are fully settled in R22
             // top::check(m_isolationCorr->applyCorrection(*electron), "Failed to apply leakage correction");
           }
  
           double d0sig = xAOD::TrackingHelpers::d0significance(electron->trackParticle(),
                                                                beam_pos_sigma_x,
                                                                beam_pos_sigma_y,
                                                                beam_pos_sigma_xy);
           electron->auxdecor<float>("d0sig") = d0sig;
  
           if (eventInfo->isAvailable<float>("AnalysisTop_PRIVTX_z_position")) {
             float vtx_z = eventInfo->auxdata<float>("AnalysisTop_PRIVTX_z_position");
             float delta_z0 = electron->trackParticle()->z0() + electron->trackParticle()->vz() - vtx_z;
             electron->auxdecor<float>("delta_z0") = delta_z0;
             electron->auxdecor<float>("delta_z0_sintheta") = delta_z0 * std::sin(electron->trackParticle()->theta());
           }
         }
  
         for (const auto& electronIsoWP : m_electronIsolationTools) {
           const char passIsol = (electronIsoWP.second->accept(*electron)) ? 1 : 0;
           electron->auxdecor<char>("AnalysisTop_Isol_" + electronIsoWP.first) = passIsol;
         }
       } // end electron loop
  
       bool setLinks = xAOD::setOriginalObjectLink(*xaod, *shallow_xaod_copy.first);
       if (!setLinks) ATH_MSG_ERROR(" Cannot set original object links for electrons, MET recalculation may struggle");
  
       // Save corrected xAOD Container to StoreGate / TStore
       std::string outputSGKey = m_config->sgKeyElectronsStandAlone(systematic.hash());
       std::string outputSGKeyAux = outputSGKey + "Aux.";
  
       StatusCode save = evtStore()->tds()->record(shallow_xaod_copy.first, outputSGKey);
       StatusCode saveAux = evtStore()->tds()->record(shallow_xaod_copy.second, outputSGKeyAux);
  
       if (!save || !saveAux) {
         return StatusCode::FAILURE;
       }
     }  // Loop over all systematics
  
     return StatusCode::SUCCESS;
   }

◆ executeFwdElectrons()

StatusCode top::EgammaObjectCollectionMaker::executeFwdElectrons ( bool executeNominal )

– Get base electrons from xAOD –///

– Loop over all systematics –///

– if executeNominal, skip other systematics (and vice-versa) –///

– Tell tool which systematic to use -///

– Shallow copy of the xAOD –///

– Loop over the xAOD Container –///

– set links to original objects- needed for MET calculation –///

Definition at line 271 of file EgammaObjectCollectionMaker.cxx.

                                                                                  {
     const xAOD::EventInfo* eventInfo(nullptr);
  
     top::check(evtStore()->retrieve(eventInfo, m_config->sgKeyEventInfo()), "Failed to retrieve EventInfo");
  
     const xAOD::ElectronContainer* xaod(nullptr);
     top::check(evtStore()->retrieve(xaod, m_config->sgKeyFwdElectrons()), "Failed to retrieve Fwd Electrons");
  
     for (auto systematic : m_specifiedSystematicsFwdElectrons) {
       if (executeNominal && !m_config->isSystNominal(m_config->systematicName(systematic.hash()))) continue;
       if (!executeNominal && m_config->isSystNominal(m_config->systematicName(systematic.hash()))) continue;
  
       top::check(m_calibrationTool->applySystematicVariation(systematic), "Failed to applySystematicVariation");
  
       std::pair< xAOD::ElectronContainer*, xAOD::ShallowAuxContainer* > shallow_xaod_copy = xAOD::shallowCopyContainer(
         *xaod);
  
       for (auto electron : *(shallow_xaod_copy.first)) {
         // Apply correction to object
         // should not affect derivations if there is no CC or track thinning
         if (electron->caloCluster() != nullptr) { // derivations might remove CC for low pt electrons
           if (calibrateFwdElectrons) {
             top::check(m_calibrationTool->applyCorrection(*electron), "Failed to applyCorrection to fwd electrons");
           }
         }
       }//end of loop on electrons
  
       bool setLinks = xAOD::setOriginalObjectLink(*xaod, *shallow_xaod_copy.first);
       if (!setLinks) ATH_MSG_ERROR(" Cannot set original object links for fwd electrons");
  
       // Save corrected xAOD Container to StoreGate / TStore
       std::string outputSGKey = m_config->sgKeyFwdElectronsStandAlone(systematic.hash());
       std::string outputSGKeyAux = outputSGKey + "Aux.";
  
       StatusCode save = evtStore()->tds()->record(shallow_xaod_copy.first, outputSGKey);
       StatusCode saveAux = evtStore()->tds()->record(shallow_xaod_copy.second, outputSGKeyAux);
  
       if (!save || !saveAux) {
         return StatusCode::FAILURE;
       }
     }  // Loop over all systematics
  
     return StatusCode::SUCCESS;
   }

◆ executePhotons()

StatusCode top::EgammaObjectCollectionMaker::executePhotons ( bool executeNominal )

– Get base photons from xAOD –///

– Loop over all systematics –///

– if executeNominal, skip other systematics (and vice-versa) –///

– Tell tool which systematic to use –///

– Shallow copy of the xAOD –///

– Loop over the xAOD Container and apply corrections–///

– Apply correction to object –///

– Isolation selection –///

– set links to original objects- needed for MET calculation –///

– Save corrected xAOD Container to StoreGate / TStore –///

Definition at line 116 of file EgammaObjectCollectionMaker.cxx.

                                                                             {
     const xAOD::PhotonContainer* xaod(nullptr);
  
     top::check(evtStore()->retrieve(xaod, m_config->sgKeyPhotons()), "Failed to retrieve Photons");
  
     for (auto systematic : m_specifiedSystematicsPhotons) {
       if (executeNominal && !m_config->isSystNominal(m_config->systematicName(systematic.hash()))) continue;
       if (!executeNominal && m_config->isSystNominal(m_config->systematicName(systematic.hash()))) continue;
  
       top::check(m_calibrationTool->applySystematicVariation(systematic), "Failed to applySystematicVariation");
  
       std::pair< xAOD::PhotonContainer*, xAOD::ShallowAuxContainer* > shallow_xaod_copy = xAOD::shallowCopyContainer(
         *xaod);
  
       for (auto photon : *(shallow_xaod_copy.first)) {
         // Needs a calo cluster so carry on if no cluster
         if (!photon->caloCluster()) continue;
  
         if (calibratePhotons) {
           top::check(m_calibrationTool->applyCorrection(*photon),
                      "Failed to applyCorrection");
           // TODO -- revert back once the isolation corrections are fully settled in R22
           // top::check(m_isolationCorr->applyCorrection(*photon),
           //            "Failed to apply photon isolation leakage correction");
  
           if (m_config->isMC() && !m_config->isAFII() && m_recomputePhotonFudge && m_config->getDerivationStream() != "PHYS") {
             if (m_photonFudgeTool->applyCorrection(*photon) == 0) { // 0: error, 1: OutOfRange (not possible), 2: OK
               // ElectronPhotonShowerShapeFudgeTool::applyCorrection can return an error for 3 reasons
               // 1) shower shapes not all found, 2) bad cluster, 3) shower shapes not all set.
               // 1 & 3 are most likely due to the smart slimming (no PhotonsDetailedCPContent), whereas 2 is an actual
               // issue.
               // Check for case 2 now:
               if (photon->caloCluster() == nullptr) {
                 ATH_MSG_ERROR("Photon " << photon << " had no calo cluster - this is bad!");
                 return StatusCode::FAILURE;
               } else {
                 // We're now in case 1 or 3
                 ATH_MSG_WARNING(
                   " Didn't find the necessary photon shower shapes variables for the ElectronPhotonShowerShapeFudgeTool! (but don't worry, you're still getting correctly ID'd photons)");
                 // Keep going, but don't try to use the tool anymore
                 m_recomputePhotonFudge = false;
               }
             }
           }
         }
         for (const auto& photonIsoWP : m_photonIsolationTools) {
           const char passIsol = (photonIsoWP.second->accept(*photon)) ? 1 : 0;
           photon->auxdecor<char>("AnalysisTop_Isol_" + photonIsoWP.first) = passIsol;
         }
       } // end photon loop
  
       bool setLinks = xAOD::setOriginalObjectLink(*xaod, *shallow_xaod_copy.first);
       if (!setLinks) ATH_MSG_ERROR(" Cannot set original object links for photons, MET recalculation may struggle");
  
       std::string outputSGKey = m_config->sgKeyPhotons(systematic.hash());
       std::string outputSGKeyAux = outputSGKey + "Aux.";
  
       StatusCode save = evtStore()->tds()->record(shallow_xaod_copy.first, outputSGKey);
       StatusCode saveAux = evtStore()->tds()->record(shallow_xaod_copy.second, outputSGKeyAux);
  
       if (!save || !saveAux) {
         return StatusCode::FAILURE;
       }
     }  // Loop over all systematics
     return StatusCode::SUCCESS;
   }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::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

◆ getKey()

SG::sgkey_t asg::AsgTool::getKey ( const void * ptr ) const

inherited

Get the (hashed) key of an object that is in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the SG::sgkey_t key for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also: asg::AsgTool::getName

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns: The hashed key of the object in the store. If not found, an invalid (zero) key.

Definition at line 119 of file AsgTool.cxx.

                                                     {
  
 #ifdef XAOD_STANDALONE
       // In case we use @c xAOD::TEvent, we have a direct function call
       // for this.
       return evtStore()->event()->getKey( ptr );
 #else
       const SG::DataProxy* proxy = evtStore()->proxy( ptr );
       return ( proxy == nullptr ? 0 : proxy->sgkey() );
 #endif // XAOD_STANDALONE
    }

◆ getName()

const std::string & asg::AsgTool::getName ( const void * ptr ) const

inherited

Get the name of an object that is / should be in the event store.

This is a bit of a special one. StoreGateSvc and xAOD::TEvent both provide ways for getting the std::string name for an object that is in the store, based on a bare pointer. But they provide different interfaces for doing so.

In order to allow tools to efficiently perform this operation, they can use this helper function.

See also: asg::AsgTool::getKey

Parameters

ptr	The bare pointer to the object that the event store should know about

Returns: The string name of the object in the store. If not found, an empty string.

Definition at line 106 of file AsgTool.cxx.

                                                             {
  
 #ifdef XAOD_STANDALONE
       // In case we use @c xAOD::TEvent, we have a direct function call
       // for this.
       return evtStore()->event()->getName( ptr );
 #else
       const SG::DataProxy* proxy = evtStore()->proxy( ptr );
       static const std::string dummy = "";
       return ( proxy == nullptr ? dummy : proxy->name() );
 #endif // XAOD_STANDALONE
    }

◆ getProperty()

template<class T >

const T* asg::AsgTool::getProperty ( const std::string & name ) const

inherited

Get one of the tool's properties.

◆ initialize()

StatusCode top::EgammaObjectCollectionMaker::initialize ( )

virtual

Dummy implementation of the initialisation function.

It's here to allow the dual-use tools to skip defining an initialisation function. Since many are doing so...

Reimplemented from asg::AsgTool.

Definition at line 43 of file EgammaObjectCollectionMaker.cxx.

                                                      {
     ATH_MSG_INFO(" top::EgammaObjectCollectionMaker initialize");
  
     top::check(m_calibrationTool.retrieve(), "Failed to retrieve egamma calibration tool");
  
     // These flags were for early R21 when we were asked not to calibrate egamma objects
     calibrateElectrons = true;
     calibrateFwdElectrons = true;
     calibratePhotons = true;
  
     if (m_config->usePhotons()) {
       for (const std::string& WP : m_config->photonIsolationWPs()) {
         m_photonIsolationTools[WP] = ToolHandle<CP::IIsolationSelectionTool>("IsolationTool_PhotonWP_" + WP);
         top::check(m_photonIsolationTools[WP].retrieve(), "Failed to retrieve photon isolation tool for WP " + WP);
       }
       top::check(m_photonFudgeTool.retrieve(), "Failed to retrieve photon shower shape fudge tool");
     }
  
     if (m_config->useElectrons()) {
       for (const std::string& WP : m_config->electronIsolationWPs()) {
         m_electronIsolationTools[WP] = ToolHandle<CP::IIsolationSelectionTool>("IsolationTool_ElectronWP_" + WP);
         top::check(m_electronIsolationTools[WP].retrieve(), "Failed to retrieve electron isolation tool for WP " + WP);
       }
     }
  
     top::check(m_isolationCorr.retrieve(), "Failed to retrieve Isolation Correction Tool");
  
     std::set<std::string> systPhoton;
     std::set<std::string> systElectron;
     std::set<std::string> systFwdElectron;
  
     const std:: string& syststr = m_config->systematics();
     std::set<std::string> syst;
  
     if (!m_config->isSystNominal(syststr) && !m_config->isSystAll(syststr)) {
       bool ok = m_config->getSystematicsList(syststr, syst);
       if (!ok) {
         ATH_MSG_ERROR(" top::EgammaObjectCollectionMaker could not determine systematic list");
         return StatusCode::FAILURE;
       }
       //here the idea is that if the user specifies AllXXX, we leave syst as an empty string, so that all recommended CP
       // systematics are then used
       if (!m_config->contains(syst, "AllElectrons")) {
         systElectron = syst;
       }
       if (!m_config->contains(syst, "AllPhotons")) {
         systPhoton = syst;
       }
       if (!m_config->contains(syst, "AllFwdElectrons")) {
         systFwdElectron = syst;
       }
     }
  
     specifiedSystematicsPhotons(systPhoton);
     specifiedSystematicsElectrons(systElectron);
     specifiedSystematicsFwdElectrons(systFwdElectron);
  
     if (m_config->usePhotons()) {
       m_config->systematicsPhotons(specifiedSystematicsPhotons());
     }
     if (m_config->useElectrons()) {
       m_config->systematicsElectrons(specifiedSystematicsElectrons());
     }
     if (m_config->useFwdElectrons()) {
       m_config->systematicsFwdElectrons(specifiedSystematicsFwdElectrons());
     }
  
     // bool to decide whether to use certain Egamma tools
     m_recomputePhotonFudge = m_config->recomputeCPvars();
  
     return StatusCode::SUCCESS;
   }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msg_level_name()

const std::string & asg::AsgTool::msg_level_name ( ) const

inherited

A deprecated function for getting the message level's name.

Instead of using this, weirdly named function, user code should get the string name of the current minimum message level (in case they really need it...), with:

MSG::name( msg().level() )

This function's name doesn't follow the ATLAS coding rules, and as such will be removed in the not too distant future.

Returns: The string name of the current minimum message level that's printed

Definition at line 101 of file AsgTool.cxx.

                                                   {
  
       return MSG::name( msg().level() );
    }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ operator=()

EgammaObjectCollectionMaker& top::EgammaObjectCollectionMaker::operator= ( const EgammaObjectCollectionMaker & rhs )

delete

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::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.

◆ print()

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

Reimplemented in JetRecTool, JetFinder, JetModifiedMassDrop, JetFromPseudojet, JetReclusterer, JetReclusteringTool, JetTruthLabelingTool, JetPileupLabelingTool, HI::HIPileupTool, top::TopObjectSelection, JetDumper, JetBottomUpSoftDrop, JetRecursiveSoftDrop, JetSoftDrop, JetConstituentsRetriever, JetSubStructureMomentToolsBase, JetSplitter, JetToolRunner, JetPruner, JetPseudojetRetriever, JetTrimmer, AsgHelloTool, and KtDeltaRTool.

Definition at line 131 of file AsgTool.cxx.

                              {
  
       ATH_MSG_INFO( "AsgTool " << name() << " @ " << this );
       return;
    }

◆ printoutElectrons()

StatusCode top::EgammaObjectCollectionMaker::printoutElectrons ( )

Definition at line 340 of file EgammaObjectCollectionMaker.cxx.

                                                             {
     // Loop over all systematics
     for (auto s : m_specifiedSystematicsElectrons) {
       const xAOD::ElectronContainer* xaod(nullptr);
       top::check(evtStore()->retrieve(xaod, m_config->sgKeyElectronsStandAlone(
                                         s.hash())), "Failed to retrieve Electrons");
  
       ATH_MSG_INFO(" Electrons with sgKey = " << m_config->sgKeyElectronsStandAlone(s.hash()));
       for (auto x : *xaod) {
         float ptcone30(0.);
         x->isolationValue(ptcone30, xAOD::Iso::ptcone30);
         ATH_MSG_INFO("   El pT , eta , ptcone30 = " << x->pt() << " , " << x->eta() << " , " << ptcone30);
       }
     }
  
     return StatusCode::SUCCESS;
   }

◆ printoutFwdElectrons()

StatusCode top::EgammaObjectCollectionMaker::printoutFwdElectrons ( )

Definition at line 358 of file EgammaObjectCollectionMaker.cxx.

                                                                {
     // Loop over all systematics
     for (auto s : m_specifiedSystematicsFwdElectrons) {
       const xAOD::ElectronContainer* xaod(nullptr);
       top::check(evtStore()->retrieve(xaod, m_config->sgKeyFwdElectronsStandAlone(
                                         s.hash())), "Failed to retrieve Fwd Electrons");
  
       ATH_MSG_INFO(" Fwd Electrons with sgKey = " << m_config->sgKeyFwdElectronsStandAlone(s.hash()));
       for (auto x : *xaod) {
         ATH_MSG_INFO("   El pT , eta = " << x->pt() << " , " << x->eta());
       }
     }
  
     return StatusCode::SUCCESS;
   }

◆ printoutPhotons()

StatusCode top::EgammaObjectCollectionMaker::printoutPhotons ( )

Definition at line 323 of file EgammaObjectCollectionMaker.cxx.

                                                           {
     // Loop over all systematics
     for (auto s : m_specifiedSystematicsPhotons) {
       const xAOD::PhotonContainer* xaod(nullptr);
       top::check(evtStore()->retrieve(xaod, m_config->sgKeyPhotons(s.hash())), "Failed to retrieve Photons");
  
       ATH_MSG_INFO(" Photons with sgKey = " << m_config->sgKeyPhotons(s.hash()));
       for (auto x : *xaod) {
         float ptcone30(0.);
         x->isolationValue(ptcone30, xAOD::Iso::ptcone30);
         ATH_MSG_INFO("   ph pT , eta , ptcone30 = " << x->pt() << " , " << x->eta() << " , " << ptcone30);
       }
     }
  
     return StatusCode::SUCCESS;
   }

◆ recommendedSystematicsElectrons()

const std::list<CP::SystematicSet>& top::EgammaObjectCollectionMaker::recommendedSystematicsElectrons ( ) const

inline

Definition at line 80 of file EgammaObjectCollectionMaker.h.

80 {return m_recommendedSystematicsElectrons;}

◆ recommendedSystematicsFwdElectrons()

const std::list<CP::SystematicSet>& top::EgammaObjectCollectionMaker::recommendedSystematicsFwdElectrons ( ) const

inline

Definition at line 81 of file EgammaObjectCollectionMaker.h.

81 {return m_recommendedSystematicsFwdElectrons;}

◆ recommendedSystematicsPhotons()

const std::list<CP::SystematicSet>& top::EgammaObjectCollectionMaker::recommendedSystematicsPhotons ( ) const

inline

Definition at line 77 of file EgammaObjectCollectionMaker.h.

                                                                                  {
                                                                                       return m_recommendedSystematicsPhotons;
                                                                                                                              }

◆ 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< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ specifiedSystematicsElectrons() [1/2]

virtual const std::list<CP::SystematicSet>& top::EgammaObjectCollectionMaker::specifiedSystematicsElectrons ( ) const

inlinevirtual

Definition at line 69 of file EgammaObjectCollectionMaker.h.

                                                                                          {
       return m_specifiedSystematicsElectrons;
     }

◆ specifiedSystematicsElectrons() [2/2]

void top::EgammaObjectCollectionMaker::specifiedSystematicsElectrons ( const std::set< std::string > & specifiedSystematics )

protectedvirtual

– Get the recommended systematics from the tool, in std::vector format –///

– MC only –///

– Are we only doing Nominal? Did the user specify specific systematics to use? –///

Definition at line 411 of file EgammaObjectCollectionMaker.cxx.

                                                                                                                {
     const std::vector<CP::SystematicSet> systList = CP::make_systematics_vector(
       m_calibrationTool->recommendedSystematics());
  
     for (auto s : systList) {
       
       if(!m_config->getTreeFilter()->filterTree(s.name())) continue; // Applying tree filter
       m_recommendedSystematicsElectrons.push_back(s);
       if (s.name() == "") {
         m_specifiedSystematicsElectrons.push_back(s);
       }
  
       if (m_config->isMC()) {
         if (!m_config->isSystNominal(m_config->systematics())) {
           if (specifiedSystematics.size() == 0) {
             m_specifiedSystematicsElectrons.push_back(s);
           }
           if (specifiedSystematics.size() > 0) {
             for (auto i : specifiedSystematics) {
               TreeFilter filter(i);
               if (!filter.filterTree(s.name())) {
                 m_specifiedSystematicsElectrons.push_back(s);
               }
             }
           }
         }
       }
     }
     m_recommendedSystematicsElectrons.sort();
     m_recommendedSystematicsElectrons.unique();
     m_specifiedSystematicsElectrons.sort();
     m_specifiedSystematicsElectrons.unique();
   }

◆ specifiedSystematicsFwdElectrons() [1/2]

virtual const std::list<CP::SystematicSet>& top::EgammaObjectCollectionMaker::specifiedSystematicsFwdElectrons ( ) const

inlinevirtual

Definition at line 72 of file EgammaObjectCollectionMaker.h.

                                                                                             {
       return m_specifiedSystematicsFwdElectrons;
     }

◆ specifiedSystematicsFwdElectrons() [2/2]

void top::EgammaObjectCollectionMaker::specifiedSystematicsFwdElectrons ( const std::set< std::string > & specifiedSystematics )

protectedvirtual

– Get the recommended systematics from the tool, in std::vector format –///

– MC only –///

– Are we only doing Nominal? Did the user specify specific systematics to use? –///

Definition at line 448 of file EgammaObjectCollectionMaker.cxx.

   {
     const std::vector<CP::SystematicSet> systList = CP::make_systematics_vector(
       m_calibrationTool->recommendedSystematics());
  
     for (auto s : systList) {
       
       if(!m_config->getTreeFilter()->filterTree(s.name())) continue; // Applying tree filter
       m_recommendedSystematicsFwdElectrons.push_back(s);
       if (s.name() == "") {
         m_specifiedSystematicsFwdElectrons.push_back(s);
       }
  
       if (m_config->isMC()) {
         if (!m_config->isSystNominal(m_config->systematics())) {
           if (specifiedSystematics.size() == 0) {
             m_specifiedSystematicsFwdElectrons.push_back(s);
           }
           if (specifiedSystematics.size() > 0) {
             for (auto i : specifiedSystematics) {
               TreeFilter filter(i);
               if (!filter.filterTree(s.name())) {
                 m_specifiedSystematicsFwdElectrons.push_back(s);
               }
             }
           }
         }
       }
     }
     m_recommendedSystematicsFwdElectrons.sort();
     m_recommendedSystematicsFwdElectrons.unique();
     m_specifiedSystematicsFwdElectrons.sort();
     m_specifiedSystematicsFwdElectrons.unique();
   }

◆ specifiedSystematicsPhotons() [1/2]

virtual const std::list<CP::SystematicSet>& top::EgammaObjectCollectionMaker::specifiedSystematicsPhotons ( ) const

inlinevirtual

Definition at line 66 of file EgammaObjectCollectionMaker.h.

                                                                                        {
       return m_specifiedSystematicsPhotons;
     }

◆ specifiedSystematicsPhotons() [2/2]

void top::EgammaObjectCollectionMaker::specifiedSystematicsPhotons ( const std::set< std::string > & specifiedSystematics )

protectedvirtual

– Get the recommended systematics from the tool, in std::vector format –///

– MC only –///

– Are we only doing Nominal? Did the user specify specific systematics to use? –///

Definition at line 374 of file EgammaObjectCollectionMaker.cxx.

                                                                                                              {
     const std::vector<CP::SystematicSet> systList = CP::make_systematics_vector(
       m_calibrationTool->recommendedSystematics());
  
     for (auto s : systList) {
       
       if(!m_config->getTreeFilter()->filterTree(s.name())) continue; // Applying tree filter
       m_recommendedSystematicsPhotons.push_back(s);
       if (s.name() == "") {
         m_specifiedSystematicsPhotons.push_back(s);
       }
  
       if (m_config->isMC()) {
         if (!m_config->isSystNominal(m_config->systematics())) {
           if (specifiedSystematics.size() == 0) {
             m_specifiedSystematicsPhotons.push_back(s);
           }
           if (specifiedSystematics.size() > 0) {
             for (auto i : specifiedSystematics) {
               TreeFilter filter(i);
               if (!filter.filterTree(s.name())) {
                 m_specifiedSystematicsPhotons.push_back(s);
               }
             }
           }
         }
       }
     }
     m_recommendedSystematicsPhotons.sort();
     m_recommendedSystematicsPhotons.unique();
     m_specifiedSystematicsPhotons.sort();
     m_specifiedSystematicsPhotons.unique();
   }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::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< AlgTool > >::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);
       }
     }
   }

Member Data Documentation

◆ calibrateElectrons

bool top::EgammaObjectCollectionMaker::calibrateElectrons

private

Definition at line 108 of file EgammaObjectCollectionMaker.h.

◆ calibrateFwdElectrons

bool top::EgammaObjectCollectionMaker::calibrateFwdElectrons

private

Definition at line 109 of file EgammaObjectCollectionMaker.h.

◆ calibratePhotons

bool top::EgammaObjectCollectionMaker::calibratePhotons

private

Definition at line 110 of file EgammaObjectCollectionMaker.h.

◆ m_calibrationTool

ToolHandle<CP::IEgammaCalibrationAndSmearingTool> top::EgammaObjectCollectionMaker::m_calibrationTool

private

Definition at line 98 of file EgammaObjectCollectionMaker.h.

◆ m_config

std::shared_ptr<top::TopConfig> top::EgammaObjectCollectionMaker::m_config

private

Definition at line 88 of file EgammaObjectCollectionMaker.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_electronIsolationTools

std::unordered_map<std::string, ToolHandle<CP::IIsolationSelectionTool> > top::EgammaObjectCollectionMaker::m_electronIsolationTools

private

– Isolation –///

Definition at line 102 of file EgammaObjectCollectionMaker.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_isolationCorr

ToolHandle<CP::IIsolationCorrectionTool> top::EgammaObjectCollectionMaker::m_isolationCorr

private

Definition at line 105 of file EgammaObjectCollectionMaker.h.

◆ m_photonFudgeTool

ToolHandle<IElectronPhotonShowerShapeFudgeTool> top::EgammaObjectCollectionMaker::m_photonFudgeTool

private

Definition at line 99 of file EgammaObjectCollectionMaker.h.

◆ m_photonIsolationTools

std::unordered_map<std::string, ToolHandle<CP::IIsolationSelectionTool> > top::EgammaObjectCollectionMaker::m_photonIsolationTools

private

Definition at line 103 of file EgammaObjectCollectionMaker.h.

◆ m_recommendedSystematicsElectrons

std::list<CP::SystematicSet> top::EgammaObjectCollectionMaker::m_recommendedSystematicsElectrons

private

Definition at line 95 of file EgammaObjectCollectionMaker.h.

◆ m_recommendedSystematicsFwdElectrons

std::list<CP::SystematicSet> top::EgammaObjectCollectionMaker::m_recommendedSystematicsFwdElectrons

private

Definition at line 96 of file EgammaObjectCollectionMaker.h.

◆ m_recommendedSystematicsPhotons

std::list<CP::SystematicSet> top::EgammaObjectCollectionMaker::m_recommendedSystematicsPhotons

private

Definition at line 94 of file EgammaObjectCollectionMaker.h.

◆ m_recomputePhotonFudge

bool top::EgammaObjectCollectionMaker::m_recomputePhotonFudge

private

Definition at line 113 of file EgammaObjectCollectionMaker.h.

◆ m_specifiedSystematicsElectrons

std::list<CP::SystematicSet> top::EgammaObjectCollectionMaker::m_specifiedSystematicsElectrons

private

Definition at line 91 of file EgammaObjectCollectionMaker.h.

◆ m_specifiedSystematicsFwdElectrons

std::list<CP::SystematicSet> top::EgammaObjectCollectionMaker::m_specifiedSystematicsFwdElectrons

private

Definition at line 92 of file EgammaObjectCollectionMaker.h.

◆ m_specifiedSystematicsPhotons

std::list<CP::SystematicSet> top::EgammaObjectCollectionMaker::m_specifiedSystematicsPhotons

private

Definition at line 90 of file EgammaObjectCollectionMaker.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ EgammaObjectCollectionMaker() [1/3]

◆ ~EgammaObjectCollectionMaker()

◆ EgammaObjectCollectionMaker() [2/3]

◆ EgammaObjectCollectionMaker() [3/3]

Member Function Documentation

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ executeElectrons()

◆ executeFwdElectrons()

◆ executePhotons()

◆ extraDeps_update_handler()

◆ getKey()

◆ getName()

◆ getProperty()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msg_level_name()

◆ msgLvl()

◆ operator=()

◆ outputHandles()

◆ print()

◆ printoutElectrons()

◆ printoutFwdElectrons()

◆ printoutPhotons()

◆ recommendedSystematicsElectrons()

◆ recommendedSystematicsFwdElectrons()

◆ recommendedSystematicsPhotons()

◆ renounce()

◆ renounceArray()

◆ specifiedSystematicsElectrons() [1/2]

◆ specifiedSystematicsElectrons() [2/2]

◆ specifiedSystematicsFwdElectrons() [1/2]

◆ specifiedSystematicsFwdElectrons() [2/2]

◆ specifiedSystematicsPhotons() [1/2]

◆ specifiedSystematicsPhotons() [2/2]

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ calibrateElectrons

◆ calibrateFwdElectrons

◆ calibratePhotons

◆ m_calibrationTool

◆ m_config

◆ m_detStore

◆ m_electronIsolationTools

◆ m_evtStore

◆ m_isolationCorr

◆ m_photonFudgeTool

◆ m_photonIsolationTools

◆ m_recommendedSystematicsElectrons

◆ m_recommendedSystematicsFwdElectrons

◆ m_recommendedSystematicsPhotons

◆ m_recomputePhotonFudge

◆ m_specifiedSystematicsElectrons

◆ m_specifiedSystematicsFwdElectrons

◆ m_specifiedSystematicsPhotons

◆ m_varHandleArraysDeclared