AthReentrantAlgorithm to associate Flow Elements (FEs) to Muons. More...

#include <PFMuonFlowElementAssoc.h>

Inheritance diagram for PFMuonFlowElementAssoc:

Collaboration diagram for PFMuonFlowElementAssoc:

Public Member Functions
	PFMuonFlowElementAssoc (const std::string &name, ISvcLocator *pSvcLocator)

virtual	~PFMuonFlowElementAssoc ()

virtual StatusCode	initialize ()

virtual StatusCode	execute (const EventContext &ctx) const

	AthReentrantAlgorithm (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters: More...

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
std::pair< double, double >	doMuonCellMatching (bool &isCellMatched, const xAOD::CaloCluster &FECluster, const xAOD::CaloCluster &muonCluster) const
	Function that flags whether the FE cluster has any cell that is also in the muon list of cells. More...

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
SG::ReadHandleKey< xAOD::MuonContainer >	m_muonReadHandleKey {this,"MuonContainer","Muons","ReadHandleKey for Muons"}

SG::ReadHandleKey< xAOD::FlowElementContainer >	m_neutralFEReadHandleKey {this,"JetEtMissNeutralFlowElementContainer","JetETMissNeutralParticleFlowObjects","ReadHandleKey for neutral FlowElements"}

SG::ReadHandleKey< xAOD::FlowElementContainer >	m_chargedFEReadHandleKey {this,"JetEtMissChargedFlowElementContainer","JetETMissChargedParticleFlowObjects","ReadHandleKey for charged FlowElements"}

SG::WriteDecorHandleKey< xAOD::MuonContainer >	m_muonChargedFEWriteHandleKey {this,"MuonContainer_chargedFELinks","Muons.chargedFELinks","WriteHandleKey for muon link to charged FlowElements"}
	Write key for adding charged Flow Element link decorations to muons. More...

SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_ChargedFE_energy_match_muonWriteHandleKey {this,"FlowElementContainer_ChargedFE_ennergy_matched_muon","JetETMissChargedParticleFlowObjects.FE_efrac_matched_muon","WriteHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"}
	Write key for adding fraction of nFlowElement cluster energy used in cell matching decoration of FlowElementContainer - EXPERIMENTAL. More...

SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_ChargedFEmuonWriteHandleKey {this,"JetETMissChargedFlowElements_FE_MuonLinks","JetETMissChargedParticleFlowObjects.FE_MuonLinks","WriteHandleKey for Charged Flow Elements coupled to muons"}
	Write key for adding Muon link decorations to charged Flow Elements. More...

SG::WriteDecorHandleKey< xAOD::MuonContainer >	m_muonNeutralFEWriteHandleKey {this,"MuonContainer_neutralFELinks","Muons.neutralFELinks","WriteHandleKey for muon links to neutral FlowElement"}
	Write key for adding neutral Flow Element link decorations to muons. More...

SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_NeutralFEmuonWriteHandleKey {this,"JetETMissNeutralFlowElementContainer_FE_MuonLinks","JetETMissNeutralParticleFlowObjects.FE_MuonLinks","WriteHandleKey for neutral flow Elements to Muons"}
	Write key for adding Muon link decorations to neutral Flow Elements. More...

SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_NeutralFE_efrac_match_muonWriteHandleKey {this,"FlowElementContainer_FE_efrac_matched_muon","JetETMissNeutralParticleFlowObjects.FE_efrac_matched_muon","WriteHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"}
	Write key for adding fraction of nFlowElement cluster energy used in cell matching decoration of FlowElementContainer - EXPERIMENTAL. More...

SG::WriteDecorHandleKey< xAOD::MuonContainer >	m_muonNeutralFE_muon_efrac_WriteDecorHandleKey {this,"MuonContainer_muon_efrac_matched_FE","Muons.muon_efrac_matched_FE","WriteHandleKey for the fraction of muon cluster energy used to match to neutral Flow Elements"}
	Write key for adding fraction of Muon cluster energy used in cell matching decoration of MuonContainer -EXPERIMENTAL. More...

SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_NeutralFEmuon_nMatches_WriteDecorHandleKey {this,"FlowElementContainer_nMatchedMuons","JetETMissNeutralParticleFlowObjects.FE_nMatchedMuons","WriteHandleKey for the number of muons matched to a given neutral flow element"}
	Write key to count number of muons matched to a given neutral FE - EXPERIMENTAL. More...

SG::WriteDecorHandleKey< xAOD::MuonContainer >	m_muon_ClusterInfo_deltaR_WriteDecorHandleKey {this,"MuonContainer_ClusterInfo_deltaR","Muons.ClusterInfo_deltaR","WriteHandleKey for the delta R between the muon and it's associated calocluster"}
	Write key to measure dR between calo clusters and the muon -EXPERIMENTAL. More...

SG::ReadDecorHandleKey< xAOD::CaloClusterContainer >	m_ClustCollectionLinkKey {this,"ElementLinkName", "MuonClusterCollection.constituentClusterLinks"}

Gaudi::Property< bool >	m_LinkNeutralFEClusters {this,"LinkNeutralFEClusters",false,"Toggle usage of linkage of Neutral FlowElements - false by default (EXPERIMENTAL)"}
	Gaudi Property to configure linkage of Neutral Flow Elements to Muon clusters (EXPERIMENTAL - default = False/OFF) More...

Gaudi::Property< bool >	m_useMuonTopoClusters {this,"useMuonTopoClusters",false,"Toggle usage of linker of muon associated topoclusters to flow elements - false by default (EXPERIMENTAL)"}
	(EXPERIMENTAL) Gaudi Property to configure linkage of Neutral FEs to TopoClusters associated to Muons. More...

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

AthReentrantAlgorithm to associate Flow Elements (FEs) to Muons.

Associates tracks from charged flow elements to Muons only (otherwise links to NULL)

Definition at line 29 of file PFMuonFlowElementAssoc.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

◆ PFMuonFlowElementAssoc()

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

Definition at line 25 of file PFMuonFlowElementAssoc.cxx.

                                                                                               :
     AthReentrantAlgorithm(name, pSvcLocator) {
     // Declare the decoration keys
 }

◆ ~PFMuonFlowElementAssoc()

PFMuonFlowElementAssoc::~PFMuonFlowElementAssoc ( )

virtualdefault

Member Function Documentation

◆ AthReentrantAlgorithm()

AthReentrantAlgorithm::AthReentrantAlgorithm

Constructor with parameters:

Definition at line 90 of file AthReentrantAlgorithm.cxx.

                                                                          :
   ::AthCommonDataStore<AthCommonMsg<Gaudi::Algorithm>>   ( name, pSvcLocator )
 {
  
   // Set up to run AthAlgorithmDHUpdate in sysInitialize before
   // merging depedency lists.  This extends the output dependency
   // list with any symlinks implied by inheritance relations.
   m_updateDataHandles =
     std::make_unique<AthenaBaseComps::AthAlgorithmDHUpdate>
     (m_extendedExtraObjects,
      std::move (m_updateDataHandles));
 }

◆ 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);
   }

