#include <CaloIsolationTool.h>

Inheritance diagram for xAOD::CaloIsolationTool:

Collaboration diagram for xAOD::CaloIsolationTool:

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

	~CaloIsolationTool (void)

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

virtual StatusCode	finalize () override

virtual bool	caloTopoClusterIsolation (CaloIsolation &result, const IParticle &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, const CaloClusterContainer *container=0) const override
	ICaloTopoClusterIsolationTool interface: More...

virtual bool	caloCellIsolation (CaloIsolation &result, const IParticle &particle, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, const CaloCellContainer *container=0) const override
	ICaloCellIsolationTool interface for cell isolation: The tool expects the cones to be order in decreasing order (etcone40 -> etcone20) Internally it reorders the cones so the output isolation values are also in the same order. More...

virtual bool	neutralEflowIsolation (CaloIsolation &result, const IParticle &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections) const override
	INeutralEFlowIsolationTool interface: More...

virtual bool	caloTopoClusterIsolation (CaloIsolation &result, const IParticle &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, const CaloClusterContainer *container=0) const=0
	ICaloTopoClusterIsolationTool interface for cluster isolation: The tool expects the cones to be order in decreasing order (topetcone40 -> topoetcone20) Internally it reorders the cones so the output isolation values are also in the same order. More...

virtual bool	caloCellIsolation (CaloIsolation &result, const IParticle &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, const CaloCellContainer *container=0) const=0
	ICaloCellIsolationTool interface for cell isolation: The tool expects the cones to be order in decreasing order (etcone40 -> etcone20) Internally it reorders the cones so the output isolation values are also in the same order. More...

virtual bool	neutralEflowIsolation (CaloIsolation &result, const IParticle &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections) const=0
	INeutralEFlowIsolationTool interface for eflow isolation: The tool expects the cones to be order in decreasing order (neflowiso40 -> neflowiso20) Internally it reorders the cones so the output isolation values are also in the same order. More...

virtual void	print () const =0
	Print the state of the tool. More...

virtual void	print () const
	Print the state of the tool. More...

ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	evtStore () const
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`. More...

const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`. More...

virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm. More...

virtual StatusCode	sysStart () override
	Handle START transition. More...

virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles. More...

virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles. More...

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

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
	Declare a new Gaudi property. More...

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, T &property, const std::string &doc="none")
	Declare a new Gaudi property. More...

void	updateVHKA (Gaudi::Details::PropertyBase &)

MsgStream &	msg () const

MsgStream &	msg (const MSG::Level lvl) const

bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
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 std::map< const IParticle , const IParticle >	derefMap_t
	map to the orignal particle More...

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
bool	caloCellIsolation (CaloIsolation &result, const Muon &muon, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, double coneCoreSize, const derefMap_t &derefMap) const
	cast for Muon (etcone muon) More...

bool	caloCellIsolation (CaloIsolation &result, const Egamma &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, const CaloCellContainer *container) const
	cast for egamma (etcone egamma) More...

bool	caloTopoClusterIsolation (CaloIsolation &result, const TrackParticle &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, const CaloClusterContainer *container, double coneCoreSize, derefMap_t &derefMap) const
	cast for TrackParticle (topoetcone muon) More...

bool	caloTopoClusterIsolation (CaloIsolation &result, const Egamma &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, const CaloClusterContainer *container, double coreConeSize) const
	cast for egamma (topoetcone egamma) More...

bool	neutralEflowIsolation (CaloIsolation &result, const Egamma &eg, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, double coneCoreSize) const
	cast for egamma (pflowetcone egamma) More...

bool	neutralEflowIsolation (CaloIsolation &result, const TrackParticle &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, double coneCoreSize, derefMap_t &derefMap) const
	cast for egamma (pflowetcone egamma) More...

bool	etConeIsolation (CaloIsolation &result, const TrackParticle &tp, const std::vector< Iso::IsolationType > &isoTypes, const CaloCellContainer *container, double coneCoreSize, const derefMap_t &derefMap) const

bool	etConeIsolation (CaloIsolation &result, const Muon &muon, const std::vector< Iso::IsolationType > &isoTypes, double coneCoreSize, const derefMap_t &derefMap) const

bool	etConeIsolation (CaloIsolation &result, const Egamma &eg, const std::vector< Iso::IsolationType > &isoTypes, const CaloCellContainer *container) const

bool	topoConeIsolation (CaloIsolation &result, float eta, float phi, std::vector< float > &coneSizes, bool coreEMonly, const CaloClusterContainer container, const CaloCluster fwdClus, const Egamma *egObj, double coneCoreSize) const

bool	topoClustCones (CaloIsolation &result, float eta, float phi, std::vector< float > &m_coneSizes, const std::vector< const CaloCluster * > &clusts) const
	Calculate isolation cones in topo clusters around eg. More...

bool	correctIsolationEnergy_TopoCore (CaloIsolation &result, float eta, float phi, float dEtaMax_core, float dPhiMax_core, float dR2Max_core, const std::vector< const CaloCluster * > &clusts, bool onlyEM, const CaloCluster fwdClus, const Egamma egObj) const
	Correct the topo cluster isolation using sum of topo cluster in core region. More...

bool	pflowConeIsolation (CaloIsolation &result, float eta, float phi, std::vector< float > &m_coneSizes, bool coreEMonly, const FlowElementContainer container, double coneCoreSize, const Egamma egObj=nullptr) const

bool	pflowObjCones (CaloIsolation &result, float eta, float phi, std::vector< float > &m_coneSizes, const std::vector< const FlowElement * > &clusts) const
	Calculate isolation cones in pflow objects around eg. More...

bool	correctIsolationEnergy_pflowCore (CaloIsolation &result, float eta, float phi, float detaMax, float dphiMax, float dR2Max, const std::vector< const FlowElement * > &clusts, bool onlyEM=false, const Egamma *egObj=nullptr) const
	Correct the pflow isolation using sum of pflow objects in core region. More...

bool	correctIsolationEnergy_Eeg57 (CaloIsolation &result, const std::vector< Iso::IsolationType > &isoTypes, const Egamma *eg) const

bool	correctIsolationEnergy_MuonCore (CaloIsolation &result, const TrackParticle &tp, const derefMap_t &derefMap) const

bool	GetExtrapEtaPhi (const TrackParticle *tp, float &eta, float &phi, derefMap_t &derefMap) const

bool	PtCorrection (CaloIsolation &result, const Egamma &eg, const std::vector< Iso::IsolationType > &isoTypes) const

bool	EDCorrection (CaloIsolation &result, const std::vector< Iso::IsolationType > &isoTypes, float eta, const std::string &type, const CaloCluster *fwdClus) const

const IParticle *	getReferenceParticle (const IParticle &particle) const
	get reference particle More...

void	decorateTrackCaloPosition (const IParticle &particle, float eta, float phi) const

float	Phi_mpi_pi (float x) const

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
	specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
	specialization for handling Gaudi::Property<SG::VarHandleBase> More...

Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
	specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...

Static Private Member Functions
static void	initresult (CaloIsolation &result, const CaloCorrection &corrlist, unsigned int typesize)

Private Attributes
ToolHandle< Rec::IParticleCaloCellAssociationTool >	m_assoTool

ToolHandle< Trk::IParticleCaloExtensionTool >	m_caloExtTool

Trk::TrackParametersIdHelper	m_parsIdHelper

ToolHandle< ICaloClustersInConeTool >	m_clustersInConeTool

ToolHandle< IFlowElementsInConeTool >	m_pflowObjectsInConeTool

ToolHandle< CaloClusterProcessor >	m_caloFillRectangularTool
	Property: calo cluster filling tool. More...

Gaudi::Property< bool >	m_useCaloExtensionCaching
	Property: Use cached caloExtension if avaliable. More...

SG::ReadHandleKey< CaloExtensionCollection >	m_caloExtensionKey
	The input calorimeter extensions. More...

SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}
	CaloDetDescrManager from ConditionStore. More...

ToolHandle< CP::IIsolationCorrectionTool >	m_IsoLeakCorrectionTool
	Tool for pt-corrected isolation calculation (new) More...

Gaudi::Property< std::vector< int > >	m_EMCaloNums
	vector of calo-id to treat More...

Gaudi::Property< std::vector< int > >	m_HadCaloNums
	vector of calo-id to treat More...

std::string	m_CaloCalTopoCluster
	Topo Calo cluster location in event store. More...

Gaudi::Property< bool >	m_useEMScale
	Property: Use TopoClusters at the EM scale. More...

Gaudi::Property< bool >	m_doEnergyDensityCorrection
	Property: do the ED corrections to topoisolation. More...

Gaudi::Property< bool >	m_saveOnlyRequestedCorrections
	Property: save only requested corrections (trigger usage mainly) More...

Gaudi::Property< bool >	m_ExcludeTG3
	Property: exclude tile scintillator. More...

SG::ReadHandleKey< EventShape >	m_tpEDCentral
	Property: Name of the central topocluster energy-density container. More...

SG::ReadHandleKey< EventShape >	m_tpEDForward
	Property: Name of the forward topocluster energy-density container. More...

SG::ReadHandleKey< EventShape >	m_efEDCentral
	Property: Name of the central neutral energy flow energy-density container. More...

SG::ReadHandleKey< EventShape >	m_efEDForward
	Property: Name of the forward neutral energy flow energy-density container. More...

Gaudi::Property< double >	m_coneCoreSizeEg
	Property: The size of the coneCore core energy calculation. More...

Gaudi::Property< double >	m_coneCoreSizeMu

std::map< const IParticle , const IParticle >	m_derefMap
	map to the orignal particle More...

Gaudi::Property< bool >	m_InitializeReadHandles
	Property: Initialize read Handles. More...

Gaudi::Property< bool >	m_isMC {this, "isMC", false, "is MC"}
	Property: need to know if this is MC (from rec.doTruth) for eta dep pileup corr. More...

Gaudi::Property< bool >	m_useEtaDepPU
	Property: use pileup dependent correction. More...

Gaudi::Property< std::string >	m_puZetaCorrectionFileName
	name of the root file for the eta dependant pileup correction More...

Gaudi::Property< std::string >	m_puZetaMCCorrectionFileName

std::map< Iso::IsolationType, std::unique_ptr< TGraph > >	m_puZetaCorrection
	map of the zeta corrections (one / cone size) More...

std::map< Iso::IsolationType, std::unique_ptr< TGraph > >	m_puZetaMCCorrection

StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default) More...

StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default) More...

std::vector< SG::VarHandleKeyArray * >	m_vhka

bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 49 of file CaloIsolationTool.h.

Member Typedef Documentation

◆ derefMap_t

typedef std::map<const IParticle*, const IParticle*> xAOD::CaloIsolationTool::derefMap_t

private

map to the orignal particle

Definition at line 96 of file CaloIsolationTool.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CaloIsolationTool()

xAOD::CaloIsolationTool::CaloIsolationTool ( const std::string & name )

Definition at line 55 of file CaloIsolationTool.cxx.

                                                             :
         asg::AsgTool(name)
   {
 #ifndef XAOD_ANALYSIS
     declareInterface<ICaloCellIsolationTool>(this);
     declareInterface<ICaloTopoClusterIsolationTool>(this);
     declareInterface<INeutralEFlowIsolationTool>(this);
 #endif // XAOD_ANALYSIS
   }

◆ ~CaloIsolationTool()

xAOD::CaloIsolationTool::~CaloIsolationTool ( void )

default

Member Function Documentation

◆ caloCellIsolation() [1/4]

bool xAOD::CaloIsolationTool::caloCellIsolation	(	CaloIsolation &	result,
		const Egamma &	tp,
		const std::vector< Iso::IsolationType > &	cones,
		const CaloCorrection &	corrections,
		const CaloCellContainer *	container
	)		const

private

cast for egamma (etcone egamma)

