Calculate calibration hit based moments for CaloCluster objects using Primary Particle ID. More...

#include <CaloCalibClusterMomentsMaker2.h>

Inheritance diagram for CaloCalibClusterMomentsMaker2:

Collaboration diagram for CaloCalibClusterMomentsMaker2:

Classes
class	CalibHitIPhiIEtaRange
	Class to define range of valid bins in eta x phi plane. More...

class	MyCellInfo
	Class to store cluster number and weight for calorimeter cells. More...

class	MyClusInfo
	Class to store cluster's calibration energies. More...

Public Types
typedef std::map< Identifier, MyCellInfo >	CellInfoSet_t

typedef std::vector< MyClusInfo >	ClusInfo_t

typedef std::pair< std::string, xAOD::CaloCluster::MomentType >	moment_name_pair
	typedef for a pair to index the enums defined in CaloClusterMoment with a string. More...

typedef std::vector< moment_name_pair >	moment_name_vector
	vector of pairs defined above. More...

typedef std::set< moment_name_pair >	moment_name_set
	set of pairs defined above. More...

Public Member Functions
	CaloCalibClusterMomentsMaker2 (const std::string &type, const std::string &name, const IInterface *parent)

virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *theClusColl) const override
	Execute on an entire collection of clusters. More...

virtual StatusCode	initialize () override

virtual StatusCode	execute (const EventContext &ctx, xAOD::CaloClusterContainer *collection) const=0
	Execute on an entire collection of clusters. More...

virtual StatusCode	execute (xAOD::CaloClusterContainer *collection) final
	Execute on an entire collection of clusters. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

MsgStream &	msg () const

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

bool	msgLvl (const MSG::Level lvl) const

	DeclareInterfaceID (CaloClusterCollectionProcessor, 1, 0)

virtual StatusCode	execute (xAOD::CaloClusterContainer *collection) final
	Execute on an entire collection of clusters. More...

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution More...

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

void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed. More...

Private Types
enum	keys_dm_energy_sharing { kMatchDmOff, kMatchDmLoose, kMatchDmMedium, kMatchDmTight }

enum	keys_calib_frac_origin { kCalibFracEM, kCalibFracHAD, kCalibFracREST, kCalibFracMax }

typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

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

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

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

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

Static Private Member Functions
static double	angle_mollier_factor (double x)

Private Attributes
std::vector< std::string >	m_momentsNames
	vector holding the input list of names of moments to calculate. More...

moment_name_vector	m_validNames
	vector holding the names of valid moments which can be calculated. More...

moment_name_set	m_validMoments
	set of moments which will be calculated. More...

std::vector< std::string >	m_momentsNamesAOD
	vector holding the list of moment names which go in the first store i.e. More...

std::set< xAOD::CaloCluster::MomentType >	m_momentsAOD
	set holding the list of moment enums which go in the first store i.e. More...

SG::ReadHandleKeyArray< CaloCalibrationHitContainer >	m_CalibrationHitContainerNames
	vector of calibration hit container names to use. More...

SG::ReadHandleKeyArray< CaloCalibrationHitContainer >	m_DMCalibrationHitContainerNames
	vector of dead material calibration hit container names to use. More...

SG::ReadHandleKey< xAOD::TruthParticleContainer >	m_truthParticleContainerKey {this,"TruthParticles","TruthParticles","ReadHandleKey for truth particle container"}
	ReadHandleKey for truth particle container. More...

SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloDetDescrMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}
	Conditions Handle Key to access the CaloDetDescrManager. More...

const CaloCell_ID *	m_calo_id

const CaloDM_ID *	m_caloDM_ID

const CaloDmDescrManager *	m_caloDmDescrManager

int	m_n_phi_out

int	m_n_eta_out

double	m_out_phi_max

double	m_out_eta_max

double	m_rmaxOut [3]

std::array< std::vector< std::vector< CalibHitIPhiIEtaRange > >, 3 >	m_i_phi_eta

std::atomic< bool >	m_foundAllContainers {}

bool	m_doDeadEnergySharing

bool	m_doOutOfClusterL

bool	m_doOutOfClusterM

bool	m_doOutOfClusterT

bool	m_doDeadL

bool	m_doDeadM

bool	m_doDeadT

bool	m_useParticleID

bool	m_doCalibFrac

float	m_energyMin

float	m_energyMinCalib

float	m_apars_alpha

float	m_apars_r0

int	m_MatchDmType

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

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

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

bool	m_varHandleArraysDeclared

Detailed Description

Calculate calibration hit based moments for CaloCluster objects using Primary Particle ID.

Version: $Id: CaloCalibClusterMomentsMaker2.h,v 1.8 2009-05-18 16:16:48 pospelov Exp $

Author: Sven Menke menke.nosp@m.@mpp.nosp@m.mu.mp.nosp@m.g.de, Gennady Pospelov guenn.nosp@m.adi..nosp@m.pospe.nosp@m.lov@.nosp@m.cern..nosp@m.ch

Date: 17-June-2008 This is a CaloClusterCollectionProcessor which can be plugged into a CaloClusterMaker for calculating calibration hit based moments for each CaloCluster.

Definition at line 43 of file CaloCalibClusterMomentsMaker2.h.

Member Typedef Documentation

◆ CellInfoSet_t

typedef std::map<Identifier, MyCellInfo> CaloCalibClusterMomentsMaker2::CellInfoSet_t

Definition at line 64 of file CaloCalibClusterMomentsMaker2.h.

◆ ClusInfo_t

typedef std::vector<MyClusInfo> CaloCalibClusterMomentsMaker2::ClusInfo_t

Definition at line 94 of file CaloCalibClusterMomentsMaker2.h.

◆ moment_name_pair

typedef std::pair<std::string,xAOD::CaloCluster::MomentType> CaloCalibClusterMomentsMaker2::moment_name_pair

typedef for a pair to index the enums defined in CaloClusterMoment with a string.

Definition at line 100 of file CaloCalibClusterMomentsMaker2.h.

◆ moment_name_set

typedef std::set<moment_name_pair> CaloCalibClusterMomentsMaker2::moment_name_set

set of pairs defined above.

Definition at line 106 of file CaloCalibClusterMomentsMaker2.h.

◆ moment_name_vector

typedef std::vector<moment_name_pair> CaloCalibClusterMomentsMaker2::moment_name_vector

vector of pairs defined above.

Definition at line 103 of file CaloCalibClusterMomentsMaker2.h.

◆ StoreGateSvc_t

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

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ keys_calib_frac_origin

enum CaloCalibClusterMomentsMaker2::keys_calib_frac_origin

private

Enumerator
kCalibFracEM
kCalibFracHAD
kCalibFracREST
kCalibFracMax

Definition at line 200 of file CaloCalibClusterMomentsMaker2.h.

200 {kCalibFracEM, kCalibFracHAD, kCalibFracREST, kCalibFracMax};

◆ keys_dm_energy_sharing

enum CaloCalibClusterMomentsMaker2::keys_dm_energy_sharing

private

Enumerator
kMatchDmOff
kMatchDmLoose
kMatchDmMedium
kMatchDmTight

Definition at line 199 of file CaloCalibClusterMomentsMaker2.h.