◆ 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; }

◆ doMuonCellMatching()

std::pair< double, double > PFMuonFlowElementAssoc::doMuonCellMatching	(	bool &	isCellMatched,
		const xAOD::CaloCluster &	FECluster,
		const xAOD::CaloCluster &	muonCluster
	)		const

private

Function that flags whether the FE cluster has any cell that is also in the muon list of cells.

If so the function sets isCellMatched to true and returns non-zero values of the sum of matched energy in the FE and muon clusters.

Definition at line 325 of file PFMuonFlowElementAssoc.cxx.

       {
  
     const CaloClusterCellLink* FECellLinks = FECluster.getCellLinks();                         
     if (!FECellLinks && !m_useMuonTopoClusters) { 
         ATH_MSG_WARNING("Flow Element CaloCluster CaloClusterCellLink is nullptr");
         return std::make_pair(0.0,0.0);
     }
  
     const CaloClusterCellLink* muonCellLinks = muonCluster.getCellLinks();    
     if (!muonCellLinks) {
         ATH_MSG_WARNING("This Muon calo cluster does not have any cells associated to it");
         return std::make_pair(0.0,0.0);
     }
     
     //sum of energy of FE cells that are matched 
     double FE_matchedCellEnergy = 0;
     //sum of energy of muon cells that are matched
     double muon_matchedCellEnergy = 0;
  
     for (auto thisFECell : *FECellLinks){
         Identifier FECellID = thisFECell->ID();
         for (auto thisMuonCell : *muonCellLinks){
             Identifier muonCellID = thisMuonCell->ID();
             if (muonCellID == FECellID){
                 isCellMatched = true;
                 FE_matchedCellEnergy += thisFECell->e();
                 muon_matchedCellEnergy += thisMuonCell->e();
             }//if FE cell is also a muon cell
         }//loop on muon cells
     }//loop on FE cluster cells
  
     return std::make_pair(FE_matchedCellEnergy,muon_matchedCellEnergy);
  
 }   