Definition at line 307 of file CaloIsolationTool.cxx.

                                 {
     if( isoTypes.empty() ) {
       ATH_MSG_WARNING("Empty list passed, failing calculation");
       return false;
     }
  
     unsigned int typesize = isoTypes.size();
     initresult(result, corrlist, typesize);
  
     std::vector<float> coneSizes;
     coneSizes.resize(isoTypes.size());
     for (unsigned int is = 0; is < isoTypes.size(); is++)
       coneSizes[is] = Iso::coneSize(isoTypes[is]);
  
     // get cones
     Iso::IsolationFlavour theFlavour = Iso::isolationFlavour(isoTypes.front());
  
     if (theFlavour == Iso::etcone){
 #ifndef XAOD_ANALYSIS
       etConeIsolation(result, eg, isoTypes, container);
 #else
       return true;
 #endif
     }else{
       ATH_MSG_WARNING("Unsupported isolation flavour passed, cannot calculate isolation " << static_cast<int>(theFlavour));
       return false;
     }
  
     // Apply corrections
     // core energy subtraction
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::core57cells))) {
       if (!correctIsolationEnergy_Eeg57(result,isoTypes,&eg))
         ATH_MSG_WARNING("Could not compute core cell energy for egamma in etcone");
     }
  
     // leakage correction
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::ptCorrection))) {
       if (!PtCorrection(result, eg, isoTypes))
         ATH_MSG_WARNING("Could not apply pt correction to etcone isolation");
     }
  
     return true;
   }

◆ caloCellIsolation() [2/4]

bool xAOD::CaloIsolationTool::caloCellIsolation	(	CaloIsolation &	result,
		const IParticle &	tp,
		const std::vector< Iso::IsolationType > &	cones,
		const CaloCorrection &	corrections,
		const CaloCellContainer *	container = `0`
	)		const

overridevirtual

ICaloCellIsolationTool interface for cell isolation: The tool expects the cones to be order in decreasing order (etcone40 -> etcone20) Internally it reorders the cones so the output isolation values are also in the same order.

Parameters

[in]	result	output object to be filled
[in]	tp	input iparticle
[in]	cones	vector of input cones to be used
[in]	corrections	bitset specifying which corrections to apply to isolation
[in]	container	cell contrainer (for trigger only)

Returns: true if the calculation was successfull

get track particle

Implements xAOD::ICaloCellIsolationTool.

Definition at line 161 of file CaloIsolationTool.cxx.

                                                       {
 #ifdef XAOD_ANALYSIS
    (void) result;
    (void) particle;
    (void) cones;
    (void) corrlist;
    (void) container;
     return false;
 #else // XAOD_ANALYSIS
     derefMap_t derefMap;
     const IParticle* ip = getReferenceParticle(particle);
     if( !ip ){
       ATH_MSG_WARNING("Failed to obtain reference particle");
       return false;
     }
     derefMap[ip] = &particle;
  
     double coneCoreSize = m_coneCoreSizeEg;
     if (particle.type() == Type::Muon)
       coneCoreSize = m_coneCoreSizeMu;
  
     // muon etcone isolation
     const Muon* muon = dynamic_cast<const Muon*>(&particle);
     if(muon) return caloCellIsolation(result,*muon,cones,corrlist,coneCoreSize,derefMap);
  
     // egamma etcone isolation
     const Egamma* egam = dynamic_cast<const Egamma*>(ip);
     if( egam ) return caloCellIsolation(result,*egam,cones,corrlist,container);
  
     ATH_MSG_WARNING("CaloCellIsolation only supported for Muons and Egamma");
  
     return true;
 #endif // not XAOD_ANALYSIS
   }

◆ caloCellIsolation() [3/4]

virtual bool xAOD::ICaloCellIsolationTool::caloCellIsolation

ICaloCellIsolationTool interface for cell isolation: The tool expects the cones to be order in decreasing order (etcone40 -> etcone20) Internally it reorders the cones so the output isolation values are also in the same order.

Parameters

[in]	result	output object to be filled
[in]	tp	input iparticle
[in]	cones	vector of input cones to be used
[in]	corrections	bitset specifying which corrections to apply to isolation
[in]	container	cell contrainer (for trigger only)

Returns: true if the calculation was successfull

◆ caloCellIsolation() [4/4]

bool xAOD::CaloIsolationTool::caloCellIsolation	(	CaloIsolation &	result,
		const Muon &	muon,
		const std::vector< Iso::IsolationType > &	cones,
		const CaloCorrection &	corrections,
		double	coneCoreSize,
		const derefMap_t &	derefMap
	)		const

private

cast for Muon (etcone muon)

Definition at line 272 of file CaloIsolationTool.cxx.

                                  {
     if( isoTypes.empty() ) {
       ATH_MSG_WARNING("Empty list passed, failing calculation");
       return false;
     }
  
     unsigned int typesize = isoTypes.size();
     initresult(result, corrlist, typesize);
  
     // get cones
     Iso::IsolationFlavour theFlavour = Iso::isolationFlavour(isoTypes.front());
  
     if (theFlavour == Iso::etcone)
 #ifndef XAOD_ANALYSIS
       return etConeIsolation(result, muon, isoTypes, coneCoreSize, derefMap);
 #else
     return true;
 #endif
  
     ATH_MSG_WARNING("Unsupported isolation flavour passed, cannot calculate isolation " <<
                     static_cast<int>(theFlavour));
  
     return false;
   }

◆ caloTopoClusterIsolation() [1/4]

bool xAOD::CaloIsolationTool::caloTopoClusterIsolation	(	CaloIsolation &	result,
		const Egamma &	tp,
		const std::vector< Iso::IsolationType > &	cones,
		const CaloCorrection &	corrections,
		const CaloClusterContainer *	container,
		double	coreConeSize
	)		const

private

cast for egamma (topoetcone egamma)

Definition at line 358 of file CaloIsolationTool.cxx.

   {
  
     if( isoTypes.empty() ) {
       ATH_MSG_WARNING("Empty list passed, failing calculation");
       return false;
     }
  
     unsigned int typesize = isoTypes.size();
     initresult(result, corrlist, typesize);
  
     std::vector<float> coneSizes;
     coneSizes.reserve(isoTypes.size());
  
     for( auto isoType : isoTypes ){
       coneSizes.push_back(Iso::coneSize(isoType));
     }
  
     float phi = eg.caloCluster()->phi();
     float eta = eg.caloCluster()->eta();
  
     const CaloCluster* fwdClus = eg.author(xAOD::EgammaParameters::AuthorFwdElectron) ? eg.caloCluster() : nullptr;
  
     if (!topoConeIsolation(result, eta, phi, coneSizes, true, container, fwdClus, &eg, coneCoreSize)) {
       ATH_MSG_WARNING("topoConeIsolation failed for egamma");
       return false;
     }
  
     // 5x7 : no meaning for fwd electron
     if (fwdClus == nullptr && (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::core57cells)))) {
       // Apply core energy subtraction
       if (!correctIsolationEnergy_Eeg57(result,isoTypes,&eg))
         ATH_MSG_WARNING("Could not compute core cell energy for egamma in topoetcone");
     }
  
     // leakage : at least for the time being, no meaning for fwd electron
     if ((!m_saveOnlyRequestedCorrections && fwdClus == nullptr) || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::ptCorrection))) {
       // do pt correction
       if (!PtCorrection(result, eg, isoTypes))
         ATH_MSG_WARNING("Could not apply pt correction to topoetcone isolation");
     }
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::pileupCorrection))) {
       // do pile-up correction
       if (!EDCorrection(result,isoTypes,eta,"topo",fwdClus))
         ATH_MSG_WARNING("Could not apply ED correction to topo isolation");
     }
  
     return true;
  
   }

◆ caloTopoClusterIsolation() [2/4]

bool xAOD::CaloIsolationTool::caloTopoClusterIsolation	(	CaloIsolation &	result,
		const IParticle &	tp,
		const std::vector< Iso::IsolationType > &	cones,
		const CaloCorrection &	corrections,
		const CaloClusterContainer *	container = `0`
	)		const

overridevirtual

ICaloTopoClusterIsolationTool interface:

get track particle

Implements xAOD::ICaloTopoClusterIsolationTool.

Definition at line 201 of file CaloIsolationTool.cxx.

                                                                           {
  
     if ( cones.empty() ) {
       ATH_MSG_DEBUG("No isolation required");
       return false;
     }
  
     double coneCoreSize = m_coneCoreSizeEg;
     if (particle.type() == Type::Muon)
       coneCoreSize = m_coneCoreSizeMu;
  
     derefMap_t derefMap;
     const IParticle* ip = getReferenceParticle(particle);
     if( !ip ){
       ATH_MSG_WARNING("Failed to obtain reference particle");
       return false;
     }
     derefMap[ip] = &particle;
  
     // muon topoetcone isolation
     const TrackParticle* trkp = dynamic_cast<const TrackParticle*>(ip);
     if( trkp ) return caloTopoClusterIsolation(result,*trkp,cones,corrlist,container,coneCoreSize,derefMap);
  
     // egamma topoetcone isolation
     const Egamma* egam = dynamic_cast<const Egamma*>(ip);
     if( egam ) return caloTopoClusterIsolation(result,*egam,cones,corrlist,container, coneCoreSize);
  
     ATH_MSG_WARNING("CaloTopoClusterIsolation only supported for TrackParticles and Egamma");
  
     return true;
   }

◆ caloTopoClusterIsolation() [3/4]

virtual bool xAOD::ICaloTopoClusterIsolationTool::caloTopoClusterIsolation

ICaloTopoClusterIsolationTool interface for cluster isolation: The tool expects the cones to be order in decreasing order (topetcone40 -> topoetcone20) Internally it reorders the cones so the output isolation values are also in the same order.

Parameters

[in]	result	output object to be filled
[in]	tp	input iparticle
[in]	cones	vector of input cones to be used
[in]	corrections	bitset specifying which corrections to apply to isolation
[in]	container	topo cluster container (for trigger only)

Returns: true if the calculation was successful

◆ caloTopoClusterIsolation() [4/4]

bool xAOD::CaloIsolationTool::caloTopoClusterIsolation	(	CaloIsolation &	result,
		const TrackParticle &	tp,
		const std::vector< Iso::IsolationType > &	cones,
		const CaloCorrection &	corrections,
		const CaloClusterContainer *	container,
		double	coneCoreSize,
		derefMap_t &	derefMap
	)		const

private

cast for TrackParticle (topoetcone muon)

Definition at line 629 of file CaloIsolationTool.cxx.

                                                                                {
     if( isoTypes.empty() ) {
       ATH_MSG_WARNING("Empty list passed, failing calculation");
       return false;
     }
  
     unsigned int typesize = isoTypes.size();
     initresult(result, corrlist, typesize);
     std::vector<float> coneSizes;
     coneSizes.reserve(isoTypes.size());
  
 for( auto isoType : isoTypes ){
       coneSizes.push_back(Iso::coneSize(isoType));
     }
  
     float phi = tp.phi();
     float eta = tp.eta();
     if(!GetExtrapEtaPhi(&tp,eta,phi,derefMap)) ATH_MSG_WARNING("TrackParticle eta = " << tp.eta() << ", phi = " << tp.phi() << " not updated from extraplation!");
     ATH_MSG_DEBUG("TrackParticle eta = " << tp.eta() << ", phi = " << tp.phi() << ", extrap eta = " << eta << ", phi = " << phi);
  
     // get energy in cones
     if (!topoConeIsolation(result, eta, phi, coneSizes, false, container, nullptr, nullptr, coneCoreSize)) {
       ATH_MSG_WARNING("Could not compute topo isolation for muons");
       return false;
     }
  
     // core energy subtraction
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreMuon))) {
       if (!correctIsolationEnergy_MuonCore(result, tp, derefMap))
     ATH_MSG_WARNING("Could not compute muon core energy (cells) from topoetcone");
     }
  
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::pileupCorrection))) {
       if (!EDCorrection(result,isoTypes,eta,"topo",nullptr))
     ATH_MSG_WARNING("Could not apply ED correction to topo isolation");
     }
  
     return true;
   }

◆ correctIsolationEnergy_Eeg57()

bool xAOD::CaloIsolationTool::correctIsolationEnergy_Eeg57	(	CaloIsolation &	result,
		const std::vector< Iso::IsolationType > &	isoTypes,
		const Egamma *	eg
	)		const

private

