#include <IsolationBuilder.h>

Inheritance diagram for IsolationBuilder:

Collaboration diagram for IsolationBuilder:

Classes
struct	CaloIsoHelpHandles

struct	CaloIsoHelpKey

struct	TrackIsoHelpHandles

struct	TrackIsoHelpKey

Public Member Functions
	IsolationBuilder (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters: More...

virtual	~IsolationBuilder ()
	Destructor: More...

virtual StatusCode	initialize () override final

virtual StatusCode	execute (const EventContext &ctx) const override final

virtual StatusCode	finalize () override final

virtual StatusCode	sysInitialize () override
	Override sysInitialize. More...

virtual bool	isClonable () const override
	Specify if the algorithm is clonable. More...

virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant. More...

virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm. More...

virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies. More...

virtual bool	filterPassed (const EventContext &ctx) const

virtual void	setFilterPassed (bool state, const EventContext &ctx) const

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

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
	IsolationBuilder ()
	Default constructor: More...

StatusCode	initializeIso (std::set< xAOD::Iso::IsolationFlavour > &runIsoType, std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey >> caloIsoMap, std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey >> trackIsoMap, const std::string &containerName, const std::vector< std::vector< int >> &isoInts, const std::vector< std::vector< int >> &corInts, const std::vector< std::vector< int >> &corIntsExtra, const std::string &customConfig)
	called by algorithm initialize per object (electron, photon, forward electron, muon) More...

StatusCode	addCaloIsoCorrections (size_t flavor, xAOD::Iso::IsolationFlavour isoFlav, CaloIsoHelpKey &cisoH, const std::vector< std::vector< int >> &corInts, bool corrsAreExtra, const std::string &prefix, const std::string &customConfig)
	called by initializeIso More...

StatusCode	addTrackIsoCorrections (size_t flavor, xAOD::Iso::IsolationFlavour isoFlav, TrackIsoHelpKey &tisoH, const std::vector< std::vector< int >> &corInts, bool corrsAreExtra, const std::string &prefix, const std::string &customConfig)
	called by initializeIso More...

StatusCode	executeCaloIso (const std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey >> &caloIsoMap, const CaloCellContainer *cellColl) const

StatusCode	executeTrackIso (const std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey >> &trackIsoMap) const

void	declareIso (std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey >> &caloIso)

void	declareIso (std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey >> &trackIso)

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	isCoreCor (xAOD::Iso::IsolationCaloCorrection corr)

Private Attributes
Gaudi::Property< std::string >	m_ElectronContainerName
	Containers (Is it best to make them as strings? Used by multiple handles) More...

Gaudi::Property< std::string >	m_FwdElectronContainerName

Gaudi::Property< std::string >	m_PhotonContainerName

Gaudi::Property< std::string >	m_MuonContainerName

ToolHandle< xAOD::ICaloCellIsolationTool >	m_cellIsolationTool
	Tool for cell isolation calculation. More...

SG::ReadHandleKey< CaloCellContainer >	m_cellsKey
	Cell container. More...

ToolHandle< xAOD::ICaloTopoClusterIsolationTool >	m_topoIsolationTool
	Tool for topo isolation calculation. More...

ToolHandle< xAOD::INeutralEFlowIsolationTool >	m_pflowIsolationTool
	Tool for neutral pflow isolation calculation. More...

ToolHandle< xAOD::ITrackIsolationTool >	m_trackIsolationTool
	Tool for neutral pflow isolation calculation. More...

Gaudi::Property< bool >	m_isTrigger { this, "IsTrigger", false }
	is the alg run at trigger level More...

Gaudi::Property< bool >	m_useBremAssoc

Gaudi::Property< bool >	m_allTrackRemoval { this, "AllTrackRemoval", true }

Gaudi::Property< bool >	m_storepileupCorrection { this, "storepileupCorrection", false }

Gaudi::Property< std::vector< std::vector< int > > >	m_elisoInts
	Isolation types. More...

Gaudi::Property< std::vector< std::vector< int > > >	m_elcorInts

Gaudi::Property< std::vector< std::vector< int > > >	m_elcorIntsExtra

Gaudi::Property< std::vector< std::vector< int > > >	m_phisoInts
	Isolation types (for the alg. More...

Gaudi::Property< std::vector< std::vector< int > > >	m_phcorInts

Gaudi::Property< std::vector< std::vector< int > > >	m_phcorIntsExtra

Gaudi::Property< std::vector< std::vector< int > > >	m_muisoInts

Gaudi::Property< std::vector< std::vector< int > > >	m_mucorInts

Gaudi::Property< std::vector< std::vector< int > > >	m_mucorIntsExtra

Gaudi::Property< std::vector< std::vector< int > > >	m_feisoInts

Gaudi::Property< std::vector< std::vector< int > > >	m_fecorInts

Gaudi::Property< std::vector< std::vector< int > > >	m_fecorIntsExtra

std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > >	m_elCaloIso

std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > >	m_phCaloIso

std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > >	m_feCaloIso

std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey > >	m_muCaloIso

std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > >	m_elTrackIso

std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > >	m_phTrackIso

std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey > >	m_muTrackIso

Gaudi::Property< std::string >	m_customConfigEl

Gaudi::Property< std::string >	m_customConfigPh

Gaudi::Property< std::string >	m_customConfigFwd

Gaudi::Property< std::string >	m_customConfigMu

DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks. More...

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 44 of file IsolationBuilder.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ IsolationBuilder() [1/2]

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

Constructor with parameters:

Definition at line 18 of file IsolationBuilder.cxx.

20 : ::AthReentrantAlgorithm(name, pSvcLocator)

21 {}

◆ ~IsolationBuilder()

IsolationBuilder::~IsolationBuilder ( )

virtualdefault

Destructor:

◆ IsolationBuilder() [2/2]

IsolationBuilder::IsolationBuilder ( )

private

Default constructor:

Member Function Documentation

◆ addCaloIsoCorrections()

StatusCode IsolationBuilder::addCaloIsoCorrections	(	size_t	flavor,
		xAOD::Iso::IsolationFlavour	isoFlav,
		CaloIsoHelpKey &	cisoH,
		const std::vector< std::vector< int >> &	corInts,
		bool	corrsAreExtra,
		const std::string &	prefix,
		const std::string &	customConfig
	)

private

called by initializeIso

Definition at line 401 of file IsolationBuilder.cxx.

 {
  
   if (!corrsAreExtra) {
     std::string bitsetName =
       prefix + xAOD::Iso::toString(isoFlav) + "CorrBitset";
     if (!customConfig.empty()) {
       bitsetName += "_" + customConfig;
     }
  
     cisoH.corrBitsetDeco = bitsetName;
     ATH_MSG_DEBUG("Initializing non extra corr : " << cisoH.corrBitsetDeco.key());
     ATH_CHECK(cisoH.corrBitsetDeco.initialize());
   }
  
   for (size_t corrType = 0; corrType < corInts[flavor].size(); corrType++) {
     // iterate over the calo isolation corrections
     const auto cor = static_cast<unsigned int>(corInts[flavor][corrType]);
     if (!corrsAreExtra)
       cisoH.CorrList.calobitset.set(cor);
     const xAOD::Iso::IsolationCaloCorrection isoCor =
       static_cast<xAOD::Iso::IsolationCaloCorrection>(cor);
  
     if (isCoreCor(isoCor)) {
       std::string isoCorName = prefix;
       if (isoCor != xAOD::Iso::core57cells) {
         isoCorName += xAOD::Iso::toString(isoFlav); // since this doesn't depend on the flavor, just have one
       }
  
       // a core correction; only store core energy, not the core area
       isoCorName += xAOD::Iso::toString(isoCor) +
                     xAOD::Iso::toString(xAOD::Iso::coreEnergy) + "Correction";
       if (!customConfig.empty()) {
         isoCorName += "_" + customConfig;
       }
       cisoH.coreCorDeco.emplace(isoCor, isoCorName);
       cisoH.coreCorDeco[isoCor].setOwner(this);
       ATH_MSG_DEBUG("initializing " << cisoH.coreCorDeco[isoCor].key());
       ATH_CHECK(cisoH.coreCorDeco[isoCor].initialize());
     } else {
       // noncore correction
       if (isoCor == xAOD::Iso::pileupCorrection && !m_storepileupCorrection)
     continue;
       cisoH.noncoreCorDeco.emplace(
         isoCor, SG::WriteDecorHandleKeyArray<xAOD::IParticleContainer>());
       auto& vec = cisoH.noncoreCorDeco[isoCor];
       vec.setOwner(this);
       for (auto type : cisoH.isoTypes) {
         std::string corName = prefix + xAOD::Iso::toString(type) +
                               xAOD::Iso::toString(isoCor) + "Correction";
         if (!customConfig.empty()) {
           corName += "_" + customConfig;
         }
         vec.emplace_back(corName);
       }
       ATH_MSG_DEBUG("Initializing " << xAOD::Iso::toString(isoCor)
                                     << " Corrections");
       ATH_CHECK(vec.initialize());
     }
   }
   return StatusCode::SUCCESS;
 }

◆ addTrackIsoCorrections()

StatusCode IsolationBuilder::addTrackIsoCorrections	(	size_t	flavor,
		xAOD::Iso::IsolationFlavour	isoFlav,
		TrackIsoHelpKey &	tisoH,
		const std::vector< std::vector< int >> &	corInts,
		bool	corrsAreExtra,
		const std::string &	prefix,
		const std::string &	customConfig
	)

private

called by initializeIso

Definition at line 472 of file IsolationBuilder.cxx.

 {
  
   if (!corrsAreExtra) {
     std::string bitsetName =
       prefix + xAOD::Iso::toString(isoFlav) + "CorrBitset";
     if (!customConfig.empty()) {
       bitsetName += "_" + customConfig;
     }
  
     tisoH.corrBitsetDeco = bitsetName;
     ATH_MSG_DEBUG("Initializing " << tisoH.corrBitsetDeco.key());
     ATH_CHECK(tisoH.corrBitsetDeco.initialize());
   }
  
   for (size_t corrType = 0; corrType < corInts[flavor].size(); corrType++) {
     const auto cor = static_cast<unsigned int>(corInts[flavor][corrType]);
     if (!corrsAreExtra)
       tisoH.CorrList.trackbitset.set(cor);
     const xAOD::Iso::IsolationTrackCorrection isoCor =
       static_cast<xAOD::Iso::IsolationTrackCorrection>(cor);
  
     // all pt corrections are core type
     std::string isoCorName = prefix + xAOD::Iso::toString(isoFlav) +
                              xAOD::Iso::toString(isoCor) + "Correction";
  
     if (!customConfig.empty()) {
       isoCorName += "_" + customConfig;
     }
     tisoH.coreCorDeco.emplace(isoCor, isoCorName);
     tisoH.coreCorDeco[isoCor].setOwner(this);
     ATH_MSG_DEBUG("initializing " << tisoH.coreCorDeco[isoCor].key());
     ATH_CHECK(tisoH.coreCorDeco[isoCor].initialize());
   }
   return StatusCode::SUCCESS;
 }

◆ cardinality()

unsigned int AthReentrantAlgorithm::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 55 of file AthReentrantAlgorithm.cxx.

 {
   return 0;
 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::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< Gaudi::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< Gaudi::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);
   }

◆ declareIso() [1/2]

void IsolationBuilder::declareIso ( std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey >> & caloIso )

private

Definition at line 756 of file IsolationBuilder.cxx.

 {
   for (auto& iso : caloIso) {
     iso.second.declare(this);
   }
 }

◆ declareIso() [2/2]

void IsolationBuilder::declareIso ( std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey >> & trackIso )

private

Definition at line 765 of file IsolationBuilder.cxx.

 {
   for (auto& iso : trackIso) {
     iso.second.declare(this);
   }
 }

◆ declareProperty() [1/6]

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode IsolationBuilder::execute ( const EventContext & ctx ) const

finaloverridevirtual

Definition at line 132 of file IsolationBuilder.cxx.

 {
   ATH_MSG_DEBUG("Executing " << name() << "...");
  
   // For etcone, needs the cells
  
   const CaloCellContainer* cellColl = nullptr;
   if (!m_cellIsolationTool.empty()) {
     SG::ReadHandle<CaloCellContainer> cellcoll(m_cellsKey, ctx);
     // check is only used for serial running; remove when MT scheduler used
     if (!cellcoll.isValid()) {
       ATH_MSG_FATAL("Failed to retrieve cell container: " << m_cellsKey.key());
       return StatusCode::FAILURE;
     }
     cellColl = cellcoll.cptr();
   }
   // Compute isolations
  
   if (m_elCaloIso.size()) {
     ATH_MSG_DEBUG("About to execute Electron calo iso");
     ATH_CHECK(executeCaloIso(m_elCaloIso, cellColl));
   }
   if (m_phCaloIso.size()) {
     ATH_MSG_DEBUG("About to execute Photon calo iso");
     ATH_CHECK(executeCaloIso(m_phCaloIso, cellColl));
   }
   if (m_feCaloIso.size()) {
     ATH_MSG_DEBUG("About to execute Forward Electron calo iso");
     ATH_CHECK(executeCaloIso(m_feCaloIso, cellColl));
   }
   if (m_muCaloIso.size()) {
     ATH_MSG_DEBUG("About to execute muon calo iso");
     ATH_CHECK(executeCaloIso(m_muCaloIso, cellColl));
   }
  
   if (m_elTrackIso.size()) {
     ATH_MSG_DEBUG("About to execute Electron track iso");
     ATH_CHECK(executeTrackIso(m_elTrackIso));
   }
   if (m_phTrackIso.size()) {
     ATH_MSG_DEBUG("About to execute Photon track iso");
     ATH_CHECK(executeTrackIso(m_phTrackIso));
   }
   if (m_muTrackIso.size()) {
     ATH_MSG_DEBUG("About to execute Muon track iso");
     ATH_CHECK(executeTrackIso(m_muTrackIso));
   }
  
   return StatusCode::SUCCESS;
 }

◆ executeCaloIso()

StatusCode IsolationBuilder::executeCaloIso	(	const std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey >> &	caloIsoMap,
		const CaloCellContainer *	cellColl
	)		const

private

Definition at line 517 of file IsolationBuilder.cxx.

 {
   for (const auto& pr : caloIsoMap) {
  
     const xAOD::Iso::IsolationFlavour flav = pr.first;
     const auto& keys = pr.second;
     CaloIsoHelpHandles handles(keys);
  
     ATH_MSG_DEBUG("Executing calo iso flavor: " << xAOD::Iso::toString(flav));
  
     if (handles.isoDeco.empty()) {
       ATH_MSG_FATAL("Have a CaloIsoHelpHandles with no actual isolations; "
                     "something wrong happened");
       return StatusCode::FAILURE;
     }
     auto& readHandle =
       handles.isoDeco[0]; // can treat the writeDecorHandle as a read handle;
     
     if (readHandle.isAvailable()){ // This must be before readHandle.isValid() or else the isValid call
                                    // will crash if the deocration already exists
       ATH_MSG_DEBUG("read (actually a write) handle for " << keys.isoDeco[0].key() << " already exists.  "
                     << "Will not recompute." );
       return StatusCode::SUCCESS;
     }
  
     if (!readHandle.isValid()) {
       ATH_MSG_FATAL("Could not retrieve read handle for "
                     << keys.isoDeco[0].key());
       return StatusCode::FAILURE;
     }
  
     for (const auto *part : *readHandle) {
       xAOD::CaloIsolation CaloIsoResult;
       bool successfulCalc = false;
       if (flav == xAOD::Iso::IsolationFlavour::etcone && cellColl) {
         successfulCalc = m_cellIsolationTool->caloCellIsolation(
           CaloIsoResult, *part, keys.isoTypes, keys.CorrList, cellColl);
       } else if (flav == xAOD::Iso::IsolationFlavour::topoetcone) {
         successfulCalc = m_topoIsolationTool->caloTopoClusterIsolation(
           CaloIsoResult, *part, keys.isoTypes, keys.CorrList);
       } else if (flav == xAOD::Iso::IsolationFlavour::neflowisol) {
         successfulCalc = m_pflowIsolationTool->neutralEflowIsolation(
           CaloIsoResult, *part, keys.isoTypes, keys.CorrList);
       }
  
       if (successfulCalc) {
         for (unsigned int i = 0; i < keys.isoTypes.size(); i++) {
           float iso = CaloIsoResult.etcones[i];
           ATH_MSG_DEBUG("custom Iso " << xAOD::Iso::toCString(keys.isoTypes[i])
                                       << " = " << iso / 1e3);
           (handles.isoDeco[i])(*part) = iso;
         }
         // corrections
         (handles.corrBitsetDeco)(*part) = keys.CorrList.calobitset.to_ulong();
  
         // let's do the core corrections
  
         // iterate over the values we want to store
         for (auto& coreCorDecoPr : handles.coreCorDeco) {
           // find the matching result
           auto corIter =
             CaloIsoResult.coreCorrections.find(coreCorDecoPr.first);
           if (corIter == CaloIsoResult.coreCorrections.end()) {
             ATH_MSG_FATAL("Could not find core correction of required type: "
                           << xAOD::Iso::toCString(coreCorDecoPr.first));
             ATH_MSG_FATAL("Check configuration");
             return StatusCode::FAILURE;
           }
           // now that we have the match, let's find the energy
           std::map<xAOD::Iso::IsolationCorrectionParameter,
                    float>::const_iterator it =
             corIter->second.find(xAOD::Iso::coreEnergy);
           if (it == corIter->second.end()) {
             ATH_MSG_FATAL("Could not find coreEnergy correction for: "
                           << xAOD::Iso::toCString(coreCorDecoPr.first));
             ATH_MSG_FATAL("Check configuration");
             return StatusCode::FAILURE;
           }
           ATH_MSG_DEBUG("About to write core correction: "
                         << xAOD::Iso::toCString(coreCorDecoPr.first));
           (coreCorDecoPr.second)(*part) = it->second;
         }
  
         // let's do the noncore corrections
         for (auto& noncoreCorDecoPr : handles.noncoreCorDeco) {
           // find the matching result
           auto corIter =
             CaloIsoResult.noncoreCorrections.find(noncoreCorDecoPr.first);
           if (corIter == CaloIsoResult.noncoreCorrections.end()) {
             ATH_MSG_FATAL("Could not find noncore correction of required type: "
                           << xAOD::Iso::toCString(noncoreCorDecoPr.first));
             ATH_MSG_FATAL("Check configuration");
             return StatusCode::FAILURE;
           }
  
           ATH_MSG_DEBUG("About to write noncore correction: "
                         << xAOD::Iso::toCString(noncoreCorDecoPr.first));
           auto& vecHandles = noncoreCorDecoPr.second;
           for (size_t i = 0; i < vecHandles.size(); i++) {
             (vecHandles[i])(*part) = corIter->second[i];
           }
         }
       } else {
         ATH_MSG_FATAL("Call to CaloIsolationTool failed for flavor "
                       << xAOD::Iso::toCString(flav));
         return StatusCode::FAILURE;
       }
     }
   }
   return StatusCode::SUCCESS;
 }

◆ executeTrackIso()

StatusCode IsolationBuilder::executeTrackIso ( const std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey >> & trackIsoMap ) const

private

Definition at line 633 of file IsolationBuilder.cxx.

 {
   for (const auto& pr : trackIsoMap) {
     const xAOD::Iso::IsolationFlavour flav = pr.first;
     const auto& keys = pr.second;
     TrackIsoHelpHandles handles(keys);
  
     ATH_MSG_DEBUG("Executing track iso flavor: " << xAOD::Iso::toString(flav));
  
     if (handles.isoDeco.empty()) {
       ATH_MSG_FATAL("Have a TrackIsoHelpHandles with no actual isolations; "
                     "something wrong happened");
       return StatusCode::FAILURE;
     }
     auto& readHandle =
       handles.isoDeco[0]; // can treat the writeDecorHandle as a read handle;
  
     if (readHandle.isAvailable()){ // This must be before readHandle.isValid() or else the isValid call
                                    // will crash if the deocration already exists
       ATH_MSG_DEBUG("Decoration for for " << keys.isoDeco[0].key() << " already exists.  "
                     << "Will not recompute." );
       return StatusCode::SUCCESS;
     }
  
     if (!readHandle.isValid()) {
       ATH_MSG_FATAL("Could not retrieve read handle for "
                     << keys.isoDeco[0].key());
       return StatusCode::FAILURE;
     }
  
     for (const auto *part : *readHandle) {
       xAOD::TrackIsolation TrackIsoResult;
       bool successfulCalc = false;
       // check to see if we are dealing with an electron
       const auto * eg = dynamic_cast<const xAOD::Egamma*>(part);
       if (eg) {
         ATH_MSG_DEBUG("Doing track isolation on an egamma particle");
     std::unique_ptr<xAOD::Vertex> trigVtx = nullptr;
         std::set<const xAOD::TrackParticle*> tracksToExclude;
         if (xAOD::EgammaHelpers::isElectron(eg)) {
           tracksToExclude =
             xAOD::EgammaHelpers::getTrackParticles(eg, m_useBremAssoc);
       if (m_isTrigger) {
         const xAOD::Electron* el = static_cast<const xAOD::Electron*>(part);
         trigVtx = std::make_unique<xAOD::Vertex>();
         trigVtx->makePrivateStore();
         trigVtx->setZ(el->trackParticle()->z0() + el->trackParticle()->vz());
         ATH_MSG_DEBUG("will use a vertex at z = " << trigVtx->z() << " to compute electron track isolation");
       }
         } else {
           if (m_allTrackRemoval) { // New (from ??/??/16) : now this gives all
                                    // tracks
             tracksToExclude =
               xAOD::EgammaHelpers::getTrackParticles(eg, m_useBremAssoc);
           } else { // this is just to be able to have the 2015+2016 default case
                    // (only tracks from first vertex)
             const auto * gam = dynamic_cast<const xAOD::Photon*>(eg);
             if (gam && gam->nVertices() > 0) {
               const xAOD::Vertex* phvtx = gam->vertex(0);
               for (unsigned int itk = 0; itk < phvtx->nTrackParticles(); itk++)
                 tracksToExclude.insert(
                   m_useBremAssoc
                     ? xAOD::EgammaHelpers::getOriginalTrackParticleFromGSF(
                         phvtx->trackParticle(itk))
                     : phvtx->trackParticle(itk));
             }
           }
         }
         successfulCalc = m_trackIsolationTool->trackIsolation(TrackIsoResult,
                                                               *part,
                                                               keys.isoTypes,
                                                               keys.CorrList,
                                                               trigVtx.get(),
                                                               &tracksToExclude);
       } else {
         ATH_MSG_DEBUG("Not doing track isolation on an egamma particle");
         successfulCalc = m_trackIsolationTool->trackIsolation(
           TrackIsoResult, *part, keys.isoTypes, keys.CorrList);
       }
  
       if (successfulCalc) {
         for (unsigned int i = 0; i < keys.isoTypes.size(); i++) {
           float iso = TrackIsoResult.ptcones[i];
           float isoV = TrackIsoResult.ptvarcones_10GeVDivPt[i];
           ATH_MSG_DEBUG("custom Iso " << xAOD::Iso::toCString(keys.isoTypes[i])
                                       << " = " << iso / 1e3
                                       << ", var cone = " << isoV / 1e3);
           (handles.isoDeco[i])(*part) = iso;
           (handles.isoDecoV[i])(*part) = isoV;
         }
  
         // corrections
         (handles.corrBitsetDeco)(*part) = keys.CorrList.trackbitset.to_ulong();
         // let's do the core corrections
         // iterate over the values we want to store
         for (auto& coreCorDecoPr : handles.coreCorDeco) {
           // find the matching result
           auto corIter =
             TrackIsoResult.coreCorrections.find(coreCorDecoPr.first);
           if (corIter == TrackIsoResult.coreCorrections.end()) {
             ATH_MSG_FATAL("Could not find core correction of required type: "
                           << xAOD::Iso::toCString(coreCorDecoPr.first));
             ATH_MSG_FATAL("Check configuration");
             return StatusCode::FAILURE;
           }
           ATH_MSG_DEBUG("About to write tracking core correction: "
                         << xAOD::Iso::toCString(coreCorDecoPr.first));
           (coreCorDecoPr.second)(*part) = corIter->second;
         }
  
       } else {
         ATH_MSG_FATAL("Call to TrackIsolationTool failed for flavor "
                       << xAOD::Iso::toCString(flav));
         return StatusCode::FAILURE;
       }
     }
   }
   return StatusCode::SUCCESS;
 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthReentrantAlgorithm::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 79 of file AthReentrantAlgorithm.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();
 }

◆ filterPassed()

virtual bool AthReentrantAlgorithm::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 135 of file AthReentrantAlgorithm.h.

                                                            {
     return execState( ctx ).filterPassed();
   }

◆ finalize()

StatusCode IsolationBuilder::finalize ( )

finaloverridevirtual

Definition at line 124 of file IsolationBuilder.cxx.

 {
   ATH_MSG_INFO("Finalizing " << name() << "...");
  
   return StatusCode::SUCCESS;
 }

◆ initialize()

StatusCode IsolationBuilder::initialize ( )

finaloverridevirtual

Definition at line 26 of file IsolationBuilder.cxx.

 {
   ATH_MSG_INFO("Initializing " << name() << "...");
  
   std::set<xAOD::Iso::IsolationFlavour> runIsoType;
  
   if (m_elisoInts.size()) {
     ATH_MSG_DEBUG("Initializing central electrons");
     ATH_CHECK(initializeIso(runIsoType,
                 &m_elCaloIso,
                 &m_elTrackIso,
                 m_ElectronContainerName,
                 m_elisoInts,
                 m_elcorInts,
                 m_elcorIntsExtra,
                 m_customConfigEl));
     declareIso(m_elCaloIso);
     declareIso(m_elTrackIso);
   }
  
   if (m_phisoInts.size()) {
     ATH_MSG_DEBUG("Initializing central photons");
     ATH_CHECK(initializeIso(runIsoType,
                 &m_phCaloIso,
                 &m_phTrackIso,
                 m_PhotonContainerName,
                 m_phisoInts,
                 m_phcorInts,
                 m_phcorIntsExtra,
                 m_customConfigPh));
     declareIso(m_phCaloIso);
     declareIso(m_phTrackIso);
   }
  
   if (m_feisoInts.size()) {
     ATH_MSG_DEBUG("Initializing forward electrons");
     ATH_CHECK(initializeIso(runIsoType,
                 &m_feCaloIso,
                 nullptr,
                 m_FwdElectronContainerName,
                 m_feisoInts,
                 m_fecorInts,
                 m_fecorIntsExtra,
                 m_customConfigFwd));
     declareIso(m_feCaloIso);
   }
  
   if (m_muisoInts.size()) {
     ATH_MSG_DEBUG("Initializing muons");
     ATH_CHECK(initializeIso(runIsoType,
                 &m_muCaloIso,
                 &m_muTrackIso,
                 m_MuonContainerName,
                 m_muisoInts,
                 m_mucorInts,
                 m_mucorIntsExtra,
                 m_customConfigMu));
     declareIso(m_muCaloIso);
     declareIso(m_muTrackIso);
   }
  
   // Retrieve the tools (there three Calo ones are the same in fact)
   if (!m_cellIsolationTool.empty() &&
       runIsoType.find(xAOD::Iso::etcone) != runIsoType.end()) {
     ATH_CHECK(m_cellIsolationTool.retrieve());
   } else {
     m_cellIsolationTool.disable();
   }
  
   if (!m_topoIsolationTool.empty() &&
       runIsoType.find(xAOD::Iso::topoetcone) != runIsoType.end()) {
     ATH_CHECK(m_topoIsolationTool.retrieve());
   } else {
     m_topoIsolationTool.disable();
   }
  
   if (!m_pflowIsolationTool.empty() &&
       runIsoType.find(xAOD::Iso::neflowisol) != runIsoType.end()) {
     ATH_CHECK(m_pflowIsolationTool.retrieve());
   } else {
     m_pflowIsolationTool.disable();
   }
  
   if (!m_trackIsolationTool.empty() &&
       runIsoType.find(xAOD::Iso::IsolationFlavour::ptcone) !=
         runIsoType.end()) {
     ATH_CHECK(m_trackIsolationTool.retrieve());
   } else {
     m_trackIsolationTool.disable();
   }
  
   // initialise data handles
   ATH_CHECK(m_cellsKey.initialize(!m_cellIsolationTool.empty()));
  
   return StatusCode::SUCCESS;
 }

◆ initializeIso()

StatusCode IsolationBuilder::initializeIso	(	std::set< xAOD::Iso::IsolationFlavour > &	runIsoType,
		std::vector< std::pair< xAOD::Iso::IsolationFlavour, CaloIsoHelpKey >> *	caloIsoMap,
		std::vector< std::pair< xAOD::Iso::IsolationFlavour, TrackIsoHelpKey >> *	trackIsoMap,
		const std::string &	containerName,
		const std::vector< std::vector< int >> &	isoInts,
		const std::vector< std::vector< int >> &	corInts,
		const std::vector< std::vector< int >> &	corIntsExtra,
		const std::string &	customConfig
	)

private

called by algorithm initialize per object (electron, photon, forward electron, muon)

Definition at line 269 of file IsolationBuilder.cxx.

 {
  
   std::string prefix = containerName + ".";
  
   for (size_t flavor = 0; flavor < isoInts.size(); flavor++) {
     // iterate over the flavor (cell, topo, eflow, track
     //   Note: it is a configuration error if different types
     //         are included in one inner vector
  
     CaloIsoHelpKey cisoH(this);
     TrackIsoHelpKey tisoH(this);
  
     // std::vector<SG::AuxElement::Decorator<float>*> Deco;
     xAOD::Iso::IsolationFlavour isoFlav = xAOD::Iso::numIsolationFlavours;
     xAOD::Iso::IsolationFlavour oldIsoFlav = xAOD::Iso::numIsolationFlavours;
  
     for (size_t type = 0; type < isoInts[flavor].size(); type++) {
       // iterate over the cone sizes for a given flavor.
       // (also check that the cone sizes really are of the same flavor;
       // otherwise an error)
  
       xAOD::Iso::IsolationType isoType =
         static_cast<xAOD::Iso::IsolationType>(isoInts[flavor][type]);
       isoFlav = xAOD::Iso::isolationFlavour(isoType);
       ATH_MSG_DEBUG("Saw isoType " << xAOD::Iso::toString(isoType) << " and isoFlav " << xAOD::Iso::toString(isoFlav));
       if (oldIsoFlav != xAOD::Iso::numIsolationFlavours &&
           oldIsoFlav != isoFlav) {
         ATH_MSG_FATAL("Configuration error:  can only have one type of "
                       "isolation in inner vector");
         return StatusCode::FAILURE;
       }
       oldIsoFlav = isoFlav;
       std::string isoName = prefix + xAOD::Iso::toString(isoType);
       if (!customConfig.empty()) {
         isoName += "_" + customConfig;
       }
       if (isoFlav == xAOD::Iso::etcone || isoFlav == xAOD::Iso::topoetcone ||
           isoFlav == xAOD::Iso::neflowisol) {
         cisoH.isoTypes.push_back(isoType);
         cisoH.isoDeco.emplace_back(isoName);
       } else if (isoFlav == xAOD::Iso::ptcone) {
         tisoH.isoTypes.push_back(isoType);
         tisoH.isoDeco.emplace_back(isoName);
         auto coneSize =
           static_cast<int>(round(100 * xAOD::Iso::coneSize(isoType)));
         std::string isoNameV = prefix + "ptvarcone" + std::to_string(coneSize);
         if (!customConfig.empty()) {
           isoNameV += "_" + customConfig;
         }
         tisoH.isoDecoV.emplace_back(isoNameV);
       } else {
         ATH_MSG_FATAL("Configuration error: Isolation flavor "
                       << isoFlav << " not supported.");
         return StatusCode::FAILURE;
       }
     }
  
     // check that there were isolations configured
     if (isoFlav == xAOD::Iso::numIsolationFlavours) {
       ATH_MSG_WARNING("The configuration was malformed: an empty inner vector "
                       "was added; ignoring");
       continue;
     }
  
     // Now that the isolations to calculate are determined,
     // initialize the isolation decorations
     // and then determine the corrections to apply,
     // and finally add it to the IsoMap.
  
     if (isoFlav == xAOD::Iso::etcone || isoFlav == xAOD::Iso::topoetcone ||
         isoFlav == xAOD::Iso::neflowisol) {
  
       // let's initialize the decos
       ATH_MSG_DEBUG("Initializing cisoH.isoDeco");
       ATH_CHECK(cisoH.isoDeco.initialize());
  
       ATH_CHECK(addCaloIsoCorrections(
         flavor, isoFlav, cisoH, corInts, false, prefix, customConfig));
       ATH_CHECK(addCaloIsoCorrections(
         flavor, isoFlav, cisoH, corIntsExtra, true, prefix, customConfig));
  
       if (caloIsoMap) {
         caloIsoMap->push_back(std::make_pair(isoFlav, cisoH));
       } else {
         ATH_MSG_FATAL(
           "caloIsoMap was nullptr but the configuration attempted to use it");
         return StatusCode::FAILURE;
       }
     } else if (isoFlav == xAOD::Iso::ptcone) {
  
       // let's initialize the decos
       ATH_MSG_DEBUG("Initializing tisoH.isoDeco");
       ATH_CHECK(tisoH.isoDeco.initialize());
       ATH_MSG_DEBUG("Initializing tisoH.isoDecoV");
       ATH_CHECK(tisoH.isoDecoV.initialize());
  
       ATH_CHECK(addTrackIsoCorrections(
         flavor, isoFlav, tisoH, corInts, false, prefix, customConfig));
       ATH_CHECK(addTrackIsoCorrections(
         flavor, isoFlav, tisoH, corIntsExtra, true, prefix, customConfig));
  
       if (trackIsoMap) {
         trackIsoMap->push_back(std::make_pair(isoFlav, tisoH));
       } else {
         ATH_MSG_FATAL(
           "trackIsoMap was nullptr but the configuration attempted to use it");
         return StatusCode::FAILURE;
       }
     } else {
       ATH_MSG_WARNING("Isolation flavour "
                       << xAOD::Iso::toCString(isoFlav)
                       << " does not exist ! Check your inputs");
     }
     runIsoType.insert(isoFlav);
   }
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

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

◆ isClonable()

bool AthReentrantAlgorithm::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in Simulation::BeamEffectsAlg, InDet::SiTrackerSpacePointFinder, InDet::SCT_Clusterization, InDet::SiSPSeededTrackFinder, SCTRawDataProvider, InDet::GNNSeedingTrackMaker, SCT_PrepDataToxAOD, RoIBResultToxAOD, InDet::SiSPGNNTrackMaker, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, ITkStripCablingAlg, SCTEventFlagWriter, SCT_ConditionsSummaryTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_TdaqEnabledTestAlg, SCT_SiliconConditionsTestAlg, SCTSiLorentzAngleTestAlg, SCT_ByteStreamErrorsTestAlg, SCT_ConditionsParameterTestAlg, SCT_FlaggedConditionTestAlg, SCT_StripVetoTestAlg, SCT_RawDataToxAOD, and SCTSiPropertiesTestAlg.

Definition at line 44 of file AthReentrantAlgorithm.cxx.

 {
   // Reentrant algorithms are clonable.
   return true;
 }

◆ isCoreCor()

bool IsolationBuilder::isCoreCor ( xAOD::Iso::IsolationCaloCorrection corr )

staticprivate

Definition at line 262 of file IsolationBuilder.cxx.

 {
   return (cor == xAOD::Iso::coreCone || cor == xAOD::Iso::coreConeSC ||
           cor == xAOD::Iso::coreMuon || cor == xAOD::Iso::core57cells);
 }

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Gaudi::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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ setFilterPassed()

virtual void AthReentrantAlgorithm::setFilterPassed	(	bool	state,
		const EventContext &	ctx
	)		const

inlinevirtualinherited

Definition at line 139 of file AthReentrantAlgorithm.h.

                                                                             {
     execState( ctx ).setFilterPassed( state );
   }

◆ sysExecute()

StatusCode AthReentrantAlgorithm::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 67 of file AthReentrantAlgorithm.cxx.

 {
   return Gaudi::Algorithm::sysExecute (ctx);
 }

◆ sysInitialize()

StatusCode AthReentrantAlgorithm::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< Gaudi::Algorithm > >.

Reimplemented in InputMakerBase, and HypoBase.

Definition at line 96 of file AthReentrantAlgorithm.cxx.

                                                 {
   StatusCode sc=AthCommonDataStore<AthCommonMsg<Gaudi::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< Gaudi::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< Gaudi::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);
       }
     }
   }