199 {kMatchDmOff, kMatchDmLoose, kMatchDmMedium, kMatchDmTight};

Constructor & Destructor Documentation

◆ CaloCalibClusterMomentsMaker2()

CaloCalibClusterMomentsMaker2::CaloCalibClusterMomentsMaker2	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent
	)

Definition at line 55 of file CaloCalibClusterMomentsMaker2.cxx.

   : AthAlgTool(type, name, parent), 
     m_calo_id(nullptr),
     m_caloDM_ID(nullptr),
     m_caloDmDescrManager(nullptr),
     m_useParticleID(true),
     m_energyMin(200*MeV),
     m_energyMinCalib(20*MeV),
     m_apars_alpha(0.5),
     m_apars_r0(0.2),
     m_MatchDmType(kMatchDmLoose)
 {
   declareInterface<CaloClusterCollectionProcessor> (this);
   // Name(s) of Moments to calculate
   declareProperty("MomentsNames",m_momentsNames);
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_TOT"),xAOD::CaloCluster::ENG_CALIB_TOT));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_OUT_L"),xAOD::CaloCluster::ENG_CALIB_OUT_L));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_OUT_M"),xAOD::CaloCluster::ENG_CALIB_OUT_M));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_OUT_T"),xAOD::CaloCluster::ENG_CALIB_OUT_T));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_EMB0"),xAOD::CaloCluster::ENG_CALIB_EMB0));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_EME0"),xAOD::CaloCluster::ENG_CALIB_EME0));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_TILEG3"),xAOD::CaloCluster::ENG_CALIB_TILEG3));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TOT"),xAOD::CaloCluster::ENG_CALIB_DEAD_TOT));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EMB0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILE0"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_TILEG3"),xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_EME0"),xAOD::CaloCluster::ENG_CALIB_DEAD_EME0));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_HEC0"),xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_FCAL"),xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_LEAKAGE"),xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_DEAD_UNCLASS"),xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_FRAC_EM"),xAOD::CaloCluster::ENG_CALIB_FRAC_EM));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_FRAC_HAD"),xAOD::CaloCluster::ENG_CALIB_FRAC_HAD));
   m_validNames.push_back(moment_name_pair(std::string("ENG_CALIB_FRAC_REST"),xAOD::CaloCluster::ENG_CALIB_FRAC_REST));
  
   // Name(s) of Moments which can be stored on the AOD - all others go to ESD
   m_momentsNamesAOD.emplace_back("ENG_CALIB_TOT");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_OUT_L");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_OUT_M");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_OUT_T");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_EMB0");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_EME0");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_TILEG3");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_DEAD_TOT");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_DEAD_EMB0");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_DEAD_TILE0");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_DEAD_TILEG3");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_DEAD_EME0");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_DEAD_HEC0");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_DEAD_FCAL");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_DEAD_LEAKAGE");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_DEAD_UNCLASS");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_FRAC_EM");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_FRAC_HAD");
   m_momentsNamesAOD.emplace_back("ENG_CALIB_FRAC_REST");
  
   declareProperty("AODMomentsNames",m_momentsNamesAOD);
   declareProperty("CalibrationHitContainerNames",m_CalibrationHitContainerNames);
   declareProperty("DMCalibrationHitContainerNames",m_DMCalibrationHitContainerNames);
   m_n_phi_out = 127; // not more than 127 since we store indices (-127,...-1,0,...,126) and have 8 bits only
   m_n_eta_out = 127;
   m_out_phi_max =  M_PI;
   m_out_eta_max =  6;
  
   m_rmaxOut[0] = 1.0;
   m_rmaxOut[1] = 0.5; 
   m_rmaxOut[2] = 0.3;
  
   for( int im=0;im<3;im++) {
     m_i_phi_eta[im].resize(m_n_eta_out);
   }
   m_doDeadEnergySharing = false;
   m_foundAllContainers = false;
   m_doOutOfClusterL = false;
   m_doOutOfClusterM = false;
   m_doOutOfClusterT = false;
   m_doDeadL = false;
   m_doDeadM = false;
   m_doDeadT = false;
   m_doCalibFrac = false;
  
   declareProperty("MatchDmType",m_MatchDmType);
  
   declareProperty( "UseParticleID",m_useParticleID);
 }

Member Function Documentation

◆ angle_mollier_factor()

double CaloCalibClusterMomentsMaker2::angle_mollier_factor ( double x )

staticprivate

Definition at line 813 of file CaloCalibClusterMomentsMaker2.cxx.

 {
   double eta = fabs(x);
   double ff;
   if(eta<1.6){
     ff = atan(5.0*1.7/(200.0*cosh(eta)));
   }else if(eta<3.2){
     ff = atan(5.0*1.6/(420./tanh(eta)));
   }else{
     ff = atan(5.0*0.95/(505./tanh(eta)));
   }
   return ff*(1./atan(5.0*1.7/200.0));
 }

◆ declareGaudiProperty() [1/4]

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

inlineprivateinherited

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

◆ declareGaudiProperty() [3/4]

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

inlineprivateinherited

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

inlineprivateinherited

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

Definition at line 199 of file AthCommonDataStore.h.

   {
     return PBASE::declareProperty(t);
   }

◆ DeclareInterfaceID()

CaloClusterCollectionProcessor::DeclareInterfaceID	(	CaloClusterCollectionProcessor	,
		1	,
		0
	)

inherited