Definition at line 1123 of file CaloIsolationTool.cxx.

   {
  
     float coreV = 0;
     bool gotIso = eg->isolationCaloCorrection(coreV,Iso::etcone, Iso::core57cells, Iso::coreEnergy);
     if (gotIso)
       ATH_MSG_DEBUG("core57cells available = " << coreV);
     else
       ATH_MSG_DEBUG("core57cells not available");
     if ((gotIso && fabs(coreV) < 1e-3) || !gotIso) {
 #ifndef XAOD_ANALYSIS
       const CaloCluster *cleg = eg->caloCluster();
       // now correct the isolation energy for the core cluster energy
       float eraw57=0., eta=0.;
  
       if(cleg && cleg->getCellLinks()){
     double seedEta = cleg->eta0(), seedPhi = cleg->phi0();
         std::unique_ptr<CaloCluster> egcCloneFor57 = CaloClusterStoreHelper::makeCluster(cleg->getCellLinks()->getCellContainer(),
                                              seedEta,seedPhi,
                                              cleg->clusterSize());
  
     if (!m_caloFillRectangularTool->execute (Gaudi::Hive::currentContext(),
                                                  egcCloneFor57.get()).isSuccess())
         {
           return false;
     }
     if(egcCloneFor57->size()==0){
       ATH_MSG_WARNING("Size of Created Cluster is 0 aka no cells");
       return false;
     }
  
     eraw57 = egcCloneFor57->e();
     eta    = cleg->eta(); //FillRectangularCluster doesn't recalculated the overall cluster eta (only per-sampling)
     coreV  = eraw57/cosh(eta);
     ATH_MSG_DEBUG("Number of cells in 5x7 " << egcCloneFor57->size()
               << " seed eta,phi " << cleg->eta0() << " " << cleg->phi0()
               << " eraw = " << eraw57 << " etraw = " << coreV
               );
      }
 #else
      return false;
 #endif // XAOD_ANALYSIS
     }
  
     std::map<Iso::IsolationCorrectionParameter,float> corecorr;
     corecorr[Iso::coreEnergy] = coreV;
     corecorr[Iso::coreArea]   = 5*0.025*7*TMath::Pi()/128;
     result.coreCorrections[Iso::core57cells] = corecorr;
     if (result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::core57cells))) {
       for (unsigned int i = 0; i < isoTypes.size(); i++){
     result.etcones[i] -= coreV;
       }
     }
  
     return true;
   }

◆ correctIsolationEnergy_MuonCore()

bool xAOD::CaloIsolationTool::correctIsolationEnergy_MuonCore	(	CaloIsolation &	result,
		const TrackParticle &	tp,
		const derefMap_t &	derefMap
	)		const

private

Definition at line 1438 of file CaloIsolationTool.cxx.

                                                                                              {
  
     ATH_MSG_DEBUG("in  CaloIsolationTool::correctIsolationEnergy_MuonCore ");
  
     // initialize varialbes
     double ecore = 0.;
     auto muI = derefMap.find(&tp);
     static const SG::ConstAccessor<float> ET_CoreAcc ("ET_Core");
     if(muI!=derefMap.end()){
       ecore = ET_CoreAcc.withDefault (*muI->second, 0);
     }else{
       ATH_MSG_WARNING("ET_Core of muon not found! coreMuon isolation correction will not be applied!!!");
       return false;
     }
  
     std::map<Iso::IsolationCorrectionParameter,float> corecorr;
     corecorr[Iso::coreEnergy] = ecore;
     corecorr[Iso::coreArea]   = 0;
     result.coreCorrections[Iso::coreMuon] = corecorr;
  
     if (result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreMuon))) {
       for( unsigned int i=0;i<result.etcones.size();++i ) {
     result.etcones[i] -= ecore;
     ATH_MSG_DEBUG("MuonCore i=" << i << " cone [before] " << result.etcones[i]+ecore << " cone [after] " << result.etcones[i]);
       }
     }
  
     return true;
   }

◆ correctIsolationEnergy_pflowCore()

bool xAOD::CaloIsolationTool::correctIsolationEnergy_pflowCore	(	CaloIsolation &	result,
		float	eta,
		float	phi,
		float	detaMax,
		float	dphiMax,
		float	dR2Max,
		const std::vector< const FlowElement * > &	clusts,
		bool	onlyEM = `false`,
		const Egamma *	egObj = `nullptr`
	)		const

private

Correct the pflow isolation using sum of pflow objects in core region.

get energy

add to the core

get energy

add to the core

set results

Definition at line 1327 of file CaloIsolationTool.cxx.

   {
  
     float pflowCore(0.);
     for (const FlowElement* cl : clusts) {
       ATH_MSG_DEBUG("pflo: eta " << cl->eta() << " phi " << cl->phi() << " pt " << cl->pt() << " charge " << cl->charge());
       float dphi = Phi_mpi_pi(cl->phi()-phi);
       if (detaMax > 0 && fabs(dphi) > dphiMax) continue;
       float deta = cl->eta()-eta;
       if (dphiMax > 0 && fabs(deta) > detaMax) continue;
       if (dR2Max > 0 && dphi*dphi+deta*deta > dR2Max) continue;
  
       float et = cl->pt();
       if (et <= 0 || fabs(cl->eta()) > 7.0) continue;
  
       double emfrac = 1.;
       if (onlyEM) {
     const xAOD::CaloCluster *ocl = dynamic_cast<const xAOD::CaloCluster*>(cl->otherObject(0));
     if(ocl) {
       double eEM = ocl->energyBE(0)+ocl->energyBE(1)+ocl->energyBE(2)+ocl->energyBE(3);
       emfrac     = std::min(1.,eEM / cl->e());
     }
       }
       et *= emfrac;
  
       pflowCore += et;
       ATH_MSG_DEBUG("pflow to be added to core: et = " << et << " (em frac = " << emfrac << "), total = " << pflowCore);
     }
  
     if (egObj) {
       float pflowCoreSC(0.);
       // These are the original FE, before origin correction, before CSSK... But the index should still match
       // for the corresponding FE in the post-processed container
       std::vector<const xAOD::FlowElement*> fes = EgammaHelpers::getAssociatedFlowElements(egObj);
       ATH_MSG_DEBUG("Number of associated neutral FE = " << fes.size());
       for (const FlowElement *fe : fes) {
     if (fe == nullptr) {
       ATH_MSG_DEBUG("null pointer to associated neutral");
       continue;
     }
     ATH_MSG_DEBUG("asso pflo: eta " << fe->eta() << " phi " << fe->phi() << " pt " << fe->pt() << " charge " << fe->charge() << " index = " << fe->index());
     const FlowElement *afe(nullptr);
     for (const FlowElement *cl : clusts) {
       if (fe->index() == cl->index()) {
         afe = cl;
         break;
       }
     }
     if (afe == nullptr)
       continue;
     ATH_MSG_DEBUG("asso pflo after vertex correction : eta " << afe->eta() << " phi " << afe->phi() << " pt " << afe->pt());
     float et = afe->pt();
     if (et <= 0 || fabs(afe->eta()) > 7.0) continue;
  
     double emfrac = 1.;
     if (m_ExcludeTG3 || onlyEM) {
       std::vector<float> allEne = FEHelpers::getEnergiesPerSampling(*afe);
  
       if (m_ExcludeTG3)
         et -= allEne.at(17)/cosh(afe->eta());
  
       if (onlyEM) {
         double eEM = 0;
         for (int i = 0; i <= 7; i++) eEM += allEne.at(i);
         double eAll = fe->e();
         if (m_ExcludeTG3)
           eAll -= allEne.at(17);
         emfrac = std::min(1.,eEM / eAll);
       }
       et *= emfrac;
     }
     pflowCoreSC += et;
     ATH_MSG_DEBUG("asso pflow to be added to core " << fe << " et = " << et << " (em frac = " << emfrac << "), total = " << pflowCoreSC);
       }
       std::map<Iso::IsolationCorrectionParameter,float> corecorrSC;
       corecorrSC[Iso::coreEnergy] = pflowCoreSC;
       corecorrSC[Iso::coreArea]   = 0;
       result.coreCorrections[Iso::coreConeSC] = corecorrSC;
     }
  
     float areacore = -999.;
     if      (detaMax > 0 && dphiMax > 0) areacore = 4*detaMax*dphiMax;
     else if (dR2Max > 0)                 areacore = M_PI*dR2Max;
  
     std::map<Iso::IsolationCorrectionParameter,float> corecorr;
     corecorr[Iso::coreEnergy] = pflowCore;
     corecorr[Iso::coreArea]   = areacore;
     result.coreCorrections[Iso::coreCone] = corecorr;
  
     if (result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone))) {
       for (unsigned int i = 0; i < result.etcones.size(); i++) {
     ATH_MSG_DEBUG("pflow, cone type " << i << ", in cone " << result.etcones[i] << ", subtracted " << result.etcones[i]-pflowCore);
     result.etcones[i] -= pflowCore;
       }
     }
  
     return true;
   }

◆ correctIsolationEnergy_TopoCore()

bool xAOD::CaloIsolationTool::correctIsolationEnergy_TopoCore	(	CaloIsolation &	result,
		float	eta,
		float	phi,
		float	dEtaMax_core,
		float	dPhiMax_core,
		float	dR2Max_core,
		const std::vector< const CaloCluster * > &	clusts,
		bool	onlyEM,
		const CaloCluster *	fwdClus,
		const Egamma *	egObj
	)		const

private

Correct the topo cluster isolation using sum of topo cluster in core region.

check distance

get enenrgy

remove TileGap3

if only EM

add to the core

remove TileGap3

if only EM