Member Data Documentation

◆ m_allTrackRemoval

Gaudi::Property<bool> IsolationBuilder::m_allTrackRemoval { this, "AllTrackRemoval", true }

private

Definition at line 145 of file IsolationBuilder.h.

◆ m_cellIsolationTool

ToolHandle<xAOD::ICaloCellIsolationTool> IsolationBuilder::m_cellIsolationTool

private

Initial value:

{
    this,
    "CaloCellIsolationTool",
    "",
    "Handle of the calo cell IsolationTool"
  }

Tool for cell isolation calculation.

Definition at line 97 of file IsolationBuilder.h.

◆ m_cellsKey

SG::ReadHandleKey<CaloCellContainer> IsolationBuilder::m_cellsKey

private

Initial value:

{
    this,
    "CellCollectionName",
    "AllCalo",
    "Name of container which contain calo cells"
  }

Cell container.

Definition at line 105 of file IsolationBuilder.h.

◆ m_customConfigEl

Gaudi::Property<std::string> IsolationBuilder::m_customConfigEl

private

Initial value:

{
    this,
    "CustomConfigurationNameEl",
    "",
    "use a custom configuration for electron"
  }

Definition at line 349 of file IsolationBuilder.h.

◆ m_customConfigFwd

Gaudi::Property<std::string> IsolationBuilder::m_customConfigFwd