◆ 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 PFMuonFlowElementAssoc::execute ( const EventContext & ctx ) const

virtual

not all muons have a track. catch the nullptrs in this case and skip

In short, this feature is an experimental linker between neutral FEs and Muons either by the following:
Case 1) Retrieve the CaloCluster(s) from the muon, and get any topocluster(s) associated to those, then link the topoclusters to the

neutral FEs Case 2) Retrieve the CaloCluster(s) from the muon then link to the neutral FEs

This code is switched using two switches:
m_LinkNeutralFEClusters (turns on the experimental feature)
m_useMuonTopoClusters (True= Case 1, False = Case 2)

Definition at line 61 of file PFMuonFlowElementAssoc.cxx.

                                                                         {
     // WriteDecorHandles for the charged/neutral Flow Elements and Muons
     // Links a Muon that has a track to a charged flow element if possible
  
     ATH_MSG_VERBOSE("Started execute step");
  
     // Get container for muons
     SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<FlowElementLink_t>> muonChargedFEWriteDecorHandle(m_muonChargedFEWriteHandleKey,
                                                                                                             ctx);
     SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<FlowElementLink_t>> muonNeutralFEWriteDecorHandle(m_muonNeutralFEWriteHandleKey,
                                                                                                             ctx);
     // get container for charged flow elements
     SG::WriteDecorHandle<xAOD::FlowElementContainer, std::vector<MuonLink_t>> ChargedFEmuonWriteDecorHandle(m_ChargedFEmuonWriteHandleKey,
                                                                                                             ctx);
     SG::WriteDecorHandle<xAOD::FlowElementContainer, std::vector<MuonLink_t>> NeutralFEmuonWriteDecorHandle(m_NeutralFEmuonWriteHandleKey,
                                                                                                             ctx);
  
     // extra container handles between neutral FE cluster and Muon CaloCluster - these are all for studies based on neutral Flow Element
     // matching - All of these handles are experimental
     SG::WriteDecorHandle<xAOD::FlowElementContainer, std::vector<double>> NeutralFE_efrac_match_muonWriteDecorHandle(
         m_NeutralFE_efrac_match_muonWriteHandleKey, ctx);
     SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<double>> muonNeutralFE_muon_efrac_WriteDecorHandle(
         m_muonNeutralFE_muon_efrac_WriteDecorHandleKey, ctx);
     SG::WriteDecorHandle<xAOD::FlowElementContainer, int> NeutralFEmuon_nMatches_WriteDecorHandle(
         m_NeutralFEmuon_nMatches_WriteDecorHandleKey, ctx);
     SG::WriteDecorHandle<xAOD::MuonContainer, double> muon_ClusterInfo_deltaR_WriteDecorHandle(
         m_muon_ClusterInfo_deltaR_WriteDecorHandleKey, ctx);
  
     // store readhandles for muon and charged flow elements
     SG::ReadHandle<xAOD::MuonContainer> muonReadHandle(m_muonReadHandleKey, ctx);  // readhandle for muon
     SG::ReadHandle<xAOD::FlowElementContainer> ChargedFEReadHandle(m_chargedFEReadHandleKey, ctx);
     SG::ReadHandle<xAOD::FlowElementContainer> NeutralFEReadHandle(m_neutralFEReadHandleKey, ctx);
     SG::ReadDecorHandle<xAOD::CaloClusterContainer, std::vector<ElementLink<xAOD::CaloClusterContainer>>> acc_constClusterLinks(m_ClustCollectionLinkKey,ctx);
     // now init some Flow element link containers
     std::vector<std::vector<FlowElementLink_t>> muonChargedFEVec(muonReadHandle->size());
     std::vector<std::vector<FlowElementLink_t>> muonNeutralFEVec(muonReadHandle->size());
  
     // for neutral flow element studies
     std::vector<std::vector<double>> muonNeutralFE_frac_cluster_energy_matched_Vec(muonReadHandle->size());
  
     SG::WriteDecorHandle<xAOD::FlowElementContainer, std::vector<double> > chargedFE_energy_match_muonWriteHandle(m_ChargedFE_energy_match_muonWriteHandleKey,ctx);
  
     // Loop over the Flow Elements
  
     //     CHARGED LOOP
     for (const xAOD::FlowElement* FE : *ChargedFEmuonWriteDecorHandle) {
         // get the track associated to the charged flow element (or at least the index of said track)
         size_t FETrackIndex = FE->chargedObjects().at(0)->index();
         // Init a vector of element links to muons
         std::vector<MuonLink_t> FEMuonLinks;
  
         //vector of fractions of FE cluster energy matched to muons
         std::vector<double> FEMatchedClusterCellEnergies;
         for (unsigned int counter = 0; counter < FE->otherObjects().size(); ++counter) FEMatchedClusterCellEnergies.push_back(0.0);
  
         // loop over muons in container
         for (const xAOD::Muon* muon : *muonChargedFEWriteDecorHandle) {
             const xAOD::TrackParticle* muon_trk = muon->trackParticle(xAOD::Muon::TrackParticleType::InnerDetectorTrackParticle);
             if (!muon_trk) continue;
             // skip muon matching if the following cases occur
             int MuonType = muon->muonType();
             int MuonAuthor = muon->author();
             if (MuonType == xAOD::Muon::SiliconAssociatedForwardMuon) {  // if muon is a forward muon, skip. Basically the tracks associated
                                                                        // to this are the wrong type (InDetForwardTrackParticle instead of
                                                                        // InDetTrackParticle), so the indices used would be wrong/generate
                                                                        // spurious matches
                 ATH_MSG_DEBUG("Muon is identified as a forward muon, skipping");
                 continue;
             }
             if (MuonAuthor == xAOD::Muon::Author::STACO) {  // remove muons primarily authored by STACO algorithm.
                 ATH_MSG_DEBUG("Muon is authored by STACO algorithm, skip");
                 continue;
             }
             size_t MuonTrkIndex = muon_trk->index();
             if (MuonTrkIndex == FETrackIndex) {
                 // Add Muon element link to a vector
                 // index() is the unique index of the muon in the muon container
                 FEMuonLinks.emplace_back(*muonReadHandle, muon->index());
                 // Add flow element link to a vector
                 // index() is the unique index of the cFlowElement in the cFlowElementcontaine
                 muonChargedFEVec.at(muon->index()).emplace_back(*ChargedFEReadHandle, FE->index());
             }  // matching block
  
             //if in mode where we can access calorimeter cells, then we will check if any of the clusters
             //that this chargedFE has modified have calorimeter cells that match the muons calorimeter cells
             //if so then we will decorate the charged FE with the fraction of cluster energy that was matched
             if (!m_useMuonTopoClusters){
                 const xAOD::CaloCluster* muonCluster = muon->cluster();
                 //these clusters are expected to be nullptr sometimes
                 if (!muonCluster) continue;                
                 unsigned int counter = 0;
                 for (auto thisCluster : FE->otherObjects()){
                     const xAOD::CaloCluster* thisCaloCluster = dynamic_cast<const xAOD::CaloCluster*>(thisCluster);
                     bool isCellMatched = false;
                     std::pair <double,double> FEAndMuonMatchedCellEnergy = this->doMuonCellMatching(isCellMatched, *thisCaloCluster,*muonCluster);
                     FEMatchedClusterCellEnergies[counter] += FEAndMuonMatchedCellEnergy.first;
                     counter++;
                 }//loop over associated calorimeter clusters
             }
         }// end of muon loop
  
         chargedFE_energy_match_muonWriteHandle(*FE) = FEMatchedClusterCellEnergies;
  
         // Add vector of muon element links as decoration to FlowElement container
         ChargedFEmuonWriteDecorHandle(*FE) = FEMuonLinks;
     }  // end of charged Flow Element loop
  
     //   Loop over Neutral FlowElements
  
     if (m_LinkNeutralFEClusters) {
         ATH_MSG_VERBOSE("Experimental: Cluster Linkers between neutral FEs and Muons are used");
         for (const xAOD::FlowElement* FE : *NeutralFEmuonWriteDecorHandle) {
             int nMatchedFE = 0;
             // get the index of the cluster corresponding to the Neutral FlowElements
             ATH_MSG_DEBUG("P1");
             ATH_MSG_DEBUG("FE with e, eta and phi" << FE->e() << ", " << FE->eta() << " and " << FE->phi());
             const xAOD::IParticle* otherObject = FE->otherObjects().at(0);
             //This is expected to happen for low energy FE - sometimes the linked cluster has E < 0 and 
             //is thinned away in the AOD
             if (!otherObject){
                 ATH_MSG_DEBUG("No linked cluster for Neutral FE with E, eta and phi" << FE->e() << ", " << FE->eta() << " and " << FE->phi());
                 continue;
             }
             size_t FEclusterindex = otherObject->index();
  
             // FE->otherObjects returns a vector of IParticles. We only want the first one
             const xAOD::IParticle* FE_Iparticle = FE->otherObjects().at(0);
  
             // dynamic cast to CaloCluster
             const xAOD::CaloCluster* FE_cluster = dynamic_cast<const xAOD::CaloCluster*>(FE_Iparticle);  // cast to CaloCluster            
  
             // debug for Negative energy cluster
  
             double cluster_E = FE_cluster->p4().E();
             bool neg_E_cluster = (cluster_E < 0.0);
  
             // design the vector of ElementLinks
             std::vector<MuonLink_t> FEMuonLinks;
             std::vector<double> FE_efrac_clustermatch;
             std::vector<double> Muon_efrac_clustermatch;
             for (const xAOD::Muon* muon : *muonNeutralFEWriteDecorHandle) {
                 // Retrieve the ElementLink vector of clusters
                 const xAOD::CaloCluster* cluster = muon->cluster(); 
                 // de-ref the element link to retrieve the pointer to the original object
                 // check if the ElementLink is valid
                 if (!cluster) {
                     ATH_MSG_DEBUG("Muon has an invalid link to cluster");
                     continue;
                 }
                 if (m_useMuonTopoClusters) {
                     // get the linker to the topo clusters
                     const std::vector<ElementLink<xAOD::CaloClusterContainer>>& linksToTopoClusters = acc_constClusterLinks(*cluster);
                     for (const ElementLink<xAOD::CaloClusterContainer>& TopoClusterLink : linksToTopoClusters) {
                          //This is expected to happen for low energy cluster - sometimes the linked cluster has E < 0 and 
                         //is thinned away in the AOD
                         if (!TopoClusterLink.isValid()) {
                             ATH_MSG_DEBUG("Muon Calo cluster's TopoCluster link not found, skip");
                             continue;
                         }
                         const xAOD::CaloCluster* MuonTopoCluster = *TopoClusterLink;  // de-ref the link to get the topo-cluster
                         size_t MuonTopoCluster_index = MuonTopoCluster->index();
                         if (MuonTopoCluster_index == FEclusterindex) {
                             // Add Muon element link to a vector
                             // index() is the unique index of the muon in the muon container
                             FEMuonLinks.emplace_back(*muonReadHandle, muon->index());
                             // index() is the unique index of the cFlowElement in the cFlowElementcontaine
                             muonNeutralFEVec.at(muon->index()).emplace_back(*NeutralFEReadHandle, FE->index());            
                             ATH_MSG_VERBOSE("Got a match between NFE and Muon");
                             nMatchedFE++;  // count number of matches between FE and muons
                             if (neg_E_cluster) ATH_MSG_ERROR("Muon cluster matched to negative E topocluster from FE");
                         }  // check block of index matching
                     }      // end of loop over element links
                 }          // end of TopoCluster specific block
                 else {     // case when we don't use Topoclusters, just match the caloclusters to the flow element
                     // if we don't match topoclusters, do something more complex:
                     // Retrieve cells in both the FE cluster and muon cluster
                     // Define the link as where at least one calo cell is shared between the FE cluster and the Muon Cluster
  
                     bool isCellMatched = false;
                     std::pair<double,double> FEAndMuonMatchedCellEnergy = this->doMuonCellMatching(isCellMatched, *FE_cluster,*cluster);
  
                     double FE_sum_matched_cellEnergy = FEAndMuonMatchedCellEnergy.first;
                     double Muon_sum_matched_cellEnergy = FEAndMuonMatchedCellEnergy.second;
  
                     double frac_FE_cluster_energy_matched = 0;
                     // retrieve total cluster energy from the FE cluster
                     double tot_FE_cluster_energy = FE_cluster->e();
                     if (tot_FE_cluster_energy != 0) {  // ! div 0
                         frac_FE_cluster_energy_matched = FE_sum_matched_cellEnergy / tot_FE_cluster_energy;
                     }
                     double tot_muon_cluster_energy = cluster->e();
                     double frac_muon_cluster_energy_matched = 0;
                     if (tot_muon_cluster_energy != 0) {
                         frac_muon_cluster_energy_matched = Muon_sum_matched_cellEnergy / tot_muon_cluster_energy;
                     }
                     if (frac_FE_cluster_energy_matched > 0) {
                         ATH_MSG_VERBOSE("Fraction of FE cluster energy used in match: " << frac_FE_cluster_energy_matched << ", ismatched? "
                                                                                         << isCellMatched << "");
                         ATH_MSG_VERBOSE("Numerator and denominator are " << FE_sum_matched_cellEnergy << " and " << tot_FE_cluster_energy);
                         ATH_MSG_VERBOSE("Fraction of Muon cluster energy used in match: " << frac_muon_cluster_energy_matched << "");
                     }
  
                     if (isCellMatched) {  // cell matched => Link the two objects.
                         // Add Muon element link to a vector
                         // index() is the unique index of the muon in the muon container
                         FEMuonLinks.emplace_back(*muonReadHandle, muon->index());
                         // index() is the unique index of the nFlowElement in the nFlowElementcontainer
                         muonNeutralFEVec.at(muon->index()).emplace_back(*NeutralFEReadHandle, FE->index());
                         // save the energy fraction used in the cluster matching - mostly for debug/extension studies
                         FE_efrac_clustermatch.push_back(frac_FE_cluster_energy_matched);  // fraction of FE cluster energy matched
                         muonNeutralFE_frac_cluster_energy_matched_Vec.at(muon->index())
                             .push_back(frac_muon_cluster_energy_matched);  // fraction of Muon cluster energy matched
                         nMatchedFE++;                                      // count number of matches incrementally
                         if (neg_E_cluster) { ATH_MSG_ERROR("Muon cluster matched to negative E topocluster from FE"); }
                     }
  
                 }  // end of calocluster specific block
                 // loop over caloclusters
             }  // loop over muons
             NeutralFEmuon_nMatches_WriteDecorHandle(*FE) = nMatchedFE;
             NeutralFEmuonWriteDecorHandle(*FE) = FEMuonLinks;
             NeutralFE_efrac_match_muonWriteDecorHandle(*FE) = FE_efrac_clustermatch;
         }  // loop over neutral FE
     }      // end of the Gaudi check block
  
     //   WRITE OUTPUT: ADD HANDLES TO MUON CONTAINERS
     // Add the vectors of the Flow Element Links as decoations to the muon container
     for (const xAOD::Muon* muon : *muonChargedFEWriteDecorHandle) {
         muonChargedFEWriteDecorHandle(*muon) = muonChargedFEVec.at(muon->index());
     }                               // end of muon loop
     if (m_LinkNeutralFEClusters) {  // Experimental
         for (const xAOD::Muon* muon : *muonNeutralFEWriteDecorHandle) {
             if (!muonNeutralFEVec.empty()) {
                 muonNeutralFEWriteDecorHandle(*muon) = muonNeutralFEVec.at(muon->index());
                 muonNeutralFE_muon_efrac_WriteDecorHandle(*muon) = muonNeutralFE_frac_cluster_energy_matched_Vec.at(muon->index());
             }
             // For debug of the muon clusters used, add also: dR between caloclusters and number of caloclusters associated to each muon.
             // retrieve element link again to cluster
             // use elem link to retrieve container
             const xAOD::CaloCluster* MuonCluster = muon->cluster();
             // retrieve the vector of delta R between muon and its associated calo cluster.
             muon_ClusterInfo_deltaR_WriteDecorHandle(*muon) =  MuonCluster ? xAOD::P4Helpers::deltaR(MuonCluster,muon,false) : -1.;
         }
     }  // end of experimental block
     ATH_MSG_VERBOSE("Execute completed successfully");
  
     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();
   }