Definition at line 1183 of file CaloIsolationTool.cxx.

   {
     ATH_MSG_DEBUG("In CaloIsolationTool::correctIsolationEnergy_TopoCore");
     ATH_MSG_DEBUG("particle: eta " << eta << " phi " << phi);
  
  
     // I do not remember why I put areacore = 0 for fwdClus !!
     float areacore = -999.;
     if (fwdClus == nullptr) {
       if (dEtaMax_core>0 && dPhiMax_core>0) areacore = 4*dEtaMax_core*dPhiMax_core;
       else if (dR2Max_core>0) areacore = M_PI*dR2Max_core;
     } else
       areacore = 0;
  
     double topoCore(0.);
     if (fwdClus) {
       topoCore = fwdClus->p4(CaloCluster::State::UNCALIBRATED).Et();
       ATH_MSG_DEBUG("Including " << topoCore << " in the core transverse energy of the fwd electron");
     } else {
       for (const CaloCluster* cl : clusts) {
     ATH_MSG_DEBUG("cl: eta " << cl->eta() << " phi " << cl->phi()
               << " E " << cl->p4(CaloCluster::State::UNCALIBRATED).E()
               << " pt " << cl->p4(CaloCluster::State::UNCALIBRATED).Et()
               << " cal E " << cl->e());
     float dPhi = Phi_mpi_pi(cl->phi()-phi);
     if(dEtaMax_core>0 && fabs(dPhi) > dPhiMax_core) continue;
     float dEta = cl->eta()-eta;
     if(dPhiMax_core>0 && fabs(dEta) > dEtaMax_core) continue;
     if(dR2Max_core>0 && dPhi*dPhi+dEta*dEta > dR2Max_core) continue;
     ATH_MSG_DEBUG("dist: dPhi " << dPhi << " dEta " << dEta << " dR2 " << dPhi*dPhi+dEta*dEta);
  
     float et = (m_useEMScale ? cl->p4(CaloCluster::State::UNCALIBRATED).Et() : cl->pt() );
     if(et <= 0 || fabs(cl->eta()) > 7.0) continue;
  
     double ettg3 = cl->eSample(CaloSampling::TileGap3)/cosh(cl->p4(CaloCluster::State::UNCALIBRATED).Eta());
     et -= ettg3;
     if (fabs(ettg3) > 1)
       ATH_MSG_DEBUG("After TG3 removal, pt = " << et);
  
     double emfrac = 1.;
     if(onlyEM){
       double eEM = cl->energyBE(0)+cl->energyBE(1)+cl->energyBE(2)+cl->energyBE(3);
       emfrac     = std::min(1., eEM / cl->p4(CaloCluster::State::UNCALIBRATED).E());
     }
     et *= emfrac;
  
     topoCore += et;
     ATH_MSG_DEBUG("adding in core et: " << et << " (em frac = " << emfrac << " dR = " << sqrt(dPhi*dPhi+dEta*dEta) << ") total " << topoCore);
       }
     }
  
     double topoCoreSC(0.);
     double test         = 0;
     double topoCoreSCem = 0;
     if (egObj && egObj->caloCluster()->clusterSize() == CaloCluster::ClusterSize::SuperCluster) {
       const std::vector<const CaloCluster*> assocClus = EgammaHelpers::getAssociatedTopoClusters(egObj->caloCluster());
       for (unsigned int ic = 0; ic < assocClus.size(); ic++) {
     const CaloCluster* cl = assocClus.at(ic);
     test       += cl->pt();
     topoCoreSC += cl->p4(CaloCluster::State::UNCALIBRATED).Et();
     ATH_MSG_DEBUG("Adding topo " << ic << " ptr = " << cl << " contrib, pt = " << cl->pt()
               << " uncal pt = " << cl->p4(CaloCluster::State::UNCALIBRATED).Et()
               << " eta,phi = " << cl->eta() << " " << cl->phi()
               << " uncal eta,phi = " << cl->p4(CaloCluster::State::UNCALIBRATED).Eta()
               << " " << cl->p4(CaloCluster::State::UNCALIBRATED).Phi()
               << " nCells = " << cluster_size(cl)
                       );
  
     double ettg3 = cl->eSample(CaloSampling::TileGap3)/cosh(cl->p4(CaloCluster::State::UNCALIBRATED).Eta());
     topoCoreSCem -= ettg3;
  
     double emfrac = 1.;
     if(onlyEM){
       double eEM = cl->energyBE(0)+cl->energyBE(1)+cl->energyBE(2)+cl->energyBE(3);
       emfrac     = std::min(1., eEM / cl->p4(CaloCluster::State::UNCALIBRATED).E());
     }
     topoCoreSCem += emfrac*cl->p4(CaloCluster::State::UNCALIBRATED).Et();
  
     //auto itc = assocClus.at(ic)->begin();
     //for (; itc != assocClus.at(ic)->end(); itc++)
     //  std::cout << "A cell " << (*itc) << " eta = " << (*itc)->eta() << std::endl;
       }
       ATH_MSG_DEBUG("Including " << topoCore << " only em, no tg3 " << topoCoreSCem << " calibrated " << test << " in the core transverse energy of the super cluster egamma object made of "
             << assocClus.size() << " clusters with corresponding pT = " << egObj->pt()
             << " cluster pT = " << egObj->caloCluster()->pt() << " cluster un cal pT = "
             << egObj->caloCluster()->p4(CaloCluster::State::UNCALIBRATED).Et()
             << " nCells = " << cluster_size(egObj->caloCluster())
                     );
       //auto itc = egObj->caloCluster()->begin();
       //for (; itc != egObj->caloCluster()->end(); itc++)
       //std::cout << "A cell in the SC " << (*itc) << " eta = " << (*itc)->eta() << std::endl;
  
       std::map<Iso::IsolationCorrectionParameter,float> corecorrSC;
       corecorrSC[Iso::coreEnergy] = topoCoreSCem;
       corecorrSC[Iso::coreArea]   = areacore;
       result.coreCorrections[Iso::coreConeSC] = corecorrSC;
  
     }
  
     ATH_MSG_DEBUG("core energy, std = " << topoCore << " topo-assoc (full) = " << topoCoreSC << " topo-assoc (only em, no tg3) = " << topoCoreSCem);
  
     std::map<Iso::IsolationCorrectionParameter,float> corecorr;
     corecorr[Iso::coreEnergy] = topoCore;
     corecorr[Iso::coreArea]   = areacore;
     result.coreCorrections[Iso::coreCone] = corecorr;
  
     float toSub = 0;
     bool  doSub = false;
     if (result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone)) ||
     result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreConeSC))) {
       doSub = true;
       if (result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone)) &&
       !result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreConeSC)))
     toSub = topoCore;
       else if (!result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone)) &&
            result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreConeSC)))
     toSub = topoCoreSCem;
       else {
     ATH_MSG_WARNING("Cannot do two core subtraction ! Using coreCone");
     toSub = topoCore;
       }
     }
  
     if (doSub) {
       for (unsigned int i = 0; i < result.etcones.size(); i++){
     result.etcones[i] -= toSub;
     ATH_MSG_DEBUG("TopoCore correction i=" << i << " cone [before] " << result.etcones[i]+toSub << " cone [after] " << result.etcones[i]);
       }
     }
  
     return true;
   }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyArrayType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleKeyType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	hndl,
		const SG::VarHandleType &
	)

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty	(	Gaudi::Property< T > &	t,
		const SG::NotHandleType &
	)

inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleBase &	hndl,
		const std::string &	doc,
		const SG::VarHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKey &	hndl,
		const std::string &	doc,
		const SG::VarHandleKeyType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
hndl	Object holding the property value.
doc	Documentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		SG::VarHandleKeyArray &	hndArr,
		const std::string &	doc,
		const SG::VarHandleKeyArrayType &
	)

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc,
		const SG::NotHandleType &
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty	(	const std::string &	name,
		T &	property,
		const std::string &	doc = `"none"`
	)

inlineinherited

Declare a new Gaudi property.

Parameters

name	Name of the property.
property	Object holding the property value.
doc	Documentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ decorateTrackCaloPosition()

void xAOD::CaloIsolationTool::decorateTrackCaloPosition	(	const IParticle &	particle,
		float	eta,
		float	phi
	)		const

private

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ EDCorrection()

bool xAOD::CaloIsolationTool::EDCorrection	(	CaloIsolation &	result,
		const std::vector< Iso::IsolationType > &	isoTypes,
		float	eta,
		const std::string &	type,
		const CaloCluster *	fwdClus
	)		const

private

Definition at line 1500 of file CaloIsolationTool.cxx.

   {
     std::vector<float> corrvec;
     corrvec.resize(isoTypes.size(),0.);
  
     // assume two densities for the time being
     const SG::ReadHandleKey<EventShape>* esKey = (fabs(eta) < 1.5 || m_useEtaDepPU) ? &m_tpEDCentral : &m_tpEDForward;
     if (type == "PFlow") {
       esKey = (fabs(eta) < 1.5) ? &m_efEDCentral : &m_efEDForward;
     } else if (fwdClus != nullptr) {
       ATH_MSG_DEBUG("No pileup correction for forward electron isolation yet");
       result.noncoreCorrections[Iso::pileupCorrection] = corrvec;
       return true;
     }
  
     SG::ReadHandle<EventShape> edShape(*esKey);
     // check is only used for serial running; remove when MT scheduler used
     if(!edShape.isValid()) {
       ATH_MSG_FATAL("Failed to retrieve "<< esKey->key());
       return false;
     }
  
     double rho = 0;
     bool gotDensity = edShape->getDensity(EventShape::Density,rho);
     if (!gotDensity) {
       ATH_MSG_WARNING("Cannot retrieve density " << esKey->key() << " for isolation correction. No ED correction");
       return false;
     }
  
     // Get the core size
     float areacore = 0;
     std::map<xAOD::Iso::IsolationCorrectionParameter,float> ecore;
     if(result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreMuon))){
       ecore = result.coreCorrections.find(Iso::coreMuon)->second;
     }else if(result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::core57cells))){
       ecore = result.coreCorrections.find(Iso::core57cells)->second;
     }else if(result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone))){
       ecore = result.coreCorrections.find(Iso::coreCone)->second;
     }
  
     auto iter = ecore.find(xAOD::Iso::coreArea);
     if (iter != ecore.end())
       areacore = ecore.find(xAOD::Iso::coreArea)->second;
  
     for (unsigned int i = 0; i < isoTypes.size(); i++) {
       float dR    = Iso::coneSize(isoTypes.at(i));
       float toSub = rho*(dR*dR*M_PI - areacore);
       // The improved PU correction is only for central EGamma objects, and topoetcone
       if (m_useEtaDepPU && fwdClus == nullptr && Iso::isolationFlavour(isoTypes.at(i)) == Iso::topoetcone) {
     double areaCorr = 0;
     auto puZeta = m_puZetaCorrection.find(isoTypes.at(i));
     if (puZeta != m_puZetaCorrection.end()) {
       areaCorr = puZeta->second->Eval(std::abs(eta)); // CW might have done it vs etaBE(2). This eta here is caloCluster eta...
     } else {
       ATH_MSG_WARNING("Requested refined eta dependent pileup correction but no zeta correction provided " << Iso::toCString(isoTypes.at(i)));
     }
     if (m_isMC) {
       auto puZetaMC = m_puZetaMCCorrection.find(isoTypes.at(i));
       if (puZetaMC != m_puZetaMCCorrection.end()) {
         areaCorr -= puZetaMC->second->Eval(std::abs(eta));
       } else {
         ATH_MSG_WARNING("Requested refined eta dependent pileup correction for mc but no zeta correction provided " << Iso::toCString(isoTypes.at(i)));
       }
     }
     toSub *= areaCorr;
       }
       corrvec[i] = toSub;
       if (result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::pileupCorrection))){
     result.etcones[i] -= toSub;
       }
       ATH_MSG_DEBUG("ED correction ("<< type << ")for size " << dR << " = " << toSub << " (areacore=" << areacore << ")");
     }
  
     result.noncoreCorrections[Iso::pileupCorrection] = corrvec;
     return true;
   }

◆ etConeIsolation() [1/3]

bool xAOD::CaloIsolationTool::etConeIsolation	(	CaloIsolation &	result,
		const Egamma &	eg,
		const std::vector< Iso::IsolationType > &	isoTypes,
		const CaloCellContainer *	container
	)		const

private

Definition at line 877 of file CaloIsolationTool.cxx.

                                                                    {
     if( isoTypes.empty() ) {
       ATH_MSG_WARNING("Empty list passed, failing calculation");
       return false;
     }
  
     SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
     const CaloDetDescrManager* caloDDMgr = *caloMgrHandle;
  
     std::vector<float> coneSizes;        coneSizes.resize(3);
     std::vector<float> coneSizesSquared; coneSizesSquared.resize(3);
     for (unsigned int i = 0; i < isoTypes.size(); i++) {
       float dR = Iso::coneSize(isoTypes.at(i));
       coneSizes[i] = dR;
       coneSizesSquared[i] = dR*dR;
     }
  
     float phi = eg.caloCluster()->phi();
     float eta = eg.caloCluster()->eta();
  
     // Define a new Calo Cell list corresponding to EM Calo
     std::vector<CaloCell_ID::SUBCALO> Vec_EMCaloEnums;
     for (unsigned int n=0; n < m_EMCaloNums.size(); ++n) {
       Vec_EMCaloEnums.push_back(static_cast<CaloCell_ID::SUBCALO>( m_EMCaloNums[n] ));
     }
     CaloCellList EMccl(caloDDMgr,container, Vec_EMCaloEnums);
  
     std::vector<CaloCell_ID::SUBCALO> Vec_HadCaloEnums;
     for (unsigned int n=0; n < m_HadCaloNums.size(); ++n) {
       Vec_HadCaloEnums.push_back(static_cast<CaloCell_ID::SUBCALO>( m_HadCaloNums[n] ));
     }
     CaloCellList HADccl(caloDDMgr,container, Vec_HadCaloEnums);
  
     // Let's determine some values based on the input specs
     // Search for largest radius
     double Rmax = 0.0;
     for (unsigned int n=0; n< coneSizes.size(); n++)
       if (coneSizes[n] > Rmax) Rmax = coneSizes[n];
  
     // get the cells for the first one; by convention, it must be bigger than all the other cones.
     EMccl.select(eta,phi,Rmax);
  
     for (const auto *it: EMccl) {
       double etacel=it->eta();
       double phicel=it->phi();
  
       double deleta = eta-etacel;
       float delphi = Phi_mpi_pi(phi-phicel);
       double drcel2 = (deleta*deleta) + (delphi*delphi);
  
       for (unsigned int i = 0; i < coneSizes.size(); i++) {
     if (drcel2 < coneSizesSquared[i])
       result.etcones[i] += it->et();
       }
     }//end loop over cell-list
  
  
     // get the cells for the first one; by convention, it must be bigger than all the other cones.
     HADccl.select(eta, phi, Rmax);
  
     for (const auto *it: HADccl) {
       // Optionally remove TileGap cells
       if (m_ExcludeTG3 && CaloCell_ID::TileGap3 == it->caloDDE()->getSampling()) {
     ATH_MSG_DEBUG("Excluding cell with Et = " << it->et());
     continue;
       }
  
       // if no TileGap cells excluded, log energy of all cells
       double etacel = it->eta();
       double phicel = it->phi();
  
       double deleta = eta-etacel;
       float delphi = Phi_mpi_pi(phi-phicel);
       double drcel2 = (deleta*deleta) + (delphi*delphi);
  
       for (unsigned int i = 0; i < coneSizes.size(); i++) {
     if (drcel2 < coneSizesSquared[i])
       result.etcones[i] += it->et();
       }
     }//end loop over cell-list
  
     return true;
   }

