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
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

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.
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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",m_muonReadHandleKey,"chargedFELinks","WriteHandleKey for muon link to charged FlowElements"}
	Write key for adding charged Flow Element link decorations to muons.
SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_ChargedFE_energy_match_muonWriteHandleKey {this,"FlowElementContainer_ChargedFE_ennergy_matched_muon",m_chargedFEReadHandleKey,"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.
SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_ChargedFEmuonWriteHandleKey {this,"JetETMissChargedFlowElements_FE_MuonLinks",m_chargedFEReadHandleKey,"FE_MuonLinks","WriteHandleKey for Charged Flow Elements coupled to muons"}
	Write key for adding Muon link decorations to charged Flow Elements.
SG::WriteDecorHandleKey< xAOD::MuonContainer >	m_muonNeutralFEWriteHandleKey {this,"MuonContainer_neutralFELinks",m_muonReadHandleKey,"neutralFELinks","WriteHandleKey for muon links to neutral FlowElement"}
	Write key for adding neutral Flow Element link decorations to muons.
SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_NeutralFEmuonWriteHandleKey {this,"JetETMissNeutralFlowElementContainer_FE_MuonLinks",m_neutralFEReadHandleKey,"FE_MuonLinks","WriteHandleKey for neutral flow Elements to Muons"}
	Write key for adding Muon link decorations to neutral Flow Elements.
SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_NeutralFE_efrac_match_muonWriteHandleKey {this,"FlowElementContainer_FE_efrac_matched_muon",m_neutralFEReadHandleKey,"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.
SG::WriteDecorHandleKey< xAOD::MuonContainer >	m_muonNeutralFE_muon_efrac_WriteDecorHandleKey {this,"MuonContainer_muon_efrac_matched_FE",m_muonReadHandleKey,"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.
SG::WriteDecorHandleKey< xAOD::FlowElementContainer >	m_NeutralFEmuon_nMatches_WriteDecorHandleKey {this,"FlowElementContainer_nMatchedMuons",m_neutralFEReadHandleKey,"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.
SG::WriteDecorHandleKey< xAOD::MuonContainer >	m_muon_ClusterInfo_deltaR_WriteDecorHandleKey {this,"MuonContainer_ClusterInfo_deltaR",m_muonReadHandleKey,"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.
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).
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.
DataObjIDColl	m_extendedExtraObjects
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
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 27 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

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareGaudiProperty	(	Gaudi::Property< T, V, H > &	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());
 
  }

◆ declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > & 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; }

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

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

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

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

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

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ 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
            if (muon->muonType() == xAOD::Muon::MuonType::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 (muon->author() == 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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.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 BaseAlg::extraOutputDeps();
}

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

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

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

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

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed	(	bool	state,
		const EventContext &	ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

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

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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 HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::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",m_chargedFEReadHandleKey,"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 59 of file PFMuonFlowElementAssoc.h.

59{this,"FlowElementContainer_ChargedFE_ennergy_matched_muon",m_chargedFEReadHandleKey,"FE_efrac_matched_muon","WriteHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"};

◆ m_ChargedFEmuonWriteHandleKey

SG::WriteDecorHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_ChargedFEmuonWriteHandleKey {this,"JetETMissChargedFlowElements_FE_MuonLinks",m_chargedFEReadHandleKey,"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 63 of file PFMuonFlowElementAssoc.h.

63{this,"JetETMissChargedFlowElements_FE_MuonLinks",m_chargedFEReadHandleKey,"FE_MuonLinks","WriteHandleKey for Charged Flow Elements coupled to muons"};

◆ m_chargedFEReadHandleKey

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

private

Definition at line 53 of file PFMuonFlowElementAssoc.h.

53{this,"JetEtMissChargedFlowElementContainer","JetETMissChargedParticleFlowObjects","ReadHandleKey for charged FlowElements"};

◆ m_ClustCollectionLinkKey

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

private

Definition at line 83 of file PFMuonFlowElementAssoc.h.

83{this,"ElementLinkName", "MuonClusterCollection.constituentClusterLinks"};

◆ 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 AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

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

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.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 86 of file PFMuonFlowElementAssoc.h.

86{this,"LinkNeutralFEClusters",false,"Toggle usage of linkage of Neutral FlowElements - false by default (EXPERIMENTAL)"};

◆ m_muon_ClusterInfo_deltaR_WriteDecorHandleKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> PFMuonFlowElementAssoc::m_muon_ClusterInfo_deltaR_WriteDecorHandleKey {this,"MuonContainer_ClusterInfo_deltaR",m_muonReadHandleKey,"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 81 of file PFMuonFlowElementAssoc.h.

81{this,"MuonContainer_ClusterInfo_deltaR",m_muonReadHandleKey,"ClusterInfo_deltaR","WriteHandleKey for the delta R between the muon and it's associated calocluster"};

◆ m_muonChargedFEWriteHandleKey

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

private

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

Definition at line 56 of file PFMuonFlowElementAssoc.h.

56{this,"MuonContainer_chargedFELinks",m_muonReadHandleKey,"chargedFELinks","WriteHandleKey for muon link to charged FlowElements"};

◆ m_muonNeutralFE_muon_efrac_WriteDecorHandleKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> PFMuonFlowElementAssoc::m_muonNeutralFE_muon_efrac_WriteDecorHandleKey {this,"MuonContainer_muon_efrac_matched_FE",m_muonReadHandleKey,"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 75 of file PFMuonFlowElementAssoc.h.

75{this,"MuonContainer_muon_efrac_matched_FE",m_muonReadHandleKey,"muon_efrac_matched_FE","WriteHandleKey for the fraction of muon cluster energy used to match to neutral Flow Elements"};

◆ m_muonNeutralFEWriteHandleKey

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

private

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

Definition at line 66 of file PFMuonFlowElementAssoc.h.

66{this,"MuonContainer_neutralFELinks",m_muonReadHandleKey,"neutralFELinks","WriteHandleKey for muon links to neutral FlowElement"};

◆ m_muonReadHandleKey

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

private

Definition at line 49 of file PFMuonFlowElementAssoc.h.

49{this,"MuonContainer","Muons","ReadHandleKey for Muons"};

◆ m_NeutralFE_efrac_match_muonWriteHandleKey

SG::WriteDecorHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_NeutralFE_efrac_match_muonWriteHandleKey {this,"FlowElementContainer_FE_efrac_matched_muon",m_neutralFEReadHandleKey,"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 72 of file PFMuonFlowElementAssoc.h.

72{this,"FlowElementContainer_FE_efrac_matched_muon",m_neutralFEReadHandleKey,"FE_efrac_matched_muon","WriteHandleKey for the fraction of neutral FlowElements cluster energy used to match to Muons"};

◆ m_NeutralFEmuon_nMatches_WriteDecorHandleKey

SG::WriteDecorHandleKey<xAOD::FlowElementContainer> PFMuonFlowElementAssoc::m_NeutralFEmuon_nMatches_WriteDecorHandleKey {this,"FlowElementContainer_nMatchedMuons",m_neutralFEReadHandleKey,"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 78 of file PFMuonFlowElementAssoc.h.

78{this,"FlowElementContainer_nMatchedMuons",m_neutralFEReadHandleKey,"FE_nMatchedMuons","WriteHandleKey for the number of muons matched to a given neutral flow element"};

◆ m_NeutralFEmuonWriteHandleKey

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

private

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

Definition at line 69 of file PFMuonFlowElementAssoc.h.

69{this,"JetETMissNeutralFlowElementContainer_FE_MuonLinks",m_neutralFEReadHandleKey,"FE_MuonLinks","WriteHandleKey for neutral flow Elements to Muons"};

◆ m_neutralFEReadHandleKey

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

private

Definition at line 51 of file PFMuonFlowElementAssoc.h.

51{this,"JetEtMissNeutralFlowElementContainer","JetETMissNeutralParticleFlowObjects","ReadHandleKey for neutral FlowElements"};

◆ 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 93 of file PFMuonFlowElementAssoc.h.

93{this,"useMuonTopoClusters",false,"Toggle usage of linker of muon associated topoclusters to flow elements - false by default (EXPERIMENTAL)"};

◆ 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

◆ cardinality()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ doMuonCellMatching()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ initialize()

◆ inputHandles()

◆ isClonable()

◆ msg()

◆ 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