private

Initial value:

{
    this,
    "CustomConfigurationNameFwd",
    "",
    "use a custom configuration for forward electron"
  }

Definition at line 363 of file IsolationBuilder.h.

◆ m_customConfigMu

Gaudi::Property<std::string> IsolationBuilder::m_customConfigMu

private

Initial value:

{
    this,
    "CustomConfigurationNameMu",
    "",
    "use a custom configuration for muon"
  }

Definition at line 370 of file IsolationBuilder.h.

◆ m_customConfigPh

Gaudi::Property<std::string> IsolationBuilder::m_customConfigPh

private

Initial value:

{
    this,
    "CustomConfigurationNamePh",
    "",
    "use a custom configuration for photon"
  }

Definition at line 356 of file IsolationBuilder.h.

◆ m_detStore

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

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_elCaloIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey> > IsolationBuilder::m_elCaloIso

private

Definition at line 277 of file IsolationBuilder.h.

◆ m_elcorInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_elcorInts

private

Initial value:

{
    this,
    "ElCorTypes",
    {},
    "The correction types to do for electron iso: vector of vector of enum "
    "type Iso::IsolationCalo/TrackCorrection"
  }

Definition at line 158 of file IsolationBuilder.h.

◆ m_elcorIntsExtra

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_elcorIntsExtra