◆ etConeIsolation() [2/3]

bool xAOD::CaloIsolationTool::etConeIsolation	(	CaloIsolation &	result,
		const Muon &	muon,
		const std::vector< Iso::IsolationType > &	isoTypes,
		double	coneCoreSize,
		const derefMap_t &	derefMap
	)		const

private

add coreCone if asked – make sure it's the last one! or a better

apply the correction if required.

start the calculation

do coreCone

apply the correction if required.

Definition at line 770 of file CaloIsolationTool.cxx.

                                                                              {
  
     std::vector<double> conesf;
     double maxConeSize = -1;
     for( auto isoType : isoTypes ){
       if( Iso::isolationFlavour(isoType) != Iso::etcone ) {
         ATH_MSG_WARNING("Unsupported isolation type passed, cannot calculate isolation " << static_cast<int>(isoType));
         return false;
       }
       double cone = Iso::coneSize(isoType);
       conesf.push_back(cone);
       if(cone>maxConeSize) maxConeSize = cone;
     }
     const double coreConeDR = coneCoreSize;
     bool doCoreCone = (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone)));
     if(doCoreCone && maxConeSize<coreConeDR) maxConeSize = coreConeDR;
  
     if(!muon.clusterLink().isValid()){
       ATH_MSG_DEBUG("no valid cluster link");
       //no cluster, set everything to 0
       for(unsigned int i=0; i<conesf.size(); i++) result.etcones[i] = 0;
       if(doCoreCone){
     ATH_MSG_DEBUG("starting etcone, coreCone");
     double totE = 0.;
     std::map<Iso::IsolationCorrectionParameter,float> corecorr;
     corecorr[Iso::coreEnergy] = totE;
     corecorr[Iso::coreArea]   = coreConeDR*coreConeDR*M_PI;
     result.coreCorrections[Iso::coreCone] = corecorr;
     ATH_MSG_DEBUG("done etcone, coreCone");
     if(result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone))){
       double ecore = totE;
       ATH_MSG_DEBUG("Applying coreCone correction for trackParticle etcone isolation.");
       for( unsigned int i=0;i<result.etcones.size();++i ) {
         result.etcones[i] -= ecore;
         ATH_MSG_DEBUG("i: " << i << " cone [before] " << result.etcones[i]+ecore << " cone [after] " << result.etcones[i]);
       }
     }
       }
     }
     else{
       const xAOD::CaloCluster* muonCluster=*muon.clusterLink();
       ATH_MSG_DEBUG("calculating etcone for # " << conesf.size() << " cones");
       Trk::CaloCellSelectorLayerdR selector(maxConeSize);
       selector.preSelectAction(*muonCluster);
       ATH_MSG_DEBUG("looping over cells " << muonCluster->size());
       for(unsigned int i=0; i<conesf.size(); i++){
     double totE = 0.;
     selector.setConeSize(conesf[i]);
     xAOD::CaloCluster::const_cell_iterator cell_itr=muonCluster->begin();
     for(; cell_itr!=muonCluster->end(); ++cell_itr){
       if( !selector.select(**cell_itr) ) continue;
       if (m_ExcludeTG3 && CaloCell_ID::TileGap3 == (*cell_itr)->caloDDE()->getSampling()) continue;
       totE += (*cell_itr)->et();
     }
     result.etcones[i] = totE;
     ATH_MSG_DEBUG("etcone raw: coneSize = " << conesf[i] << "; etcone = " << result.etcones[i]);
       }
       ATH_MSG_DEBUG("done looping over cells ");
       if(doCoreCone){
     ATH_MSG_DEBUG("starting etcone, coreCone");
     double totE = 0.;
     selector.setConeSize(coreConeDR);
     xAOD::CaloCluster::const_cell_iterator cell_itr=muonCluster->begin();
     for(; cell_itr!=muonCluster->end(); ++cell_itr){
       if( !selector.select(**cell_itr) ) continue;
       if (m_ExcludeTG3 && CaloCell_ID::TileGap3 == (*cell_itr)->caloDDE()->getSampling()) continue;
       totE += (*cell_itr)->et();
     }
     std::map<Iso::IsolationCorrectionParameter,float> corecorr;
     corecorr[Iso::coreEnergy] = totE;
     corecorr[Iso::coreArea]   = coreConeDR*coreConeDR*M_PI;
     result.coreCorrections[Iso::coreCone] = corecorr;
     ATH_MSG_DEBUG("done etcone, coreCone");
     
     if(result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone))){
       double ecore = totE;
       ATH_MSG_DEBUG("Applying coreCone correction for trackParticle etcone isolation.");
       for( unsigned int i=0;i<result.etcones.size();++i ) {
         result.etcones[i] -= ecore;
         ATH_MSG_DEBUG("i: " << i << " cone [before] " << result.etcones[i]+ecore << " cone [after] " << result.etcones[i]);
       }
     }
       }
     }
     // calculate etcore
     if(!m_saveOnlyRequestedCorrections ||
        result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreMuon))){
       const TrackParticle* tp = nullptr;
       if(muon.primaryTrackParticleLink().isValid() && muon.author()!=2) tp = *muon.primaryTrackParticleLink();
       if( !tp) tp = *muon.inDetTrackParticleLink();
       correctIsolationEnergy_MuonCore(result, *tp, derefMap);
     }
  
     return true;
   }

◆ etConeIsolation() [3/3]

bool xAOD::CaloIsolationTool::etConeIsolation	(	CaloIsolation &	result,
		const TrackParticle &	tp,
		const std::vector< Iso::IsolationType > &	isoTypes,
		const CaloCellContainer *	container,
		double	coneCoreSize,
		const derefMap_t &	derefMap
	)		const

private

add coreCone if asked – make sure it's the last one! or a better

start the calculation

do coreCone

apply the correction if required.

Definition at line 677 of file CaloIsolationTool.cxx.

                                                                              {
  
     // for now always use track, should move to extrapolation to calo entrance
     const Trk::Track* track = tp.track();
     if( !track  ) {
       ATH_MSG_WARNING("Failed to access track");
       return false;
     }
  
     std::vector<double> conesf;
     double maxConeSize = -1;
     for( auto isoType : isoTypes ){
         if( Iso::isolationFlavour(isoType) != Iso::etcone ) {
         ATH_MSG_WARNING("Unsupported isolation type passed, cannot calculate isolation " << static_cast<int>(isoType));
         return false;
       }
       double cone = Iso::coneSize(isoType);
       conesf.push_back(cone);
       if(cone>maxConeSize) maxConeSize = cone;
     }
  
     const double coreConeDR = coneCoreSize;
     bool doCoreCone = (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone)));
     if(doCoreCone && maxConeSize<coreConeDR) maxConeSize = coreConeDR;
  
     ATH_MSG_DEBUG("calculating etcone for # " << conesf.size() << " cones");
     std::unique_ptr<const Rec::ParticleCellAssociation> association=m_assoTool->particleCellAssociation(tp,maxConeSize,container);
     if( !association) {
       ATH_MSG_DEBUG("failed to obtain the ParticleCellAssociation");
       return false;
     }
  
     Trk::CaloCellSelectorLayerdR selector(maxConeSize);
     selector.preSelectAction(association->caloExtension());
     ATH_MSG_DEBUG("looping over cells " << association->data().size());
     for(unsigned int i=0; i<conesf.size(); i++){
       double totE = 0.;
       selector.setConeSize(conesf[i]);
       for (const auto *aCell : association->data()){
         if( !selector.select(*aCell) ) continue;
         if (m_ExcludeTG3 && CaloCell_ID::TileGap3 == aCell->caloDDE()->getSampling()) continue;
         totE += aCell->et();
       }
       result.etcones[i] = totE;
       ATH_MSG_DEBUG("etcone raw: coneSize = " << conesf[i] << "; etcone = " << result.etcones[i]);
     }
     ATH_MSG_DEBUG("done looping over cells ");
  
     if(doCoreCone){
       ATH_MSG_DEBUG("starting etcone, coreCone");
       double totE = 0.;
       selector.setConeSize(coreConeDR);
       for (const auto *aCell : association->data()){
         if( !selector.select(*aCell) ) continue;
         if (m_ExcludeTG3 && CaloCell_ID::TileGap3 == aCell->caloDDE()->getSampling()) continue;
         totE += aCell->et();
       }
       std::map<Iso::IsolationCorrectionParameter,float> corecorr;
       corecorr[Iso::coreEnergy] = totE;
       corecorr[Iso::coreArea]   = coreConeDR*coreConeDR*M_PI;
       result.coreCorrections[Iso::coreCone] = corecorr;
       ATH_MSG_DEBUG("done etcone, coreCone");
  
       if(result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone))){
         double ecore = totE;
         ATH_MSG_DEBUG("Applying coreCone correction for trackParticle etcone isolation.");
         for( unsigned int i=0;i<result.etcones.size();++i ) {
           result.etcones[i] -= ecore;
           ATH_MSG_DEBUG("i: " << i << " cone [before] " << result.etcones[i]+ecore << " cone [after] " << result.etcones[i]);
         }
       }
     }
  
     // calculate etcore
     if(!m_saveOnlyRequestedCorrections ||
        result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreMuon))){
       correctIsolationEnergy_MuonCore(result, tp, derefMap);
     }
  
     return true;
   }

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ finalize()

StatusCode xAOD::CaloIsolationTool::finalize ( )

overridevirtual

Definition at line 155 of file CaloIsolationTool.cxx.

                                          {
     return StatusCode::SUCCESS;
   }

◆ GetExtrapEtaPhi()

bool xAOD::CaloIsolationTool::GetExtrapEtaPhi	(	const TrackParticle *	tp,
		float &	eta,
		float &	phi,
		derefMap_t &	derefMap
	)		const

private

get it from decoration

get it from calo-cluster if it's muon

try the extention in athena if it's not obtained from muon yet.

if still not got the updated eta & phi