◆ declareProperty() [1/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

inlineinherited

Declare a new Gaudi property.

Parameters

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

inlineinherited

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute() [1/4]

virtual StatusCode CaloClusterCollectionProcessor::execute

Execute on an entire collection of clusters.

Parameters

collection The container of clusters. param ctx The event context.

◆ execute() [2/4]

StatusCode CaloCalibClusterMomentsMaker2::execute	(	const EventContext &	ctx,
		xAOD::CaloClusterContainer *	collection
	)		const

overridevirtual

Execute on an entire collection of clusters.

Parameters

collection The container of clusters. param ctx The event context.

Implements CaloClusterCollectionProcessor.

Definition at line 277 of file CaloCalibClusterMomentsMaker2.cxx.

 {  
  
   ATH_MSG_DEBUG("Starting CaloCalibClusterMomentsMaker2::execute");
   SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloDetDescrMgrKey,ctx};
   const CaloDetDescrManager* calo_dd_man = *caloMgrHandle;
  
   bool foundAllContainers (true);
   std::vector<const CaloCalibrationHitContainer *> v_cchc;
   for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& key :
          m_CalibrationHitContainerNames)
   {
     SG::ReadHandle<CaloCalibrationHitContainer> cchc (key, ctx);
     if ( !cchc.isValid() ) {
       if (m_foundAllContainers) {
     // print ERROR message only if there was at least one event with 
     // all containers 
     msg(MSG::ERROR) << "SG does not contain calibration hit container " << key.key() << endmsg;
       }
       foundAllContainers = false;
     }
     else {
       v_cchc.push_back(cchc.cptr());
     }
   }
  
   std::vector<const CaloCalibrationHitContainer *> v_dmcchc;
   for (const SG::ReadHandleKey<CaloCalibrationHitContainer>& key :
          m_DMCalibrationHitContainerNames)
   {
     SG::ReadHandle<CaloCalibrationHitContainer> cchc (key, ctx);
     if ( !cchc.isValid() ) {
       if (m_foundAllContainers) {
     // print ERROR message only if there was at least one event with 
     // all containers 
     ATH_MSG_ERROR("SG does not contain DM calibration hit container " << key.key());
       }
       foundAllContainers = false;
     }
     else {
       v_dmcchc.push_back(cchc.cptr());
     }
   }
  
   if ( !m_foundAllContainers && foundAllContainers ) 
     m_foundAllContainers = true;
  
   if ( !foundAllContainers ) return StatusCode::SUCCESS;
   ATH_MSG_DEBUG("SG has all containers ");
  
   // will contain detailed info about cluster calibration eneries
   ClusInfo_t clusInfoVec (theClusColl->size());
  
   CellInfoSet_t cellInfo;
  
   /* ********************************************
   filling the map with info which cell belongs to which cluster and what 
   is the cell weight in the cluster
   ******************************************** */
   xAOD::CaloClusterContainer::iterator clusIter = theClusColl->begin();
   xAOD::CaloClusterContainer::iterator clusIterEnd = theClusColl->end();
   int iClus = 0;
   for( ;clusIter!=clusIterEnd;++clusIter,++iClus) {
      const xAOD::CaloCluster * theCluster = (*clusIter);
  
     // loop over all cell members and fill cell vector for used cells
     xAOD::CaloCluster::const_cell_iterator cellIter    = theCluster->cell_begin();
     xAOD::CaloCluster::const_cell_iterator cellIterEnd = theCluster->cell_end();
     for(; cellIter != cellIterEnd; cellIter++ ){
       const CaloCell* pCell = (*cellIter);
       Identifier myId = pCell->ID();
  
       MyCellInfo info (iClus, cellIter.weight() );
       CellInfoSet_t::iterator bookmark = cellInfo.lower_bound( myId );
       if(bookmark == cellInfo.end() || bookmark->first != myId) {
         // We haven't had a infohit in this cell before.  Add it to our set.
         if (bookmark != cellInfo.begin()) --bookmark;
         cellInfo.emplace_hint (bookmark, myId, std::move(info));
       }else{
         // Update the existing hit.
         bookmark->second.Add( info );
       }
     } // cellIter
   } // iClus
  
  
   /* ********************************************
   calculate total calib energy inside clusters
   ******************************************** */
   unsigned int nHitsTotal = 0;
   unsigned int nHitsWithoutParticleUID = 0;
   for (const CaloCalibrationHitContainer* cchc : v_cchc) {
     //loop over cells in calibration container
     for (const CaloCalibrationHit* hit : *cchc) {
       Identifier myId = hit->cellID();
  
       CellInfoSet_t::iterator pos = cellInfo.find( myId );
       if(pos != cellInfo.end() ) {
         // i.e. given hit id belongs to one or more clusters
         CaloSampling::CaloSample nsmp = CaloSampling::CaloSample(m_calo_id->calo_sample(myId));
         for ( const std::pair<int, double>& p : pos->second) {
           int iClus = p.first;
           double weight = p.second;
           if(m_useParticleID){
             const int uniqueID = HepMC::uniqueID(hit);
             if (uniqueID == HepMC::INVALID_PARTICLE_ID) {
               ATH_MSG_ERROR("Invalid uniqueID detected - this sample cannot be properly analysed.");
               break;
             }
             clusInfoVec[iClus].Add(weight * hit->energyTotal(), nsmp, (unsigned int)(HepMC::uniqueID(hit)));
           }else{
             clusInfoVec[iClus].Add(weight * hit->energyTotal(), nsmp);
           }
         }
       }
       if( m_useParticleID && HepMC::uniqueID(hit) == HepMC::UNDEFINED_ID) {
         nHitsWithoutParticleUID++;
       }
       nHitsTotal++;
     }
   }
  
   // if all calibration hits have ParticleUID(i.e GenParticle::id())==0 when simulation was done without ParticleUID
   bool doCalibFrac = m_doCalibFrac;
   bool useParticleID = m_useParticleID;
   if(m_useParticleID && (nHitsTotal == nHitsWithoutParticleUID) ) {
     ATH_MSG_INFO("Calibration hits do not have ParticleUID, ids of particle-caused hits are always 0. Continuing without ParticleID machinery.");
     useParticleID = false;
   }
  
   // reading particle information for later calcution of calibration enegry fraction caused
   // by particles of different types
   SG::ReadHandle<xAOD::TruthParticleContainer> truthParticleContainerReadHandle(m_truthParticleContainerKey, ctx);
  
   if (doCalibFrac && !truthParticleContainerReadHandle.isValid()){
     ATH_MSG_WARNING("Invalid read handle to TruthParticleContainer with key: " << m_truthParticleContainerKey.key());
     doCalibFrac = false;
   }
  
   std::vector<double> engCalibOut[3];
  
   /* ****************************************************************
   lists of clusters populating given area [eta*phi][iClus list]
   **************************************************************** */
   std::vector<std::vector <int > > clusListL;
   std::vector<std::vector <int > > clusListM;
   std::vector<std::vector <int > > clusListT;
   if ( m_doOutOfClusterL || m_doDeadL || (m_doDeadEnergySharing && m_MatchDmType==kMatchDmLoose) )
     clusListL.resize((2*m_n_phi_out+1)*(2*m_n_eta_out+1));
   if ( m_doOutOfClusterM || m_doDeadM || (m_doDeadEnergySharing && m_MatchDmType==kMatchDmMedium) )
     clusListM.resize((2*m_n_phi_out+1)*(2*m_n_eta_out+1));
   if ( m_doOutOfClusterT || m_doDeadT || (m_doDeadEnergySharing && m_MatchDmType==kMatchDmTight) )
     clusListT.resize((2*m_n_phi_out+1)*(2*m_n_eta_out+1));
  
   for(unsigned int ii=0;ii<3;ii++) {
     if ( (ii == 0 && (m_doOutOfClusterL || m_doDeadL || (m_doDeadEnergySharing && m_MatchDmType==kMatchDmLoose) ) ) || 
          (ii == 1 && (m_doOutOfClusterM || m_doDeadM || (m_doDeadEnergySharing && m_MatchDmType==kMatchDmMedium) ) ) || 
          (ii == 2 && (m_doOutOfClusterT || m_doDeadT || (m_doDeadEnergySharing && m_MatchDmType==kMatchDmTight)) ) ) {
       engCalibOut[ii].resize(theClusColl->size(),0);
       iClus = -1;
       for (const xAOD::CaloCluster * theCluster : *theClusColl) {
     ++iClus;
         MyClusInfo& clusInfo = clusInfoVec[iClus];
  
         if ( clusInfo.engCalibIn.engTot > 0 ) {
           int iEtaSign = 1;
           if ( theCluster->eta() < 0 ) iEtaSign = -1;
           int jeta = (int)(floor(m_n_eta_out*(theCluster->eta()/(m_out_eta_max))));
           int jphi = (int)(floor(m_n_phi_out*(theCluster->phi())/(m_out_phi_max)));
           if ( jeta >= -m_n_eta_out && jeta < m_n_eta_out ) {
             if ( jphi < -m_n_phi_out ) jphi +=  2*m_n_phi_out;
             if ( jphi >=  m_n_phi_out ) jphi -=  2*m_n_phi_out;
             unsigned int iEtaBin(jeta);
             if ( jeta < 0 ) iEtaBin = abs(jeta)-1;
             const std::vector<CalibHitIPhiIEtaRange>& bins
               = m_i_phi_eta[ii][iEtaBin];
             for (const CalibHitIPhiIEtaRange& range : bins) {
               int jp = range.iPhi+jphi;
               if ( jp < -m_n_phi_out )  jp +=  2*m_n_phi_out;
               if ( jp >=  m_n_phi_out )  jp -=  2*m_n_phi_out;
               int jEtaMin = iEtaSign<0?-range.iEtaMax-1:range.iEtaMin;
               int jEtaMax = iEtaSign<0?-range.iEtaMin-1:range.iEtaMax;
               for( int je = jEtaMin;je<=jEtaMax;je++ ) {
               if(ii == 0 ) clusListL[(jp+m_n_phi_out)*(2*m_n_eta_out+1)+je+m_n_eta_out].push_back(iClus);
               else if(ii == 1 ) clusListM[(jp+m_n_phi_out)*(2*m_n_eta_out+1)+je+m_n_eta_out].push_back(iClus);
               else if(ii == 2 ) clusListT[(jp+m_n_phi_out)*(2*m_n_eta_out+1)+je+m_n_eta_out].push_back(iClus);
               }
             }
           }
         }
       }
     }
   }
  
   /* ****************************************************************
   calculate out-of-cluster energy of clusters
   **************************************************************** */
   if ( m_doOutOfClusterL  ||  m_doOutOfClusterM  ||  m_doOutOfClusterT  ) {
     for (const CaloCalibrationHitContainer* cchc : v_cchc) {
       //loop over cells in calibration container
       for (const CaloCalibrationHit* hit : *cchc) {
         Identifier myId = hit->cellID();
  
           CellInfoSet_t::iterator pos = cellInfo.find( myId );
           if(pos == cellInfo.end() ) {
             // hit is not inside any cluster
             const CaloDetDescrElement* myCDDE = 
               calo_dd_man->get_element(myId);
             int uniqueID(HepMC::UNDEFINED_ID);
             if(useParticleID) uniqueID = HepMC::uniqueID(hit);
             if ( myCDDE ) {
               int jeO = (int)floor(m_n_eta_out*(myCDDE->eta()/m_out_eta_max));
               if ( jeO >= -m_n_eta_out && jeO < m_n_eta_out ) {
                 int jpO = (int)floor(m_n_phi_out*(myCDDE->phi()/m_out_phi_max));
                 if ( jpO < -m_n_phi_out ) jpO +=  2*m_n_phi_out;
                 if ( jpO >=  m_n_phi_out ) jpO -=  2*m_n_phi_out;
                 for (unsigned int ii=0;ii<3;ii++) {
                   std::vector<std::vector <int > > *pClusList=nullptr;
                   if ( ii == 0 && m_doOutOfClusterL ) 
                     pClusList = &clusListL;
                   else if ( ii == 1 && m_doOutOfClusterM ) 
                     pClusList = &clusListM;
                   else if ( ii == 2 && m_doOutOfClusterT ) 
                     pClusList = &clusListT;
                   if ( pClusList) {
                     // loop over list of potential neighboring clusters
                     double hitClusNorm(0.);
                     std::vector<int> hitClusIndex;
                     std::vector<double > hitClusEffEnergy;
                     // loop over clusters which match given OOC hit
                     for(unsigned int i_cls=0; i_cls<(*pClusList)[(jpO+m_n_phi_out)*(2*m_n_eta_out+1)+jeO+m_n_eta_out].size(); i_cls++){
                       int iClus = (*pClusList)[(jpO+m_n_phi_out)*(2*m_n_eta_out+1)+jeO+m_n_eta_out][i_cls];
                       MyClusInfo& clusInfo = clusInfoVec[iClus];
                       // getting access to calibration energy inside cluster caused by same particleUID (uniqueID)
                       // as given OOC hit
                       auto pos = clusInfo.engCalibParticle.find(uniqueID);
                       if(pos!=clusInfo.engCalibParticle.end()) {
                         // given cluster have some energy inside caused by same particle as given OOC hitClusEffEnergy
                         // so the hit will be assigned to this cluster with some weight
                         hitClusNorm += pos->second.engTot;
                         hitClusEffEnergy.push_back(pos->second.engTot);
                         hitClusIndex.push_back(iClus);
                       }
                     }
                     if ( hitClusNorm > 0 ) {
                       const double inv_hitClusNorm = 1. / hitClusNorm;
                       for(unsigned int i_cls=0; i_cls<hitClusIndex.size(); i_cls++){
                         int iClus = hitClusIndex[i_cls];
                         double w = hitClusEffEnergy[i_cls] * inv_hitClusNorm;
                         engCalibOut[ii][iClus] += w*hit->energyTotal();
                     }
                   }
                 }
               }
             }
           }
         } // hits not in cluster
       }
     }
   }
  
   // ------------------------------------------------------------------------
   // calculate dead-material energy of clusters (way2)
   // + energy is shared among clusters within certain area
   // + distance to clusters and energy in specific samplings are used as sharing criteria
   // + calculations are done separately for different dead material areas
   std::vector<std::vector <int > > *pClusList=nullptr;
   if ( m_MatchDmType == kMatchDmLoose ) {
     pClusList = &clusListL;
   } else if ( m_MatchDmType == kMatchDmMedium ) {
     pClusList = &clusListM;
   } else if ( m_MatchDmType == kMatchDmTight ) {
     pClusList = &clusListT;
   }
   if( m_doDeadEnergySharing && pClusList) {
  
     for (const CaloCalibrationHitContainer* dmcchc : v_dmcchc) {
       for (const CaloCalibrationHit* hit : *dmcchc) {
         Identifier myId = hit->cellID();
         if (m_calo_id->is_lar_dm(myId) || m_calo_id->is_tile_dm(myId)) {
           CaloDmDescrElement* myCDDE(nullptr);
           myCDDE = m_caloDmDescrManager->get_element(myId);
           if ( myCDDE ) {
             int uniqueID(HepMC::UNDEFINED_ID);
             if(useParticleID) uniqueID = HepMC::uniqueID(hit);
  
             int jeO = (int)floor(m_n_eta_out*(myCDDE->eta()/m_out_eta_max));
             if ( jeO >= -m_n_eta_out && jeO < m_n_eta_out ) {
               int jpO = (int)floor(m_n_phi_out*(myCDDE->phi()/m_out_phi_max));
               if ( jpO < -m_n_phi_out ) jpO +=  2*m_n_phi_out;
               if ( jpO >=  m_n_phi_out ) jpO -=  2*m_n_phi_out;
  
               /* ****************************************
               share energy of DM hit among different clusters
               ***************************************** */
               int nDmArea = m_caloDmDescrManager->get_dm_area(myId);
               const CaloDmRegion *dmRegion = m_caloDmDescrManager->get_dm_region(myId);
           int hitClusVecIndex = 0;
               std::vector<int> hitClusIndex(theClusColl->size());
               std::vector<double > hitClusEffEnergy(theClusColl->size());
               double hitClusNorm = 0.0;
               // loop over clusters which match given DM hit
               for(unsigned int i_cls=0; i_cls< (*pClusList)[(jpO+m_n_phi_out)*(2*m_n_eta_out+1)+jeO+m_n_eta_out].size(); i_cls++){
         int iClus = (*pClusList)[(jpO+m_n_phi_out)*(2*m_n_eta_out+1)+jeO+m_n_eta_out][i_cls];
                 xAOD::CaloCluster * theCluster = theClusColl->at(iClus);
                 
                 MyClusInfo& clusInfo = clusInfoVec[iClus];
                 // getting access to calibration energy inside cluster caused by same particleUID (uniqueID)
                 // as given OOC hit
                 auto pos = clusInfo.engCalibParticle.find(uniqueID);
                 if(pos!=clusInfo.engCalibParticle.end()) {
                   double engClusTruthUniqueIDCalib = pos->second.engTot;
  
                   if(engClusTruthUniqueIDCalib > m_energyMinCalib  && theCluster->e()>m_energyMin) {
                     double sum_smp_energy = 0.0;
                     // loop over calo sampling numbers registered for given DM area
                     for(unsigned int i_smp=0; i_smp<dmRegion->m_CaloSampleNeighbours.size(); i_smp++) {
                       CaloSampling::CaloSample nsmp = (CaloSampling::CaloSample) dmRegion->m_CaloSampleNeighbours[i_smp];
               if( (dmRegion->m_CaloSampleEtaMin[i_smp]-0.5) <= theCluster->eta()  &&
                           theCluster->eta() <= (dmRegion->m_CaloSampleEtaMax[i_smp]+0.5) ){
                         //sum_smp_energy += theCluster->eSample(nsmp);
                         sum_smp_energy += pos->second.engSmp[nsmp];
                       }
                     }
                     if(sum_smp_energy > 0.0) {
                       double phi_diff=myCDDE->phi()-theCluster->phi();
                       if(phi_diff <= -M_PI){
                         phi_diff += 2.*M_PI;
                       } else if (phi_diff > M_PI){
                         phi_diff -= 2.*M_PI;
                       }
                       double eta_diff = (myCDDE->eta()-theCluster->eta());
               float distance=sqrt(eta_diff * eta_diff + phi_diff * phi_diff);
  
                       double effEner = pow(sum_smp_energy,m_apars_alpha)*exp(-distance/m_apars_r0);
                       
                       hitClusIndex [hitClusVecIndex] = iClus;
                       hitClusEffEnergy [hitClusVecIndex++]= effEner;
                       hitClusNorm += effEner;
                     }
                   } // good energetic cluster
         } // we ve found a uniqueID
               } // loop over clusters in the list
               hitClusIndex.resize(hitClusVecIndex);
               hitClusEffEnergy.resize(hitClusVecIndex);
  
  
               // now we have to calculate weight for assignment hit energy to cluster
               if(hitClusNorm >0.0) {
                 const double inv_hitClusNorm = 1. / hitClusNorm;
                 for(unsigned int i_cls=0; i_cls<hitClusIndex.size(); i_cls++){
                   int iClus = hitClusIndex[i_cls];
                   double dm_weight = hitClusEffEnergy[i_cls] * inv_hitClusNorm;
                   if(dm_weight > 1.0 || dm_weight < 0.0 ){
                     std::cout << "CaloCalibClusterMomentsMaker2::execute() ->Error! Strange weight " <<  dm_weight<< std::endl;
                     std::cout << hitClusEffEnergy[i_cls] << " " << hitClusNorm << std::endl;
                   }
                   clusInfoVec[iClus].engCalibDeadInArea[nDmArea] += hit->energyTotal()*dm_weight;
                   clusInfoVec[iClus].engCalibDeadInArea[CaloDmDescrArea::DMA_ALL] += hit->energyTotal()*dm_weight;
                 }
               } // hit clus norm
  
             } // loop over united ieta*iphi
           } // myCDDE
         } // tile and lar
       } // eol over DM calibration hits
     } //eol over containers
  
   } // doDeadEnergySharing
  
   // fraction of calibration energies caused by different particles
   std::vector<double> engCalibFrac;
   engCalibFrac.resize(kCalibFracMax, 0.0);
  
   std::map<unsigned int,int> truthIDToPdgCodeMap;
   
   //loop on truth particle container is slow, so put needed information in a map for faster key lookup in later loops
   for ( const auto *thisTruthParticle : *truthParticleContainerReadHandle){   
  
     if (!thisTruthParticle){
       ATH_MSG_WARNING("Got invalid pointer to TruthParticle");
       continue;
     }
     
     truthIDToPdgCodeMap[HepMC::uniqueID(thisTruthParticle)] = thisTruthParticle->pdgId();
   }//truth particle loop
   
   // assign moments
   for( clusIter = theClusColl->begin(),iClus=0;  clusIter!=clusIterEnd;++clusIter,++iClus) {
     xAOD::CaloCluster * theCluster = *clusIter;
     MyClusInfo& clusInfo = clusInfoVec[iClus];
  
     // total DM energy assigned to cluster
     double eng_calib_dead_tot = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_ALL]
           + clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerB]
           + clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerE]
           + clusInfo.engCalibIn.engSmp[CaloSampling::TileGap3];
     // DM energy before barrel presampler, inside it, and between presampler and strips
     double eng_calib_dead_emb0 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EMB0]
           + clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EMB1]
           + clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerB];
     // DM energy between barrel and tile
     double eng_calib_dead_tile0 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EMB3_TILE0];
     // DM energy before scintillator and inside scintillator
     double eng_calib_dead_tileg3 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_SCN]
           + clusInfo.engCalibIn.engSmp[CaloSampling::TileGap3];
     // DM energy beforee endcap presampler, inside it and between presampler and strips
     double eng_calib_dead_eme0 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EME0]
           + clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EME12]
           + clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerE];
     // DM energy between emec and hec
     double eng_calib_dead_hec0 = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_EME3_HEC0];
     // DM energy before FCAL and between HEC and FCAL
     double eng_calib_dead_fcal = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_FCAL0]
           + clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_HEC_FCAL];
     // DM leakage behind the calorimeter
     double eng_calib_dead_leakage = clusInfo.engCalibDeadInArea[CaloDmDescrArea::DMA_LEAK];
     // the rest of DM energy which remains unclassified
     double eng_calib_dead_unclass = eng_calib_dead_tot - eng_calib_dead_emb0 - eng_calib_dead_tile0 
           - eng_calib_dead_tileg3 - eng_calib_dead_eme0 - eng_calib_dead_hec0 - eng_calib_dead_fcal
           - eng_calib_dead_leakage;
  
     if(doCalibFrac){
 /*****************************************************************************
 Calculation of energy fraction caused by particles of different types
 *****************************************************************************/
       engCalibFrac.assign(kCalibFracMax, 0.0);
       if(clusInfo.engCalibIn.engTot > 0.0) {
         // each MyClusInfo has a map of particle's uniqueID (GenParticle::id()) and particle calibration deposits in given cluster
         for (const auto& p : clusInfo.engCalibParticle) {
           int pdg_id = 0;
           if ( auto it = truthIDToPdgCodeMap.find(p.first); it != truthIDToPdgCodeMap.end()) {
             pdg_id = it->second;
           } else {   
             ATH_MSG_WARNING("truthIDToPdgCodeMap cannot find an entry with uniqueID " << p.first);
             continue;
           }
           if( std::abs(pdg_id) == 211) {
             engCalibFrac[kCalibFracHAD] += p.second.engTot;
           } else if( pdg_id == 111 || pdg_id == 22 || std::abs(pdg_id)==11) {
             engCalibFrac[kCalibFracEM] += p.second.engTot;
           } else {
             engCalibFrac[kCalibFracREST] += p.second.engTot;
           }
         }
         for(size_t i=0; i<engCalibFrac.size(); i++) engCalibFrac[i] = engCalibFrac[i]/clusInfo.engCalibIn.engTot;
       }
     }
  
     if ( !m_momentsNames.empty() ) {
       std::vector<double> myMoments(m_validMoments.size(),0);
       // assign moments 
       moment_name_set::const_iterator vMomentsIter = m_validMoments.begin(); 
       moment_name_set::const_iterator vMomentsIterEnd = m_validMoments.end();
  
       int iMoment=0;
       for(; vMomentsIter!=vMomentsIterEnd; ++vMomentsIter,++iMoment) {
         // now calculate the actual moments
         switch (vMomentsIter->second) { 
         case xAOD::CaloCluster::ENG_CALIB_TOT:
           ATH_MSG_DEBUG("Inserting ENG_CALIB_TOT");
           myMoments[iMoment] = clusInfo.engCalibIn.engTot;
           break;
         case xAOD::CaloCluster::ENG_CALIB_OUT_L:
           myMoments[iMoment] = engCalibOut[0][iClus];
           break;
         case xAOD::CaloCluster::ENG_CALIB_OUT_M:
           myMoments[iMoment] = engCalibOut[1][iClus];
           break;
         case xAOD::CaloCluster::ENG_CALIB_OUT_T:
           myMoments[iMoment] = engCalibOut[2][iClus];
           break;
         case xAOD::CaloCluster::ENG_CALIB_EMB0:
           myMoments[iMoment] = clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerB];
           break;
         case xAOD::CaloCluster::ENG_CALIB_EME0:
           myMoments[iMoment] = clusInfo.engCalibIn.engSmp[CaloSampling::PreSamplerE];
           break;
         case xAOD::CaloCluster::ENG_CALIB_TILEG3:
           myMoments[iMoment] = clusInfo.engCalibIn.engSmp[CaloSampling::TileGap3];
           break;
         case xAOD::CaloCluster::ENG_CALIB_DEAD_TOT:
           myMoments[iMoment] = eng_calib_dead_tot;
           break;
         case xAOD::CaloCluster::ENG_CALIB_DEAD_EMB0:
           myMoments[iMoment] = eng_calib_dead_emb0;
           break;
         case xAOD::CaloCluster::ENG_CALIB_DEAD_TILE0:
           myMoments[iMoment] = eng_calib_dead_tile0;
           break;
         case xAOD::CaloCluster::ENG_CALIB_DEAD_TILEG3:
           myMoments[iMoment] = eng_calib_dead_tileg3;
           break;
         case xAOD::CaloCluster::ENG_CALIB_DEAD_EME0:
           myMoments[iMoment] = eng_calib_dead_eme0;
           break;
         case xAOD::CaloCluster::ENG_CALIB_DEAD_HEC0:
           myMoments[iMoment] = eng_calib_dead_hec0;
           break;
         case xAOD::CaloCluster::ENG_CALIB_DEAD_FCAL:
           myMoments[iMoment] = eng_calib_dead_fcal;
           break;
         case xAOD::CaloCluster::ENG_CALIB_DEAD_LEAKAGE:
           myMoments[iMoment] = eng_calib_dead_leakage;
           break;
         case xAOD::CaloCluster::ENG_CALIB_DEAD_UNCLASS:
           myMoments[iMoment] = eng_calib_dead_unclass;
           break;
         case xAOD::CaloCluster::ENG_CALIB_FRAC_EM:
           myMoments[iMoment] = engCalibFrac[kCalibFracEM];
           break;
         case xAOD::CaloCluster::ENG_CALIB_FRAC_HAD:
           myMoments[iMoment] = engCalibFrac[kCalibFracHAD];
           break;
         case xAOD::CaloCluster::ENG_CALIB_FRAC_REST:
           myMoments[iMoment] = engCalibFrac[kCalibFracREST];
           break;
         default:
           // nothing to be done for other moments
           break;
         }
  
         theCluster->insertMoment(vMomentsIter->second, myMoments[iMoment]);
       }
     }
   }
  
   return StatusCode::SUCCESS;
 }