private

Initial value:

{
    this,
    "ElCorTypesExtra",
    {},
    "The extra correction types to store but not apply for electrons"
  }

Definition at line 166 of file IsolationBuilder.h.

◆ m_ElectronContainerName

Gaudi::Property<std::string> IsolationBuilder::m_ElectronContainerName

private

Initial value:

{
    this,
    "ElectronCollectionContainerName",
    "Electrons"
  }

Containers (Is it best to make them as strings? Used by multiple handles)

Definition at line 72 of file IsolationBuilder.h.

◆ m_elisoInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_elisoInts

private

Initial value:

{
    this,
    "ElIsoTypes",
    {},
    "The isolation types to do for electrons: vector of vector of enum type "
    "Iso::IsolationType"
  }

Isolation types.

Definition at line 150 of file IsolationBuilder.h.

◆ m_elTrackIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey> > IsolationBuilder::m_elTrackIso

private

Definition at line 314 of file IsolationBuilder.h.

◆ m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthReentrantAlgorithm::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 153 of file AthReentrantAlgorithm.h.

◆ m_feCaloIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey> > IsolationBuilder::m_feCaloIso

private

Definition at line 281 of file IsolationBuilder.h.

◆ m_fecorInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_fecorInts

private

Initial value:

{
    this,
    "FeCorTypes",
    {},
    "The correction types to do for forward electron iso: vector of vector of "
    "enum type Iso::IsolationCalo/TrackCorrection"
  }