Definition at line 532 of file CaloIsolationTool.cxx.

   {
     static const SG::AuxElement::ConstAccessor< char > Decorated("caloExt_Decorated");
     static const SG::AuxElement::ConstAccessor< float > Eta("caloExt_eta");
     static const SG::AuxElement::ConstAccessor< float > Phi("caloExt_phi");
     if(Decorated.isAvailable(*tp) && Decorated(*tp)){
       eta = Eta(*tp);
       phi = Phi(*tp);
       return true;
     }
  
     const Muon* mu = dynamic_cast<const Muon*>(derefMap[tp]);
     if(mu){
       const auto *cluster = mu->cluster();
       if(cluster){
         float etaT = 0, phiT = 0, dphiT = 0.;
         int nSample = 0;
         for(unsigned int i=0; i<CaloSampling::Unknown; i++) // dangerous?
         {
           auto s = static_cast<CaloSampling::CaloSample>(i);
           if(!cluster->hasSampling(s)) continue;
           ATH_MSG_DEBUG("Sampling: " << i << "eta-phi (" << cluster->etaSample(s) << ", " << cluster->phiSample(s) << ")");
           etaT += cluster->etaSample(s);
           if( nSample == 0 ){
             phiT = cluster->phiSample(s);
           }
           else{
             dphiT += xAOD::P4Helpers::deltaPhi( cluster->phiSample(s), phiT ) ;
           }
           nSample++;
         }
         if(nSample>0){
           eta = etaT/nSample;
           phi = phiT + dphiT/nSample;
           return true;
         }else{
           ATH_MSG_WARNING("Muon calo cluster is empty????");
         }
       }else{
         ATH_MSG_DEBUG("Muon calo cluster not found.");
       }
     }
  
 #ifndef XAOD_ANALYSIS
     ATH_MSG_DEBUG("Geting calo extension caloExtension tool.");
     // If we have an extension cache then it owns the extension, otherwise we own it
     // Therefore we have to prepare both an owning and a non-owning pointer
     std::unique_ptr<Trk::CaloExtension> caloExtensionUPtr;
     const Trk::CaloExtension* caloExtension = nullptr;
     if (m_caloExtensionKey.empty())
     {
       caloExtensionUPtr =
         m_caloExtTool->caloExtension(Gaudi::Hive::currentContext(), *tp);
       caloExtension = caloExtensionUPtr.get();
     }
     else
     {
       auto cache = SG::makeHandle(m_caloExtensionKey);
       if (!cache.isValid())
       {
         ATH_MSG_WARNING("Failed to retrieve calo extension cache " << m_caloExtensionKey);
         return false;
       }
       caloExtension = m_caloExtTool->caloExtension(*tp, *cache);
     }
     if(!caloExtension){
       ATH_MSG_WARNING("Can not get caloExtension.");
       return false;
     };
  
     const std::vector<Trk::CurvilinearParameters>& intersections = caloExtension->caloLayerIntersections();
     if(!intersections.empty()){
       Amg::Vector3D avePoint(0,0,0);
       for (unsigned int i = 0; i < intersections.size(); ++i){
         const Amg::Vector3D& point = intersections[i].position();
         ATH_MSG_DEBUG("Intersection: " << i << " ID: " << m_parsIdHelper.caloSample(intersections[i].cIdentifier())
                       <<  " eta-phi (" << point.eta() << ", " << point.phi() << ")");
         avePoint += point;
       }
       avePoint = (1./intersections.size())*avePoint;
       eta = avePoint.eta();
       phi = avePoint.phi();
       return true;
     }else{
         ATH_MSG_WARNING("Muon Calo extension got no intersection!!!");
     }
 #endif // xAOD
     ATH_MSG_WARNING("Calo extension can not be obtained!!!");
     return false;
   }

◆ getKey()

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

inherited

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

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

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

See also: asg::AsgTool::getName

Parameters

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

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

Definition at line 119 of file AsgTool.cxx.

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

◆ getName()

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

inherited

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

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

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

See also: asg::AsgTool::getKey

Parameters

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

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

Definition at line 106 of file AsgTool.cxx.

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

◆ getProperty()

template<class T >

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

inherited

Get one of the tool's properties.

◆ getReferenceParticle()

const IParticle * xAOD::CaloIsolationTool::getReferenceParticle ( const IParticle & particle ) const

private

get reference particle

Definition at line 1593 of file CaloIsolationTool.cxx.

                                                                                           {
     const TrackParticle* tp = dynamic_cast<const TrackParticle*>(&particle);
     if( tp ) return tp;
     const Muon* muon = dynamic_cast<const Muon*>(&particle);
     if( muon ) {
       ATH_MSG_DEBUG("muon with author "<<muon->author()<<" and pT "<<muon->pt());
       const TrackParticle* tp = nullptr;
       //note: if STACO, the track particle has no Trk::Track associated, so use the ID track
       if(muon->primaryTrackParticleLink().isValid() && muon->author()!=2) tp = *muon->primaryTrackParticleLink();
       if( !tp) tp = *muon->inDetTrackParticleLink();
       if( !tp ) {
         ATH_MSG_WARNING(" No TrackParticle found for muon " );
         return nullptr;
       }
       return tp;
     }
     return &particle;
   }

◆ initialize()

StatusCode xAOD::CaloIsolationTool::initialize ( )

overridevirtual

Dummy implementation of the initialisation function.

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

Reimplemented from asg::AsgTool.

Definition at line 67 of file CaloIsolationTool.cxx.

                                            {
 #ifndef XAOD_ANALYSIS
     if (!m_assoTool.empty())
       ATH_CHECK(m_assoTool.retrieve());
  
     if (!m_caloExtTool.empty())
       ATH_CHECK(m_caloExtTool.retrieve());
  
     if (!m_clustersInConeTool.empty())
       ATH_CHECK(m_clustersInConeTool.retrieve());
  
     if (!m_pflowObjectsInConeTool.empty())
       ATH_CHECK(m_pflowObjectsInConeTool.retrieve());
  
     if (!m_caloFillRectangularTool.empty()) {
       ATH_CHECK( m_caloFillRectangularTool.retrieve());
     }
  
     //check calo number specified for EM Calos
     unsigned int nSubCalo=static_cast<int>(CaloCell_ID::NSUBCALO);
     if (m_EMCaloNums.size()>nSubCalo || m_HadCaloNums.size()>nSubCalo) {
       ATH_MSG_ERROR(" More than " << nSubCalo << " calo specified. Required for EM =" << m_EMCaloNums.size()<< ", and for HCAL = " << m_HadCaloNums.size() << ". Must be wrong. Stop.");
       return StatusCode::FAILURE;
     }
  
     for (unsigned int index=0; index < m_EMCaloNums.size() ; ++index)  {
       if (m_EMCaloNums[index]<0 || m_EMCaloNums[index]>=(int)nSubCalo ) {
         ATH_MSG_ERROR("Invalid calo specification:" << m_EMCaloNums[index] << "Stop.");
         return StatusCode::FAILURE;
       } else
         ATH_MSG_DEBUG("Select calorimeter " << m_EMCaloNums[index]);
     }
  
     for (unsigned int index=0; index < m_HadCaloNums.size() ; ++index) {
       if (m_HadCaloNums[index]<0 || m_HadCaloNums[index]>=(int)nSubCalo) {
         ATH_MSG_ERROR("Invalid calo specification:" << m_HadCaloNums[index] << "Stop.");
         return StatusCode::FAILURE;
       } else
         ATH_MSG_DEBUG("Select calorimeter " << m_HadCaloNums[index]);
     }
  
     ATH_CHECK(m_caloExtensionKey.initialize(SG::AllowEmpty));
     ATH_CHECK(m_caloMgrKey.initialize());
 #endif // XAOD_ANALYSIS
  
     if (!m_IsoLeakCorrectionTool.empty())
       ATH_CHECK(m_IsoLeakCorrectionTool.retrieve());
  
     // initialize the read handles (for now do all of them in all cases)
     
     ATH_CHECK(m_tpEDCentral.initialize(m_InitializeReadHandles));
     ATH_CHECK(m_tpEDForward.initialize(m_InitializeReadHandles));
     ATH_CHECK(m_efEDCentral.initialize(m_InitializeReadHandles));
     ATH_CHECK(m_efEDForward.initialize(m_InitializeReadHandles));
  
     if (m_useEtaDepPU) {
       std::string filename = PathResolverFindCalibFile(m_puZetaCorrectionFileName);
       if (filename.empty()){
     ATH_MSG_ERROR ( "Could NOT resolve file name " << m_puZetaCorrectionFileName );
     return StatusCode::FAILURE ;
       }
       ATH_MSG_INFO("Path found for pileup correction = "<< filename);
       std::unique_ptr<TFile> f(TFile::Open(filename.c_str(), "READ"));
       m_puZetaCorrection[xAOD::Iso::topoetcone20] = std::unique_ptr<TGraph>((TGraph*)f->Get("topoetcone20"));
       m_puZetaCorrection[xAOD::Iso::topoetcone30] = std::unique_ptr<TGraph>((TGraph*)f->Get("topoetcone30"));
       m_puZetaCorrection[xAOD::Iso::topoetcone40] = std::unique_ptr<TGraph>((TGraph*)f->Get("topoetcone40"));
       f->Close();
  
       if (m_isMC) {
     filename = PathResolverFindCalibFile(m_puZetaMCCorrectionFileName);
     if (filename.empty()){
       ATH_MSG_ERROR ( "Could NOT resolve file name " << m_puZetaMCCorrectionFileName );
       return StatusCode::FAILURE ;
     }
     ATH_MSG_INFO("Path found for mc additional correction of pileup correction = "<< filename);
     std::unique_ptr<TFile> g(TFile::Open(filename.c_str(), "READ"));
     m_puZetaMCCorrection[xAOD::Iso::topoetcone20] = std::unique_ptr<TGraph>((TGraph*)g->Get("topoetcone20"));
     m_puZetaMCCorrection[xAOD::Iso::topoetcone30] = std::unique_ptr<TGraph>((TGraph*)g->Get("topoetcone30"));
     m_puZetaMCCorrection[xAOD::Iso::topoetcone40] = std::unique_ptr<TGraph>((TGraph*)g->Get("topoetcone40"));
     g->Close();
       }
     }
  
     // Exit function
     return StatusCode::SUCCESS;
   }

◆ initresult()

void xAOD::CaloIsolationTool::initresult	(	CaloIsolation &	result,
		const CaloCorrection &	corrlist,
		unsigned int	typesize
	)

staticprivate

Definition at line 1582 of file CaloIsolationTool.cxx.

                                             {
  
     result.corrlist = corrlist;
     result.coreCorrections.clear();
     result.noncoreCorrections.clear();
     result.etcones.resize(typesize,0.);
  
   }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msg_level_name()

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

inherited

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

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

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

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

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

Definition at line 101 of file AsgTool.cxx.

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

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ neutralEflowIsolation() [1/4]

bool xAOD::CaloIsolationTool::neutralEflowIsolation	(	CaloIsolation &	result,
		const Egamma &	eg,
		const std::vector< Iso::IsolationType > &	cones,
		const CaloCorrection &	corrections,
		double	coneCoreSize
	)		const

private

cast for egamma (pflowetcone egamma)

Definition at line 415 of file CaloIsolationTool.cxx.

   {
  
     if( isoTypes.empty() ) {
       ATH_MSG_WARNING("Empty list passed, failing calculation");
       return false;
     }
     if(!m_useEMScale){
       ATH_MSG_WARNING("Only EM scale is supported by neutralEflowIsolation");
       return false;
     }
  
     unsigned int typesize = isoTypes.size();
     initresult(result, corrlist, typesize);
  
     std::vector<float> coneSizes;
     coneSizes.reserve(isoTypes.size());
  
     for( auto isoType : isoTypes ){
       coneSizes.push_back(Iso::coneSize(isoType));
     }
  
     // neutral pflow are pv-corrected
     // ==> use electron eta/phi (not associated SC eta/phi)
     // ==> for photons, there is a mismatch...
     float phi = eg.phi();
     float eta = eg.eta();
  
     ATH_MSG_DEBUG("eg pt eta phi " << eg.pt() << " " << eta << " " << phi
           << " cluster eta, phi = " << eg.caloCluster()->eta() << " " << eg.caloCluster()->phi());
  
     if (!pflowConeIsolation(result, eta, phi, coneSizes, true, nullptr, coneCoreSize, &eg)) {
       ATH_MSG_WARNING("pflowConeIsolation failed");
       return false;
     }
  
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::core57cells))) {
       // Apply core energy subtraction
       if (!correctIsolationEnergy_Eeg57(result,isoTypes,&eg))
         ATH_MSG_WARNING("Could not compute core cell energy for egamma in neflowisol");
     }
  
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::ptCorrection))) {
       // do pt correction
       if (!PtCorrection(result, eg, isoTypes))
         ATH_MSG_WARNING("Could not apply pt correction to isolation");
     }
  
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::pileupCorrection))) {
       // do pile-up correction
       std::string type = "PFlow";
       if (!EDCorrection(result,isoTypes,eta,type,nullptr))
         ATH_MSG_WARNING("Could not apply ED correction to topo isolation");
     }
  
     return true;
   }

◆ neutralEflowIsolation() [2/4]

bool xAOD::CaloIsolationTool::neutralEflowIsolation	(	CaloIsolation &	result,
		const IParticle &	tp,
		const std::vector< Iso::IsolationType > &	cones,
		const CaloCorrection &	corrections
	)		const

overridevirtual

INeutralEFlowIsolationTool interface:

get track particle

Implements xAOD::INeutralEFlowIsolationTool.