◆ execute() [3/4]

virtual StatusCode CaloClusterCollectionProcessor::execute ( xAOD::CaloClusterContainer * collection )

inlinefinalvirtualinherited

Execute on an entire collection of clusters.

Parameters

collection The container of clusters. (deprecated)

Definition at line 50 of file CaloClusterCollectionProcessor.h.

   {
     return execute (Gaudi::Hive::currentContext(), collection);
   }

◆ execute() [4/4]

virtual StatusCode CaloClusterCollectionProcessor::execute

inlinefinal

Execute on an entire collection of clusters.

Parameters

collection The container of clusters. (deprecated)

Definition at line 50 of file CaloClusterCollectionProcessor.h.

   {
     return execute (Gaudi::Hive::currentContext(), collection);
   }

◆ 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

◆ initialize()

StatusCode CaloCalibClusterMomentsMaker2::initialize ( )

overridevirtual

Definition at line 147 of file CaloCalibClusterMomentsMaker2.cxx.

 {
   ATH_MSG_INFO( "Initializing " << name()  );
  
   for (const std::string& name : m_momentsNames) {
     bool isValid(false);
     for (const moment_name_pair& vname : m_validNames) {
       if ( name == vname.first ) {
     m_validMoments.insert(vname);
     isValid = true;
         ATH_MSG_DEBUG( "Inserting " << name );
     break;
       }
     }
     if ( !isValid) {
       msg() << MSG::ERROR << "Moment " << name
       << " is not a valid Moment name and will be ignored! "
       << "Valid names are:";
       for (unsigned int i=0;i<m_validNames.size();i++) 
     msg() << (i==0?" ":", ") << m_validNames[i].first;
       msg() << endmsg;
     }
   }
  
   // to switch on clever DeadMaterial assignment procedure
   // and check if tight, medium and/or loose versions for out-of-cluster and 
   // simple dead-material assignment are wanted
   for (const moment_name_pair& vname : m_validNames) {
     switch (vname.second) {
     case xAOD::CaloCluster::ENG_CALIB_DEAD_TOT:
       m_doDeadEnergySharing = true;
       break;
     case xAOD::CaloCluster::ENG_CALIB_OUT_L:
       m_doOutOfClusterL = true;
       break;
     case xAOD::CaloCluster::ENG_CALIB_OUT_M:
       m_doOutOfClusterM = true;
       break;
     case xAOD::CaloCluster::ENG_CALIB_OUT_T:
       m_doOutOfClusterT = true;
       break;
     case xAOD::CaloCluster::ENG_CALIB_FRAC_EM:
       m_doCalibFrac = true;
       break;
     case xAOD::CaloCluster::ENG_CALIB_FRAC_HAD:
       m_doCalibFrac = true;
       break;
     case xAOD::CaloCluster::ENG_CALIB_FRAC_REST:
       m_doCalibFrac = true;
       break;
     default:
       break;
     }
   }
   
   if(m_doCalibFrac && !m_useParticleID) {
     ATH_MSG_INFO( "Usage of ParticleID was switched off (UseParticleID==False), no ENG_CALIB_FRAC_* moments will be available"  );
     m_doCalibFrac = false;
   }
  
   for (const std::string& name : m_momentsNamesAOD) {
     for (const moment_name_pair& vname : m_validNames) {
       if ( vname.first == name ) {
     m_momentsAOD.insert(vname.second);
     break;
       }
     }
   }
   if( m_momentsAOD.find(xAOD::CaloCluster::ENG_CALIB_DEAD_TOT) != m_momentsAOD.end()) {
     m_doDeadEnergySharing = true;
   }
  
   // dead material identifier description manager
   m_caloDmDescrManager = CaloDmDescrManager::instance(); 
  
   ATH_CHECK( detStore()->retrieve(m_calo_id, "CaloCell_ID") );
   ATH_CHECK( detStore()->retrieve(m_caloDM_ID) );
  
   // initialize distance tables
   for(int jeta = 0;jeta<m_n_eta_out;jeta++) {
     double eta0 = (jeta+0.5) * (m_out_eta_max)/m_n_eta_out; 
     HepLorentzVector middle(1,0,0,1);
     middle.setREtaPhi(1./cosh(eta0),eta0,0);
     double x_rmaxOut[3];
     for (int im=0;im<3;im++) {
       x_rmaxOut[im] = m_rmaxOut[im]*angle_mollier_factor(eta0);
     }
     for (int jp=-m_n_phi_out;jp<m_n_phi_out;jp++) {
       double phi = (jp+0.5) * m_out_phi_max/m_n_phi_out; 
       int ietaMin[3] = {m_n_eta_out,m_n_eta_out,m_n_eta_out};
       int ietaMax[3] = {-m_n_eta_out,-m_n_eta_out,-m_n_eta_out};
       for(int je = -m_n_eta_out;je<m_n_eta_out;je++) {
         double eta = (je+0.5) * m_out_eta_max/m_n_eta_out; 
         HepLorentzVector cpoint(1,0,0,1);
         cpoint.setREtaPhi(1./cosh(eta),eta,phi);
         double r = middle.angle(cpoint.vect());
         for (int im=0;im<3;im++) {
           if ( r < x_rmaxOut[im] ) {
             if ( je < ietaMin[im] ) 
               ietaMin[im] = je;
             if ( je > ietaMax[im] ) 
               ietaMax[im] = je;
           }
         }
       }
       for (int im=0;im<3;im++) {
         if ( ietaMin[im] <= ietaMax[im] ) {
           CalibHitIPhiIEtaRange theRange{};
           theRange.iPhi = (char)jp;
           theRange.iEtaMin = (char)ietaMin[im];
           theRange.iEtaMax = (char)ietaMax[im];
           m_i_phi_eta[im][jeta].push_back(theRange); 
         }
       }
     }
   }
  
   ATH_CHECK( m_CalibrationHitContainerNames.initialize() );
   ATH_CHECK( m_DMCalibrationHitContainerNames.initialize() );
  
   ATH_CHECK(m_truthParticleContainerKey.initialize());
  
   ATH_CHECK(m_caloDetDescrMgrKey.initialize());
  
   return StatusCode::SUCCESS;
 }