Definition at line 229 of file IsolationBuilder.h.

◆ m_fecorIntsExtra

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_fecorIntsExtra

private

Initial value:

{
    this,
    "FeCorTypesExtra",
    {},
    "The extra correction types to store but not apply for forward electrons"
  }

Definition at line 237 of file IsolationBuilder.h.

◆ m_feisoInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_feisoInts

private

Initial value:

{
    this,
    "FeIsoTypes",
    {},
    "The isolation types to do for forward electron: vector of vector of enum "
    "type Iso::IsolationType"
  }

Definition at line 221 of file IsolationBuilder.h.

◆ m_FwdElectronContainerName

Gaudi::Property<std::string> IsolationBuilder::m_FwdElectronContainerName

private

Initial value:

{
    this,
    "FwdElectronCollectionContainerName",
    "ForwardElectrons"
  }

Definition at line 78 of file IsolationBuilder.h.

◆ m_isTrigger

Gaudi::Property<bool> IsolationBuilder::m_isTrigger { this, "IsTrigger", false }

private

is the alg run at trigger level

Definition at line 137 of file IsolationBuilder.h.

◆ m_muCaloIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey> > IsolationBuilder::m_muCaloIso

private

Definition at line 283 of file IsolationBuilder.h.

◆ m_mucorInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_mucorInts