Definition at line 239 of file CaloIsolationTool.cxx.

                                                              {
  
     //
     double coneCoreSize = m_coneCoreSizeEg;
     if (particle.type() == Type::Muon)
       coneCoreSize = m_coneCoreSizeMu;
  
     derefMap_t derefMap;
     const IParticle* ip = getReferenceParticle(particle);
     if( !ip ){
       ATH_MSG_WARNING("Failed to obtain reference particle");
       return false;
     }
     derefMap[ip] = &particle;
  
     // muon pflowetcone isolation
     const TrackParticle* trkp = dynamic_cast<const TrackParticle*>(ip);
     if ( trkp ) return neutralEflowIsolation(result,*trkp,cones,corrlist,coneCoreSize,derefMap);
  
     // egamma pflowetcone isolation
     const Egamma* egam = dynamic_cast<const Egamma*>(ip);
     if ( egam ) return neutralEflowIsolation(result,*egam,cones,corrlist,coneCoreSize);
  
     ATH_MSG_WARNING("FlowElementIsolation only supported for Egamma and TrackParticle");
  
     return true;
   }

◆ neutralEflowIsolation() [3/4]

virtual bool xAOD::INeutralEFlowIsolationTool::neutralEflowIsolation

INeutralEFlowIsolationTool interface for eflow isolation: The tool expects the cones to be order in decreasing order (neflowiso40 -> neflowiso20) Internally it reorders the cones so the output isolation values are also in the same order.

Parameters

[in]	result	output object to be filled
[in]	tp	input iparticle
[in]	cones	vector of input cones to be used
[in]	corrections	bitset specifying which corrections to apply to isolation

Returns: true if the calculation was successfull

◆ neutralEflowIsolation() [4/4]

bool xAOD::CaloIsolationTool::neutralEflowIsolation	(	CaloIsolation &	result,
		const TrackParticle &	tp,
		const std::vector< Iso::IsolationType > &	cones,
		const CaloCorrection &	corrections,
		double	coneCoreSize,
		derefMap_t &	derefMap
	)		const

private

cast for egamma (pflowetcone egamma)

Definition at line 479 of file CaloIsolationTool.cxx.

   {
  
     if( isoTypes.empty() ) {
       ATH_MSG_WARNING("Empty list passed, failing calculation");
       return false;
     }
  
     unsigned int typesize = isoTypes.size();
     initresult(result, corrlist, typesize);
  
     std::vector<float> coneSizes;
     coneSizes.reserve(isoTypes.size());
  
     for( auto isoType : isoTypes ){
       coneSizes.push_back(Iso::coneSize(isoType));
     }
  
     float phi = tp.phi();
     float eta = tp.eta();
     if(!GetExtrapEtaPhi(&tp,eta,phi,derefMap)) {
       ATH_MSG_WARNING("TrackParticle eta = " << tp.eta() << ", phi = " << tp.phi() << " not updated from extraplation!");
     }
     ATH_MSG_DEBUG("TrackParticle eta = " << tp.eta() << ", phi = " << tp.phi() << ", extrap eta = " << eta << ", phi = " << phi);
  
     // The core subtraction with pflow removal is done in the method below
     if (!pflowConeIsolation(result, eta, phi, coneSizes, false, nullptr, coneCoreSize)) {
       ATH_MSG_WARNING("pflowConeIsolation failed for muon");
       return false;
     }
  
     // core energy subtraction
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreMuon))) {
       if (!correctIsolationEnergy_MuonCore(result, tp, derefMap))
     ATH_MSG_WARNING("Could not compute muon core energy (cells) from neflowisol");
     }
  
     // do pile-up correction
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::pileupCorrection))) {
       std::string type = "PFlow";
       if (!EDCorrection(result,isoTypes,eta,type,nullptr))
     ATH_MSG_WARNING("Could not apply ED correction to eflow isolation for muon");
     }
  
     return true;
   }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ pflowConeIsolation()

bool xAOD::CaloIsolationTool::pflowConeIsolation	(	CaloIsolation &	result,
		float	eta,
		float	phi,
		std::vector< float > &	m_coneSizes,
		bool	coreEMonly,
		const FlowElementContainer *	container,
		double	coneCoreSize,
		const Egamma *	egObj = `nullptr`
	)		const

private

Definition at line 1012 of file CaloIsolationTool.cxx.

   {
  
     // container is large: preselect only those in max cone size
     auto max_cone_iter=std::max_element(coneSizes.begin(), coneSizes.end());
     float max_cone = (*max_cone_iter);
     std::vector<const FlowElement*> clusts;
     if (!container) {
 #ifndef XAOD_ANALYSIS
       if (m_pflowObjectsInConeTool) {
     m_pflowObjectsInConeTool->particlesInCone(eta,phi,max_cone,clusts);
       } else {
     ATH_MSG_WARNING("No FlowElementsInConeTool available");
       }
 #else
       if(!particlesInCone(eta,phi,max_cone,clusts)) ATH_MSG_WARNING("Failed to get particles in cone.");
 #endif
     } else { // trigger container is small enough
       auto clItr  = container->begin();
       auto clItrE = container->end();
       for(; clItr != clItrE; ++clItr){
     clusts.push_back (*clItr);
       }
     }
  
     // Calculate isolation for pflow objects
     if (!pflowObjCones (result,eta,phi,coneSizes,clusts)) {
       ATH_MSG_WARNING("Could not compute pflow isolation");
       return false;
     }
  
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone))) {
       // Core subtraction
       // be careful, require a certain tag of eflowRec, below which eSample are not always filled
       if (!correctIsolationEnergy_pflowCore(result, eta, phi, -1, -1, coneCoreSize*coneCoreSize, clusts, coreEMonly, egObj))
     ATH_MSG_WARNING("Could not compure pflow core");
     }
  
     return true;
   }

◆ pflowObjCones()

bool xAOD::CaloIsolationTool::pflowObjCones	(	CaloIsolation &	result,
		float	eta,
		float	phi,
		std::vector< float > &	m_coneSizes,
		const std::vector< const FlowElement * > &	clusts
	)		const

private

Calculate isolation cones in pflow objects around eg.

Definition at line 1097 of file CaloIsolationTool.cxx.

   {
  
     ATH_MSG_DEBUG("In pflowObjCones obj eta = " << eta << " phi = " << phi);
  
     for (const FlowElement* cl : clusts) {
       float et = cl->pt();
       if (et <= 0 || fabs(cl->eta()) > 7.0) continue;
  
       float dPhi = Phi_mpi_pi(cl->phi()-phi);
       float dEta = cl->eta()-eta;
       float dR   = sqrt(dPhi*dPhi+ dEta*dEta);
  
       for (unsigned int i = 0; i < coneSizes.size(); i++) {
     if (dR < coneSizes[i]) {
       result.etcones[i] += et;
     }
       }
     }
  
     return true;
   }

◆ Phi_mpi_pi()

float xAOD::CaloIsolationTool::Phi_mpi_pi ( float x ) const

inlineprivate

Definition at line 402 of file CaloIsolationTool.h.

                                       { 
         while (x >= M_PI) x -= 2.*M_PI;
         while (x < -M_PI) x += 2.*M_PI;
         return x;
       }

◆ print() [1/2]

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

◆ print() [2/2]

virtual void asg::IAsgTool::print ( ) const

pure virtualinherited

◆ PtCorrection()

bool xAOD::CaloIsolationTool::PtCorrection	(	CaloIsolation &	result,
		const Egamma &	eg,
		const std::vector< Iso::IsolationType > &	isoTypes
	)		const

private

FIX LATER

Definition at line 1470 of file CaloIsolationTool.cxx.

   {
 // #ifndef XAOD_ANALYSIS
     if(m_IsoLeakCorrectionTool.empty()) return false;
 // #endif // XAOD_ANALYSIS
  
     std::vector<float> corrvec;
     corrvec.resize(isoTypes.size(),0.);
     for (unsigned int i = 0; i < isoTypes.size(); i++) {
  
 // #ifndef XAOD_ANALYSIS
       corrvec[i] = m_IsoLeakCorrectionTool->GetPtCorrection(eg, isoTypes[i]);
 // #else
 //       corrvec[i] = eg.isolationCaloCorrection (isoTypes[i], Iso::ptCorrection);
 // #endif // XAOD_ANALYSIS
       if (result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::ptCorrection))) {
     result.etcones[i] -= corrvec[i];
     ATH_MSG_DEBUG("eta = " << eg.eta() << ", phi = " << eg.phi() << ", pt = " << eg.pt() << ", isoType = " << Iso::toCString(isoTypes[i])
               << ", ptcorr = " << corrvec[i] << ", isol pt corrected = " << result.etcones[i] );
       }
     }
     result.noncoreCorrections[Iso::ptCorrection] = corrvec;
     // get the correction from xAOD file
  
     return true;
   }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

◆ sysStart()

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

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ topoClustCones()

bool xAOD::CaloIsolationTool::topoClustCones	(	CaloIsolation &	result,
		float	eta,
		float	phi,
		std::vector< float > &	m_coneSizes,
		const std::vector< const CaloCluster * > &	clusts
	)		const

private

Calculate isolation cones in topo clusters around eg.

Definition at line 1063 of file CaloIsolationTool.cxx.

   {
  
     ATH_MSG_DEBUG("In CaloIsolationTool::topoClustCones");
  
     for (const CaloCluster* cl : clusts) {
       float et = (m_useEMScale ? cl->p4(CaloCluster::State::UNCALIBRATED).Et() : cl->pt() );
       if(et <= 0 || fabs(cl->eta()) > 7.0) continue;
  
       float st = 1./cosh(cl->p4(CaloCluster::State::UNCALIBRATED).Eta());
       float tilegap3_et = cl->eSample(CaloSampling::TileGap3)*st;
       et -= tilegap3_et;
  
       float dPhi = Phi_mpi_pi(cl->phi()-phi);
       float dEta = cl->eta()-eta;
       float dr=sqrt(dPhi*dPhi+ dEta*dEta);
  
       for (unsigned int i = 0; i < coneSizes.size(); i++) {
     if (dr < coneSizes[i]) {
       ATH_MSG_DEBUG("Adding topo " << cl << " dR = " << dr << " et of a topo clust et = " << et
             << " (calibrated " << cl->pt() << ", tilegap et = " << tilegap3_et << ")");
       result.etcones[i] += et;
     }
       }
     }
  
     return true;
   }

◆ topoConeIsolation()

bool xAOD::CaloIsolationTool::topoConeIsolation	(	CaloIsolation &	result,
		float	eta,
		float	phi,
		std::vector< float > &	coneSizes,
		bool	coreEMonly,
		const CaloClusterContainer *	container,
		const CaloCluster *	fwdClus,
		const Egamma *	egObj,
		double	coneCoreSize
	)		const

private

Definition at line 964 of file CaloIsolationTool.cxx.

   {
  
     // offline topocluster container is large: preselect only those in max cone size
     auto max_cone_iter=std::max_element(coneSizes.begin(), coneSizes.end());
     float max_cone= (*max_cone_iter);
     std::vector<const CaloCluster*> clusts;
     if(!container){
 #ifndef XAOD_ANALYSIS
       if(m_clustersInConeTool){
     m_clustersInConeTool->particlesInCone(eta,phi,max_cone,clusts);
       }else{
     ATH_MSG_WARNING("No CaloClustersInConeTool available");
       }
 #else
       if(!particlesInCone(eta,phi,max_cone,clusts))
         ATH_MSG_WARNING("No CaloClustersInConeTool available");
 #endif
     }else{ // trigger container is small enough
       auto clItr  = container->begin();
       auto clItrE = container->end();
       for(; clItr != clItrE; ++clItr){
     clusts.push_back (*clItr);
       }
     }
  
     // Calculate isolation for topo cluster
     if (!topoClustCones (result,eta,phi, coneSizes, clusts)) {
       ATH_MSG_WARNING("Could not compute topo isolation");
       return false;
     }
  
     if (!m_saveOnlyRequestedCorrections || result.corrlist.calobitset.test(static_cast<unsigned int>(Iso::coreCone))) {
       // Subtract core (easier to do that here than outside like other core corrections)
       if (!correctIsolationEnergy_TopoCore(result, eta, phi, -1, -1, coneCoreSize*coneCoreSize, clusts, coreEMonly, fwdClus, egObj))
     ATH_MSG_WARNING("Could not compute topo core");
     }
  
     return true;
   }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_assoTool