◆ inputHandles()

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

overridevirtualinherited

Return this algorithm's input handles.

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

◆ msg() [1/2]

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                 {
     return this->msgStream();
   }

◆ msg() [2/2]

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

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                   {
     return this->msgStream(lvl);
   }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                                {
     return this->msgLevel(lvl);
   }

◆ outputHandles()

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

◆ renounce()

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

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                           {
     handlesArray.renounce();
   }

◆ sysInitialize()

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

overridevirtualinherited

Perform system initialization for an algorithm.

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

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

◆ sysStart()

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

overridevirtualinherited

Handle START transition.

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

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

float CaloCalibClusterMomentsMaker2::m_apars_alpha

private

Definition at line 213 of file CaloCalibClusterMomentsMaker2.h.

◆ m_apars_r0

float CaloCalibClusterMomentsMaker2::m_apars_r0

private

Definition at line 214 of file CaloCalibClusterMomentsMaker2.h.

◆ m_CalibrationHitContainerNames

SG::ReadHandleKeyArray<CaloCalibrationHitContainer> CaloCalibClusterMomentsMaker2::m_CalibrationHitContainerNames

private

vector of calibration hit container names to use.

The containers specified in this property should hold calibration hits inside the calorimeter systems.

Definition at line 167 of file CaloCalibClusterMomentsMaker2.h.