private

Initial value:

{
    this,
    "MuCorTypes",
    {},
    "The correction types to do for Muon iso: vector of vector of enum type "
    "Iso::IsolationCalo/TrackCorrection"
  }

Definition at line 206 of file IsolationBuilder.h.

◆ m_mucorIntsExtra

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_mucorIntsExtra

private

Initial value:

{
    this,
    "MuCorTypesExtra",
    {},
    "The extra correction types to store but not apply for muons"
  }

Definition at line 214 of file IsolationBuilder.h.

◆ m_muisoInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_muisoInts

private

Initial value:

{
    this,
    "MuIsoTypes",
    {},
    "The isolation types to do for Muons : vector of vector of enum type "
    "Iso::IsolationType"
  }

Definition at line 198 of file IsolationBuilder.h.

◆ m_MuonContainerName

Gaudi::Property<std::string> IsolationBuilder::m_MuonContainerName

private

Initial value:

{
    this,
    "MuonCollectionContainerName",
    "Muons"
  }

Definition at line 90 of file IsolationBuilder.h.

◆ m_muTrackIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey> > IsolationBuilder::m_muTrackIso

private

Definition at line 318 of file IsolationBuilder.h.

◆ m_pflowIsolationTool

ToolHandle<xAOD::INeutralEFlowIsolationTool> IsolationBuilder::m_pflowIsolationTool

