xAOD::CaloIsolationTool Class Reference

#include <CaloIsolationTool.h>

Inheritance diagram for xAOD::CaloIsolationTool:

Public Member Functions
	CaloIsolationTool (const std::string &name)
	~CaloIsolationTool (void)
virtual StatusCode	initialize () override
	Dummy implementation of the initialisation function.
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:
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.
virtual bool	neutralEflowIsolation (CaloIsolation &result, const IParticle &tp, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections) const override
	INeutralEFlowIsolationTool interface:
virtual void	print () const
	Print the state of the tool.
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const
Additional helper functions, not directly mimicking Athena
template<class T>
const T *	getProperty (const std::string &name) const
	Get one of the tool's properties.
const std::string &	msg_level_name () const __attribute__((deprecated))
	A deprecated function for getting the message level's name.
const std::string &	getName (const void *ptr) const
	Get the name of an object that is / should be in the event store.
SG::sgkey_t	getKey (const void *ptr) const
	Get the (hashed) key of an object that is in the event store.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef std::map< const IParticle *, const IParticle * >	derefMap_t
	map to the orignal particle
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)
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)
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)
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)
bool	neutralEflowIsolation (CaloIsolation &result, const Egamma &eg, const std::vector< Iso::IsolationType > &cones, const CaloCorrection &corrections, double coneCoreSize) const
	cast for egamma (pflowetcone egamma)
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)
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.
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.
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.
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.
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
void	decorateTrackCaloPosition (const IParticle &particle, float eta, float phi) const
float	Phi_mpi_pi (float x) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

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.
Gaudi::Property< bool >	m_useCaloExtensionCaching
	Property: Use cached caloExtension if avaliable.
SG::ReadHandleKey< CaloExtensionCollection >	m_caloExtensionKey
	The input calorimeter extensions.
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}
	CaloDetDescrManager from ConditionStore.
ToolHandle< CP::IIsolationCorrectionTool >	m_IsoLeakCorrectionTool
	Tool for pt-corrected isolation calculation (new)
Gaudi::Property< std::vector< int > >	m_EMCaloNums
	vector of calo-id to treat
Gaudi::Property< std::vector< int > >	m_HadCaloNums
	vector of calo-id to treat
std::string	m_CaloCalTopoCluster
	Topo Calo cluster location in event store.
Gaudi::Property< bool >	m_useEMScale
	Property: Use TopoClusters at the EM scale.
Gaudi::Property< bool >	m_doEnergyDensityCorrection
	Property: do the ED corrections to topoisolation.
Gaudi::Property< bool >	m_saveOnlyRequestedCorrections
	Property: save only requested corrections (trigger usage mainly)
Gaudi::Property< bool >	m_ExcludeTG3
	Property: exclude tile scintillator.
SG::ReadHandleKey< EventShape >	m_tpEDCentral
	Property: Name of the central topocluster energy-density container.
SG::ReadHandleKey< EventShape >	m_tpEDForward
	Property: Name of the forward topocluster energy-density container.
SG::ReadHandleKey< EventShape >	m_efEDCentral
	Property: Name of the central neutral energy flow energy-density container.
SG::ReadHandleKey< EventShape >	m_efEDForward
	Property: Name of the forward neutral energy flow energy-density container.
Gaudi::Property< double >	m_coneCoreSizeEg
	Property: The size of the coneCore core energy calculation.
Gaudi::Property< double >	m_coneCoreSizeMu
std::map< const IParticle *, const IParticle * >	m_derefMap
	map to the orignal particle
Gaudi::Property< bool >	m_InitializeReadHandles
	Property: Initialize read Handles.
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.
Gaudi::Property< bool >	m_useEtaDepPU
	Property: use pileup dependent correction.
Gaudi::Property< std::string >	m_puZetaCorrectionFileName
	name of the root file for the eta dependant pileup correction
Gaudi::Property< std::string >	m_puZetaMCCorrectionFileName
std::map< Iso::IsolationType, std::unique_ptr< TGraph > >	m_puZetaCorrection
	map of the zeta corrections (one / cone size)
std::map< Iso::IsolationType, std::unique_ptr< TGraph > >	m_puZetaMCCorrection
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

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/3]

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/3]

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/3]

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/3]

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/3]

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/3]

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

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

inlineprivateinherited

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

Definition at line 156 of file AthCommonDataStore.h.

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

declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

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.

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

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.

{ 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 ( void )

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

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

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/3]

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/3]

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/3]

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

void asg::AsgTool::print ( ) const

virtualinherited

Print the state of the tool.

Implements asg::IAsgTool.

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

Definition at line 131 of file AsgTool.cxx.

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

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 asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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.

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

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.

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

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.

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

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.

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

m_caloMgrKey

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

private

CaloDetDescrManager from ConditionStore.

Definition at line 304 of file CaloIsolationTool.h.

{this,"CaloDetDescrManager", "CaloDetDescrManager"};

m_clustersInConeTool

ToolHandle<ICaloClustersInConeTool> xAOD::CaloIsolationTool::m_clustersInConeTool

private

Initial value:

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

Definition at line 281 of file CaloIsolationTool.h.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

                                       {this,
      "ExcludeTG3", true, "Exclude the TileGap3 cells"};

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.

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

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.

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

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.

{this, "isMC", false, "is MC"};

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.

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

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.

                                                                   {this,
      "FlowElementsInConeTool", ""}; 

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

                                        {this,
      "UseEtaDepPUCorr", true, "Use the eta dependent pileup correction"};

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:

• CaloIsolationTool.h
• CaloIsolationTool.cxx