◆ m_calo_id

const CaloCell_ID* CaloCalibClusterMomentsMaker2::m_calo_id

private

Definition at line 182 of file CaloCalibClusterMomentsMaker2.h.

◆ m_caloDetDescrMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> CaloCalibClusterMomentsMaker2::m_caloDetDescrMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager"}

private

Conditions Handle Key to access the CaloDetDescrManager.

Definition at line 180 of file CaloCalibClusterMomentsMaker2.h.

◆ m_caloDM_ID

const CaloDM_ID* CaloCalibClusterMomentsMaker2::m_caloDM_ID

private

Definition at line 184 of file CaloCalibClusterMomentsMaker2.h.

◆ m_caloDmDescrManager

const CaloDmDescrManager* CaloCalibClusterMomentsMaker2::m_caloDmDescrManager

private

Definition at line 186 of file CaloCalibClusterMomentsMaker2.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_DMCalibrationHitContainerNames

SG::ReadHandleKeyArray<CaloCalibrationHitContainer> CaloCalibClusterMomentsMaker2::m_DMCalibrationHitContainerNames

private

vector of dead material calibration hit container names to use.

The containers specified in this property should hold calibration hits outside the calorimeter systems - i.e. dead material hits ...

Definition at line 174 of file CaloCalibClusterMomentsMaker2.h.