◆ initialize()

StatusCode PFMuonFlowElementAssoc::initialize ( )

virtual

Definition at line 33 of file PFMuonFlowElementAssoc.cxx.

                                               {
     ATH_MSG_VERBOSE("Initializing " << name() << "...");
  
     // Initialise the decoration keys
     ATH_CHECK(m_muonChargedFEWriteHandleKey.initialize());
     ATH_CHECK(m_ChargedFE_energy_match_muonWriteHandleKey.initialize());
     ATH_CHECK(m_muonNeutralFEWriteHandleKey.initialize());
     ATH_CHECK(m_ClustCollectionLinkKey.initialize());
     ATH_CHECK(m_ChargedFEmuonWriteHandleKey.initialize());
     ATH_CHECK(m_NeutralFEmuonWriteHandleKey.initialize());
     ATH_CHECK(m_NeutralFE_efrac_match_muonWriteHandleKey.initialize());
  
     // init the experimental keys
     ATH_CHECK(m_muonNeutralFE_muon_efrac_WriteDecorHandleKey.initialize());
     ATH_CHECK(m_NeutralFEmuon_nMatches_WriteDecorHandleKey.initialize());
     ATH_CHECK(m_muon_ClusterInfo_deltaR_WriteDecorHandleKey.initialize());
  
     // init ReadHandleKeys
     ATH_CHECK(m_muonReadHandleKey.initialize());
     ATH_CHECK(m_chargedFEReadHandleKey.initialize());
     ATH_CHECK(m_neutralFEReadHandleKey.initialize());
  
     ATH_MSG_VERBOSE("Initialization completed successfully");
  
     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, SCT_CablingCondAlgFromCoraCool, SCT_ReadCalibDataTestAlg, SCT_CablingCondAlgFromText, InDet::SiSPGNNTrackMaker, SCT_ReadCalibChipDataTestAlg, SCT_TestCablingAlg, SCT_ConfigurationConditionsTestAlg, ITkPixelCablingAlg, 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;
 }

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