ToolHandle<Rec::IParticleCaloCellAssociationTool> xAOD::CaloIsolationTool::m_assoTool

private

Initial value:

{this, 
      "ParticleCaloCellAssociationTool", 
      "Rec::ParticleCaloCellAssociationTool/ParticleCaloCellAssociationTool"}

Definition at line 271 of file CaloIsolationTool.h.

◆ m_CaloCalTopoCluster

std::string xAOD::CaloIsolationTool::m_CaloCalTopoCluster

private

Topo Calo cluster location in event store.

Definition at line 321 of file CaloIsolationTool.h.

◆ m_caloExtensionKey

SG::ReadHandleKey<CaloExtensionCollection> xAOD::CaloIsolationTool::m_caloExtensionKey

private

Initial value:

{

this, "InputCaloExtension", "", "The calorimeter extensions of the tracks"}

The input calorimeter extensions.

Definition at line 300 of file CaloIsolationTool.h.

◆ m_caloExtTool

ToolHandle<Trk::IParticleCaloExtensionTool> xAOD::CaloIsolationTool::m_caloExtTool

private

Initial value:

{this,
      "ParticleCaloExtensionTool",
      "Trk::ParticleCaloExtensionTool/ParticleCaloExtensionTool"}

Definition at line 275 of file CaloIsolationTool.h.

◆ m_caloFillRectangularTool

ToolHandle<CaloClusterProcessor> xAOD::CaloIsolationTool::m_caloFillRectangularTool

private

Initial value:

{this,
      "CaloFillRectangularClusterTool", "",
      "Handle of the CaloFillRectangularClusterTool"}

Property: calo cluster filling tool.

Definition at line 290 of file CaloIsolationTool.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> xAOD::CaloIsolationTool::m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

private

CaloDetDescrManager from ConditionStore.

Definition at line 304 of file CaloIsolationTool.h.

◆ m_clustersInConeTool

ToolHandle<ICaloClustersInConeTool> xAOD::CaloIsolationTool::m_clustersInConeTool

private

Initial value:

{this,
      "ClustersInConeTool",
      "xAOD::CaloClustersInConeTool/CaloClustersInConeTool"}

Definition at line 281 of file CaloIsolationTool.h.

◆ m_coneCoreSizeEg

Gaudi::Property<double> xAOD::CaloIsolationTool::m_coneCoreSizeEg

private

Initial value:

{this,
      "coneCoreSizeEg", 0.1,  
      "size of the coneCore core energy correction for egamma objects"}

Property: The size of the coneCore core energy calculation.

Definition at line 363 of file CaloIsolationTool.h.

◆ m_coneCoreSizeMu

Gaudi::Property<double> xAOD::CaloIsolationTool::m_coneCoreSizeMu

private

Initial value:

{this,
      "coneCoreSizeMu", 0.05, 
      "size of the coneCore core energy correction for muons"}

Definition at line 367 of file CaloIsolationTool.h.

◆ m_derefMap

std::map<const IParticle*, const IParticle*> xAOD::CaloIsolationTool::m_derefMap

private

map to the orignal particle

Definition at line 372 of file CaloIsolationTool.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_doEnergyDensityCorrection

Gaudi::Property<bool> xAOD::CaloIsolationTool::m_doEnergyDensityCorrection

private

Initial value:

{this,
      "doEnergyDensityCorrection", true, 
      "Correct isolation variables based on energy density estimations"}

Property: do the ED corrections to topoisolation.

Definition at line 329 of file CaloIsolationTool.h.

◆ m_efEDCentral

SG::ReadHandleKey<EventShape> xAOD::CaloIsolationTool::m_efEDCentral

private

Initial value:

{this,
      "EFlowEDCentralContainer", "NeutralParticleFlowIsoCentralEventShape", 
      "Name of energy flow ED Central"}

Property: Name of the central neutral energy flow energy-density container.

Definition at line 353 of file CaloIsolationTool.h.

◆ m_efEDForward

SG::ReadHandleKey<EventShape> xAOD::CaloIsolationTool::m_efEDForward

private

Initial value:

{this,
      "EFlowEDForwardContainer", "NeutralParticleFlowIsoForwardEventShape", 
      "Name of energy flow ED Forward"}

Property: Name of the forward neutral energy flow energy-density container.

Definition at line 358 of file CaloIsolationTool.h.

◆ m_EMCaloNums

Gaudi::Property<std::vector<int> > xAOD::CaloIsolationTool::m_EMCaloNums

private

Initial value:

{this,

"EMCaloNums", {}, "list of EM calo to treat"}

vector of calo-id to treat

Definition at line 313 of file CaloIsolationTool.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_ExcludeTG3

Gaudi::Property<bool> xAOD::CaloIsolationTool::m_ExcludeTG3

private

Initial value:

{this,

"ExcludeTG3", true, "Exclude the TileGap3 cells"}

Property: exclude tile scintillator.

Definition at line 339 of file CaloIsolationTool.h.

◆ m_HadCaloNums

Gaudi::Property<std::vector<int> > xAOD::CaloIsolationTool::m_HadCaloNums

private

Initial value:

{this,

"HadCaloNums", {}, "list of Had calo to treat"}

vector of calo-id to treat

Definition at line 317 of file CaloIsolationTool.h.

◆ m_InitializeReadHandles

Gaudi::Property<bool> xAOD::CaloIsolationTool::m_InitializeReadHandles

private

Initial value:

{this,
        "InitializeReadHandles", true,
        "Initialize all ReadHandles."}

Property: Initialize read Handles.

Default True. For HLT these need to be off.

Definition at line 375 of file CaloIsolationTool.h.

◆ m_isMC

Gaudi::Property<bool> xAOD::CaloIsolationTool::m_isMC {this, "isMC", false, "is MC"}

private

Property: need to know if this is MC (from rec.doTruth) for eta dep pileup corr.

Definition at line 380 of file CaloIsolationTool.h.

◆ m_IsoLeakCorrectionTool

ToolHandle<CP::IIsolationCorrectionTool> xAOD::CaloIsolationTool::m_IsoLeakCorrectionTool

private

Initial value:

{this,
      "IsoLeakCorrectionTool", "",
      "Handle on the leakage correction tool"}

Tool for pt-corrected isolation calculation (new)

Definition at line 308 of file CaloIsolationTool.h.

◆ m_parsIdHelper

Trk::TrackParametersIdHelper xAOD::CaloIsolationTool::m_parsIdHelper

private

Definition at line 278 of file CaloIsolationTool.h.

◆ m_pflowObjectsInConeTool

ToolHandle<IFlowElementsInConeTool> xAOD::CaloIsolationTool::m_pflowObjectsInConeTool

private

Initial value:

{this,

"FlowElementsInConeTool", ""}

Definition at line 286 of file CaloIsolationTool.h.

◆ m_puZetaCorrection

std::map<Iso::IsolationType,std::unique_ptr<TGraph> > xAOD::CaloIsolationTool::m_puZetaCorrection

private

map of the zeta corrections (one / cone size)

Definition at line 395 of file CaloIsolationTool.h.

◆ m_puZetaCorrectionFileName

Gaudi::Property<std::string> xAOD::CaloIsolationTool::m_puZetaCorrectionFileName

private

Initial value:

{this,
      "EtaDependentPileupCorrectionFileName", "IsolationCorrections/v4/zetas.root",
      "File name for the eta dependant pileup correction to isolation"}

name of the root file for the eta dependant pileup correction

Definition at line 387 of file CaloIsolationTool.h.

◆ m_puZetaMCCorrection

std::map<Iso::IsolationType,std::unique_ptr<TGraph> > xAOD::CaloIsolationTool::m_puZetaMCCorrection

private

Definition at line 396 of file CaloIsolationTool.h.

◆ m_puZetaMCCorrectionFileName

Gaudi::Property<std::string> xAOD::CaloIsolationTool::m_puZetaMCCorrectionFileName

private

Initial value:

{this,
      "EtaDependentPileupMCCorrectionFileName", "IsolationCorrections/v4/zetas_correction.root",
      "File name for the eta dependant pileup correction to isolation, small mc correction"}

Definition at line 390 of file CaloIsolationTool.h.

◆ m_saveOnlyRequestedCorrections

Gaudi::Property<bool> xAOD::CaloIsolationTool::m_saveOnlyRequestedCorrections

private

Initial value:

{this,
      "saveOnlyRequestedCorrections", false, 
      "save only requested corrections (trigger usage mainly)"}

Property: save only requested corrections (trigger usage mainly)

Definition at line 334 of file CaloIsolationTool.h.

◆ m_tpEDCentral

SG::ReadHandleKey<EventShape> xAOD::CaloIsolationTool::m_tpEDCentral

private

Initial value:

{this,
      "TopoClusterEDCentralContainer", "TopoClusterIsoCentralEventShape", 
      "Name of TopoCluster ED Central"}

Property: Name of the central topocluster energy-density container.

Definition at line 343 of file CaloIsolationTool.h.

◆ m_tpEDForward

SG::ReadHandleKey<EventShape> xAOD::CaloIsolationTool::m_tpEDForward

private

Initial value:

{this,
      "TopoClusterEDForwardContainer", "TopoClusterIsoForwardEventShape", 
      "Name of TopoCluster ED Forward"}

Property: Name of the forward topocluster energy-density container.

Definition at line 348 of file CaloIsolationTool.h.

◆ m_useCaloExtensionCaching

Gaudi::Property<bool> xAOD::CaloIsolationTool::m_useCaloExtensionCaching

private

Initial value:

{this, 
      "UseCaloExtensionCaching", true, 
      "Use cached caloExtension if avaliable."}

Property: Use cached caloExtension if avaliable.

Definition at line 295 of file CaloIsolationTool.h.

◆ m_useEMScale

Gaudi::Property<bool> xAOD::CaloIsolationTool::m_useEMScale

private

Initial value:

{this,
      "UseEMScale", true,
      "Use TopoClusters at the EM scale."}

Property: Use TopoClusters at the EM scale.

Definition at line 324 of file CaloIsolationTool.h.

◆ m_useEtaDepPU

Gaudi::Property<bool> xAOD::CaloIsolationTool::m_useEtaDepPU

private

Initial value:

{this,

"UseEtaDepPUCorr", true, "Use the eta dependent pileup correction"}

Property: use pileup dependent correction.

Definition at line 383 of file CaloIsolationTool.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ derefMap_t

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ CaloIsolationTool()

◆ ~CaloIsolationTool()

Member Function Documentation

◆ caloCellIsolation() [1/4]

◆ caloCellIsolation() [2/4]

◆ caloCellIsolation() [3/4]

◆ caloCellIsolation() [4/4]

◆ caloTopoClusterIsolation() [1/4]

◆ caloTopoClusterIsolation() [2/4]

◆ caloTopoClusterIsolation() [3/4]

◆ caloTopoClusterIsolation() [4/4]

◆ correctIsolationEnergy_Eeg57()

◆ correctIsolationEnergy_MuonCore()

◆ correctIsolationEnergy_pflowCore()

◆ correctIsolationEnergy_TopoCore()

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

◆ decorateTrackCaloPosition()

◆ detStore()

◆ EDCorrection()

◆ etConeIsolation() [1/3]

◆ etConeIsolation() [2/3]

◆ etConeIsolation() [3/3]

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ extraDeps_update_handler()

◆ finalize()

◆ GetExtrapEtaPhi()

◆ getKey()

◆ getName()

◆ getProperty()

◆ getReferenceParticle()

◆ initialize()

◆ initresult()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msg_level_name()

◆ msgLvl()

◆ neutralEflowIsolation() [1/4]

◆ neutralEflowIsolation() [2/4]

◆ neutralEflowIsolation() [3/4]

◆ neutralEflowIsolation() [4/4]

◆ outputHandles()

◆ pflowConeIsolation()

◆ pflowObjCones()

◆ Phi_mpi_pi()

◆ print() [1/2]

◆ print() [2/2]

◆ PtCorrection()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ topoClustCones()

◆ topoConeIsolation()

◆ updateVHKA()

Member Data Documentation

◆ m_assoTool

◆ m_CaloCalTopoCluster

◆ m_caloExtensionKey