◆ m_doCalibFrac

bool CaloCalibClusterMomentsMaker2::m_doCalibFrac

private

Definition at line 210 of file CaloCalibClusterMomentsMaker2.h.

◆ m_doDeadEnergySharing

bool CaloCalibClusterMomentsMaker2::m_doDeadEnergySharing

private

Definition at line 202 of file CaloCalibClusterMomentsMaker2.h.

◆ m_doDeadL

bool CaloCalibClusterMomentsMaker2::m_doDeadL

private

Definition at line 206 of file CaloCalibClusterMomentsMaker2.h.

◆ m_doDeadM

bool CaloCalibClusterMomentsMaker2::m_doDeadM

private

Definition at line 207 of file CaloCalibClusterMomentsMaker2.h.

◆ m_doDeadT

bool CaloCalibClusterMomentsMaker2::m_doDeadT

private

Definition at line 208 of file CaloCalibClusterMomentsMaker2.h.

◆ m_doOutOfClusterL

bool CaloCalibClusterMomentsMaker2::m_doOutOfClusterL

private

Definition at line 203 of file CaloCalibClusterMomentsMaker2.h.

◆ m_doOutOfClusterM

bool CaloCalibClusterMomentsMaker2::m_doOutOfClusterM

private

Definition at line 204 of file CaloCalibClusterMomentsMaker2.h.