SG::WriteDecorHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_ChargedFE_energy_match_muonWriteHandleKey {this,"FlowElementContainer_ChargedFE_ennergy_matched_muon","JetETMissChargedParticleFlowObjects.FE_efrac_matched_muon","WriteHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"}

private

Write key for adding fraction of nFlowElement cluster energy used in cell matching decoration of FlowElementContainer - EXPERIMENTAL.

Definition at line 61 of file PFMuonFlowElementAssoc.h.

◆ m_ChargedFEmuonWriteHandleKey

SG::WriteDecorHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_ChargedFEmuonWriteHandleKey {this,"JetETMissChargedFlowElements_FE_MuonLinks","JetETMissChargedParticleFlowObjects.FE_MuonLinks","WriteHandleKey for Charged Flow Elements coupled to muons"}

private

Write key for adding Muon link decorations to charged Flow Elements.

Definition at line 65 of file PFMuonFlowElementAssoc.h.

◆ m_chargedFEReadHandleKey

SG::ReadHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_chargedFEReadHandleKey {this,"JetEtMissChargedFlowElementContainer","JetETMissChargedParticleFlowObjects","ReadHandleKey for charged FlowElements"}

private

Definition at line 55 of file PFMuonFlowElementAssoc.h.

◆ m_ClustCollectionLinkKey