private

Initial value:

{
    this,
    "PFlowIsolationTool",
    "",
    "Handle of the pflow IsolationTool"
  }

Tool for neutral pflow isolation calculation.

Definition at line 121 of file IsolationBuilder.h.

◆ m_phCaloIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, CaloIsoHelpKey> > IsolationBuilder::m_phCaloIso

private

Definition at line 279 of file IsolationBuilder.h.

◆ m_phcorInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_phcorInts

private

Initial value:

{
    this,
    "PhCorTypes",
    {},
    "The correction types to do for photons iso: vector of vector of enum type "
    "Iso::IsolationCalo/TrackCorrection"
  }

Definition at line 183 of file IsolationBuilder.h.

◆ m_phcorIntsExtra

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_phcorIntsExtra

private

Initial value:

{
    this,
    "PhCorTypesExtra",
    {},
    "The extra correction types to store but not apply for photons"
  }

Definition at line 191 of file IsolationBuilder.h.

◆ m_phisoInts

Gaudi::Property<std::vector<std::vector<int> > > IsolationBuilder::m_phisoInts

private

Initial value:

{
    this,
    "PhIsoTypes",
    {},
    "The isolation types to do for photons: vector of vector of enum type "
    "Iso::IsolationType"
  }

Isolation types (for the alg.

properties, only vector<vector<double>> available

Definition at line 175 of file IsolationBuilder.h.

◆ m_PhotonContainerName

Gaudi::Property<std::string> IsolationBuilder::m_PhotonContainerName

private

Initial value:

{
    this,
    "PhotonCollectionContainerName",
    "Photons"
  }

Definition at line 84 of file IsolationBuilder.h.

◆ m_phTrackIso

std::vector<std::pair<xAOD::Iso::IsolationFlavour, TrackIsoHelpKey> > IsolationBuilder::m_phTrackIso

private

Definition at line 316 of file IsolationBuilder.h.

◆ m_storepileupCorrection

Gaudi::Property<bool> IsolationBuilder::m_storepileupCorrection { this, "storepileupCorrection", false }

private

Definition at line 147 of file IsolationBuilder.h.

◆ m_topoIsolationTool

ToolHandle<xAOD::ICaloTopoClusterIsolationTool> IsolationBuilder::m_topoIsolationTool

private

Initial value:

{
    this,
    "CaloTopoIsolationTool",
    "",
    "Handle of the calo topo IsolationTool"
  }

Tool for topo isolation calculation.

Definition at line 113 of file IsolationBuilder.h.

◆ m_trackIsolationTool

ToolHandle<xAOD::ITrackIsolationTool> IsolationBuilder::m_trackIsolationTool

private

Initial value:

{
    this,
    "TrackIsolationTool",
    "",
    "Handle of the track IsolationTool"
  }

Tool for neutral pflow isolation calculation.

Definition at line 129 of file IsolationBuilder.h.

◆ m_useBremAssoc

Gaudi::Property<bool> IsolationBuilder::m_useBremAssoc

private

Initial value:

{ this,
                                        "useBremAssoc",
                                        true,
                                        "use track to track assoc after brem" }

Definition at line 140 of file IsolationBuilder.h.

◆ m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ IsolationBuilder() [1/2]

◆ ~IsolationBuilder()

◆ IsolationBuilder() [2/2]

Member Function Documentation

◆ addCaloIsoCorrections()

◆ addTrackIsoCorrections()

◆ cardinality()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ declareIso() [1/2]

◆ declareIso() [2/2]

◆ 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]

◆ execute()

◆ executeCaloIso()

◆ executeTrackIso()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ finalize()

◆ initialize()

◆ initializeIso()

◆ inputHandles()

◆ isClonable()

◆ isCoreCor()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_allTrackRemoval

◆ m_cellIsolationTool

◆ m_cellsKey

◆ m_customConfigEl

◆ m_customConfigFwd

◆ m_customConfigMu

◆ m_customConfigPh

◆ m_detStore

◆ m_elCaloIso

◆ m_elcorInts

◆ m_elcorIntsExtra

◆ m_ElectronContainerName

◆ m_elisoInts

◆ m_elTrackIso

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_feCaloIso

◆ m_fecorInts

◆ m_fecorIntsExtra

◆ m_feisoInts

◆ m_FwdElectronContainerName

◆ m_isTrigger

◆ m_muCaloIso