◆ m_doOutOfClusterT

bool CaloCalibClusterMomentsMaker2::m_doOutOfClusterT

private

Definition at line 205 of file CaloCalibClusterMomentsMaker2.h.

◆ m_energyMin

float CaloCalibClusterMomentsMaker2::m_energyMin

private

Definition at line 211 of file CaloCalibClusterMomentsMaker2.h.

◆ m_energyMinCalib

float CaloCalibClusterMomentsMaker2::m_energyMinCalib

private

Definition at line 212 of file CaloCalibClusterMomentsMaker2.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_foundAllContainers

std::atomic<bool> CaloCalibClusterMomentsMaker2::m_foundAllContainers {}

mutableprivate

Definition at line 197 of file CaloCalibClusterMomentsMaker2.h.

◆ m_i_phi_eta

std::array<std::vector<std::vector<CalibHitIPhiIEtaRange> >,3> CaloCalibClusterMomentsMaker2::m_i_phi_eta

private

Definition at line 195 of file CaloCalibClusterMomentsMaker2.h.

◆ m_MatchDmType

int CaloCalibClusterMomentsMaker2::m_MatchDmType

private

Definition at line 215 of file CaloCalibClusterMomentsMaker2.h.

◆ m_momentsAOD

std::set<xAOD::CaloCluster::MomentType> CaloCalibClusterMomentsMaker2::m_momentsAOD

private

set holding the list of moment enums which go in the first store i.e.

they are available on the AOD.

Only moments listed in this property can later be directly retrieved from AOD - the others are available in the ESD ...

Definition at line 160 of file CaloCalibClusterMomentsMaker2.h.

◆ m_momentsNames

std::vector<std::string> CaloCalibClusterMomentsMaker2::m_momentsNames

private

vector holding the input list of names of moments to calculate.

This is the list of desired names of moments given in the jobOptions.

Definition at line 125 of file CaloCalibClusterMomentsMaker2.h.

◆ m_momentsNamesAOD

std::vector<std::string> CaloCalibClusterMomentsMaker2::m_momentsNamesAOD

private

vector holding the list of moment names which go in the first store i.e.

they are available on the AOD.

Only moments listed in this property can later be directly retrieved from AOD - the others are available in the ESD ...

Definition at line 152 of file CaloCalibClusterMomentsMaker2.h.

◆ m_n_eta_out

int CaloCalibClusterMomentsMaker2::m_n_eta_out

private

Definition at line 189 of file CaloCalibClusterMomentsMaker2.h.

◆ m_n_phi_out

int CaloCalibClusterMomentsMaker2::m_n_phi_out

private

Definition at line 188 of file CaloCalibClusterMomentsMaker2.h.

◆ m_out_eta_max

double CaloCalibClusterMomentsMaker2::m_out_eta_max

private

Definition at line 191 of file CaloCalibClusterMomentsMaker2.h.

◆ m_out_phi_max

double CaloCalibClusterMomentsMaker2::m_out_phi_max

private

Definition at line 190 of file CaloCalibClusterMomentsMaker2.h.

◆ m_rmaxOut

double CaloCalibClusterMomentsMaker2::m_rmaxOut[3]

private

Definition at line 193 of file CaloCalibClusterMomentsMaker2.h.

◆ m_truthParticleContainerKey

SG::ReadHandleKey<xAOD::TruthParticleContainer> CaloCalibClusterMomentsMaker2::m_truthParticleContainerKey {this,"TruthParticles","TruthParticles","ReadHandleKey for truth particle container"}

private

ReadHandleKey for truth particle container.

Definition at line 177 of file CaloCalibClusterMomentsMaker2.h.

◆ m_useParticleID

bool CaloCalibClusterMomentsMaker2::m_useParticleID

private

Definition at line 209 of file CaloCalibClusterMomentsMaker2.h.

◆ m_validMoments

moment_name_set CaloCalibClusterMomentsMaker2::m_validMoments

private

set of moments which will be calculated.

This set will hold each valid enum indexed with the name if it was found on the input list (m_momentsNames) and in the list of valid moment names (m_validNames).

Definition at line 144 of file CaloCalibClusterMomentsMaker2.h.

◆ m_validNames

moment_name_vector CaloCalibClusterMomentsMaker2::m_validNames

private

vector holding the names of valid moments which can be calculated.

Each name has to correspond to one of the enums in CaloClusterMoment. This list is defined in the constructor of CaloCalibClusterMomentsMaker2 and holds the names and enums of moments defined in CaloClusterMoment. The name is used as the key to the enum.

Definition at line 136 of file CaloCalibClusterMomentsMaker2.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

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

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CellInfoSet_t

◆ ClusInfo_t

◆ moment_name_pair

◆ moment_name_set

◆ moment_name_vector

◆ StoreGateSvc_t

Member Enumeration Documentation

◆ keys_calib_frac_origin

◆ keys_dm_energy_sharing

Constructor & Destructor Documentation

◆ CaloCalibClusterMomentsMaker2()

Member Function Documentation

◆ angle_mollier_factor()

◆ declareGaudiProperty() [1/4]

◆ declareGaudiProperty() [2/4]

◆ declareGaudiProperty() [3/4]

◆ declareGaudiProperty() [4/4]

◆ DeclareInterfaceID()

◆ declareProperty() [1/6]

◆ declareProperty() [2/6]

◆ declareProperty() [3/6]

◆ declareProperty() [4/6]

◆ declareProperty() [5/6]

◆ declareProperty() [6/6]

◆ detStore()

◆ evtStore() [1/2]

◆ evtStore() [2/2]

◆ execute() [1/4]

◆ execute() [2/4]

◆ execute() [3/4]

◆ execute() [4/4]

◆ extraDeps_update_handler()

◆ initialize()

◆ inputHandles()

◆ msg() [1/2]

◆ msg() [2/2]

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_apars_alpha

◆ m_apars_r0

◆ m_CalibrationHitContainerNames

◆ m_calo_id

◆ m_caloDetDescrMgrKey

◆ m_caloDM_ID

◆ m_caloDmDescrManager

◆ m_detStore

◆ m_DMCalibrationHitContainerNames

◆ m_doCalibFrac

◆ m_doDeadEnergySharing

◆ m_doDeadL

◆ m_doDeadM

◆ m_doDeadT

◆ m_doOutOfClusterL

◆ m_doOutOfClusterM

◆ m_doOutOfClusterT

◆ m_energyMin

◆ m_energyMinCalib

◆ m_evtStore

◆ m_foundAllContainers

◆ m_i_phi_eta

◆ m_MatchDmType

◆ m_momentsAOD

◆ m_momentsNames

◆ m_momentsNamesAOD