SG::ReadDecorHandleKey<xAOD::CaloClusterContainer> PFMuonFlowElementAssoc::m_ClustCollectionLinkKey {this,"ElementLinkName", "MuonClusterCollection.constituentClusterLinks"}

private

Definition at line 85 of file PFMuonFlowElementAssoc.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_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_LinkNeutralFEClusters

Gaudi::Property<bool> PFMuonFlowElementAssoc::m_LinkNeutralFEClusters {this,"LinkNeutralFEClusters",false,"Toggle usage of linkage of Neutral FlowElements - false by default (EXPERIMENTAL)"}

private

Gaudi Property to configure linkage of Neutral Flow Elements to Muon clusters (EXPERIMENTAL - default = False/OFF)

Definition at line 88 of file PFMuonFlowElementAssoc.h.

◆ m_muon_ClusterInfo_deltaR_WriteDecorHandleKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> PFMuonFlowElementAssoc::m_muon_ClusterInfo_deltaR_WriteDecorHandleKey {this,"MuonContainer_ClusterInfo_deltaR","Muons.ClusterInfo_deltaR","WriteHandleKey for the delta R between the muon and it's associated calocluster"}

private

Write key to measure dR between calo clusters and the muon -EXPERIMENTAL.

Definition at line 83 of file PFMuonFlowElementAssoc.h.

◆ m_muonChargedFEWriteHandleKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> PFMuonFlowElementAssoc::m_muonChargedFEWriteHandleKey {this,"MuonContainer_chargedFELinks","Muons.chargedFELinks","WriteHandleKey for muon link to charged FlowElements"}

private

Write key for adding charged Flow Element link decorations to muons.

Definition at line 58 of file PFMuonFlowElementAssoc.h.

◆ m_muonNeutralFE_muon_efrac_WriteDecorHandleKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> PFMuonFlowElementAssoc::m_muonNeutralFE_muon_efrac_WriteDecorHandleKey {this,"MuonContainer_muon_efrac_matched_FE","Muons.muon_efrac_matched_FE","WriteHandleKey for the fraction of muon cluster energy used to match to neutral Flow Elements"}

private

Write key for adding fraction of Muon cluster energy used in cell matching decoration of MuonContainer -EXPERIMENTAL.

Definition at line 77 of file PFMuonFlowElementAssoc.h.

◆ m_muonNeutralFEWriteHandleKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> PFMuonFlowElementAssoc::m_muonNeutralFEWriteHandleKey {this,"MuonContainer_neutralFELinks","Muons.neutralFELinks","WriteHandleKey for muon links to neutral FlowElement"}

private

Write key for adding neutral Flow Element link decorations to muons.

Definition at line 68 of file PFMuonFlowElementAssoc.h.

◆ m_muonReadHandleKey

SG::ReadHandleKey<xAOD::MuonContainer> PFMuonFlowElementAssoc::m_muonReadHandleKey {this,"MuonContainer","Muons","ReadHandleKey for Muons"}

private

Definition at line 51 of file PFMuonFlowElementAssoc.h.

◆ m_NeutralFE_efrac_match_muonWriteHandleKey

SG::WriteDecorHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_NeutralFE_efrac_match_muonWriteHandleKey {this,"FlowElementContainer_FE_efrac_matched_muon","JetETMissNeutralParticleFlowObjects.FE_efrac_matched_muon","WriteHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"}

private

Write key for adding fraction of nFlowElement cluster energy used in cell matching decoration of FlowElementContainer - EXPERIMENTAL.

Definition at line 74 of file PFMuonFlowElementAssoc.h.

◆ m_NeutralFEmuon_nMatches_WriteDecorHandleKey

SG::WriteDecorHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_NeutralFEmuon_nMatches_WriteDecorHandleKey {this,"FlowElementContainer_nMatchedMuons","JetETMissNeutralParticleFlowObjects.FE_nMatchedMuons","WriteHandleKey for the number of muons matched to a given neutral flow element"}

private

Write key to count number of muons matched to a given neutral FE - EXPERIMENTAL.

Definition at line 80 of file PFMuonFlowElementAssoc.h.

◆ m_NeutralFEmuonWriteHandleKey

SG::WriteDecorHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_NeutralFEmuonWriteHandleKey {this,"JetETMissNeutralFlowElementContainer_FE_MuonLinks","JetETMissNeutralParticleFlowObjects.FE_MuonLinks","WriteHandleKey for neutral flow Elements to Muons"}

private

Write key for adding Muon link decorations to neutral Flow Elements.

Definition at line 71 of file PFMuonFlowElementAssoc.h.

◆ m_neutralFEReadHandleKey

SG::ReadHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_neutralFEReadHandleKey {this,"JetEtMissNeutralFlowElementContainer","JetETMissNeutralParticleFlowObjects","ReadHandleKey for neutral FlowElements"}

private

Definition at line 53 of file PFMuonFlowElementAssoc.h.

◆ m_useMuonTopoClusters

Gaudi::Property<bool> PFMuonFlowElementAssoc::m_useMuonTopoClusters {this,"useMuonTopoClusters",false,"Toggle usage of linker of muon associated topoclusters to flow elements - false by default (EXPERIMENTAL)"}

private

(EXPERIMENTAL) Gaudi Property to configure linkage of Neutral FEs to TopoClusters associated to Muons.

Only works with previous option set to True (m_LinkNeutralFEClusters). True: Link FEs to Topoclusters associated to Muons False: Link FEs to CaloClusters associated to Muons

Definition at line 95 of file PFMuonFlowElementAssoc.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:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ PFMuonFlowElementAssoc()

◆ ~PFMuonFlowElementAssoc()

Member Function Documentation

◆ AthReentrantAlgorithm()

◆ cardinality()

◆ 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()

◆ doMuonCellMatching()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ setFilterPassed()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_ChargedFE_energy_match_muonWriteHandleKey

◆ m_ChargedFEmuonWriteHandleKey

◆ m_chargedFEReadHandleKey

◆ m_ClustCollectionLinkKey

◆ m_detStore

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_LinkNeutralFEClusters

◆ m_muon_ClusterInfo_deltaR_WriteDecorHandleKey

◆ m_muonChargedFEWriteHandleKey

◆ m_muonNeutralFE_muon_efrac_WriteDecorHandleKey

◆ m_muonNeutralFEWriteHandleKey

◆ m_muonReadHandleKey

◆ m_NeutralFE_efrac_match_muonWriteHandleKey

◆ m_NeutralFEmuon_nMatches_WriteDecorHandleKey

◆ m_NeutralFEmuonWriteHandleKey

◆ m_neutralFEReadHandleKey

◆ m_useMuonTopoClusters

◆ m_varHandleArraysDeclared

◆ m_vhka