ATLAS Offline Software
Loading...
Searching...
No Matches
CaloClusterLocalCalib Class Reference

Cluster correction tool which applies local hadronic calibration w eights to the cells. More...

#include <CaloClusterLocalCalib.h>

Inheritance diagram for CaloClusterLocalCalib:
Collaboration diagram for CaloClusterLocalCalib:

Public Member Functions

virtual StatusCode initialize () override
 Tool initialization: load calibration tools specified by jobOptions.
virtual StatusCode execute (const EventContext &ctx, xAOD::CaloCluster *theCluster) const override
 Execute on a single cluster.
 CaloClusterLocalCalib (const std::string &type, const std::string &name, const IInterface *parent)
 Standard AlgTool constructor.
virtual StatusCode execute (const EventContext &ctx, xAOD::CaloClusterContainer *collection) const
 Apply corrections to cluster.
virtual StatusCode execute (xAOD::CaloClusterContainer *collection) final
 Execute on an entire collection of clusters.
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
 DeclareInterfaceID (CaloClusterCollectionProcessor, 1, 0)

Static Public Member Functions

static const InterfaceID & interfaceID ()
 Standard Gaudi interface ID method.

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t

Private Member Functions

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

Private Attributes

ToolHandleArray< IClusterClassificationToolm_classificationTool
 property: Classification tools
ToolHandleArray< IClusterCellWeightToolm_calibTools
 property: Array of IClusterCellWeightTool
std::vector< int > m_recoStatus
 property: vector of valid Reco Statuses for the clusters in order to be calibrated
bool m_absOpt
 if set to true, negative clusters are weighted as well
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

Cluster correction tool which applies local hadronic calibration w eights to the cells.

The weight are provided by ICellWeight tools

Definition at line 32 of file CaloClusterLocalCalib.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CaloClusterLocalCalib()

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

Standard AlgTool constructor.

Definition at line 18 of file CaloClusterLocalCalib.cxx.

21 :CaloClusterProcessor(type, name, parent),
23 m_calibTools(this),
24 m_absOpt(false)
25{
26 m_recoStatus.resize(0);
27 declareProperty ("ClusterClassificationTool",m_classificationTool);
28 declareProperty ("LocalCalibTools",m_calibTools) ;
29 declareProperty ("ClusterRecoStatus",m_recoStatus) ;
30 //Use weighting of negative clusters?
31 declareProperty ("WeightingOfNegClusters",m_absOpt) ;
32}
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
bool m_absOpt
if set to true, negative clusters are weighted as well
ToolHandleArray< IClusterCellWeightTool > m_calibTools
property: Array of IClusterCellWeightTool
std::vector< int > m_recoStatus
property: vector of valid Reco Statuses for the clusters in order to be calibrated
ToolHandleArray< IClusterClassificationTool > m_classificationTool
property: Classification tools
CaloClusterProcessor(const std::string &type, const std::string &name, const IInterface *parent)
Constructor.

Member Function Documentation

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

158 {
160 hndl.value(),
161 hndl.documentation());
162
163 }

◆ DeclareInterfaceID()

CaloClusterCollectionProcessor::DeclareInterfaceID ( CaloClusterCollectionProcessor ,
1 ,
0  )
inherited

◆ declareProperty()

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

Definition at line 145 of file AthCommonDataStore.h.

145 {
146 typedef typename SG::HandleClassifier<T>::type htype;
148 }
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>

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

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

◆ execute() [1/3]

StatusCode CaloClusterLocalCalib::execute ( const EventContext & ctx,
xAOD::CaloCluster * cluster ) const
overridevirtual

Execute on a single cluster.

Parameters
clusterThe cluster to process.
ctxThe event context.

Implements CaloClusterProcessor.

Definition at line 59 of file CaloClusterLocalCalib.cxx.

61{
62 CaloRecoStatus& recoStatus=theCluster->recoStatus();
63 // call classification tool
64 if (!m_classificationTool.empty()) {
65 recoStatus=m_classificationTool[0]->classify(theCluster);
66 }
67 // check desired reco status
68 bool isSelected (false);
69 for (unsigned int i=0;!isSelected && i<m_recoStatus.size();i++ )
70 isSelected = recoStatus.checkStatus(CaloRecoStatus::StatusIndicator(m_recoStatus[i]));
71 if ( isSelected ) {
72 if( m_absOpt ){
73
74
75 //double dm_weight(0.);
76 //double had_weight(0.);
77 double centLambd(0.);
78 double engdens(0.);
79 double emprobability(0.);
80 double isolation(0.);
81 // Store moments and energy of the old cluster
82 //theCluster->retrieveMoment(xAOD::CaloCluster::DM_WEIGHT, dm_weight);
83 //theCluster->retrieveMoment(xAOD::CaloCluster::HAD_WEIGHT,had_weight);
84 if (!theCluster->retrieveMoment(xAOD::CaloCluster::CENTER_LAMBDA,centLambd))
85 centLambd = 0;
86 if (!theCluster->retrieveMoment(xAOD::CaloCluster::FIRST_ENG_DENS,engdens))
87 engdens = 0;
88 if (!theCluster->retrieveMoment(xAOD::CaloCluster::EM_PROBABILITY,emprobability))
89 emprobability = 0;
90 if (!theCluster->retrieveMoment(xAOD::CaloCluster::ISOLATION,isolation))
91 isolation = 0;
92
93 double oldEnergy = theCluster->e();
94
95 const CaloCell_ID* calo_id = nullptr;
96 ATH_CHECK(detStore()->retrieve(calo_id,"CaloCell_ID"));
97
98// Make new Cluster and CellColl
99 //std::unique_ptr<CaloCellContainer> myCellColl=std::make_unique<CaloCellContainer>(SG::OWN_ELEMENTS);
100 CaloCellContainer myCellColl(SG::OWN_ELEMENTS);
101 std::unique_ptr<xAOD::CaloCluster> myCluster = CaloClusterStoreHelper::makeCluster(&myCellColl);
102 int cellIndex = 0;
103// Iterate over cells of old cluster and replicate them with energy weighted by -1 if negative and add it to the new cluster
104 xAOD::CaloCluster::cell_iterator cellIter = theCluster->cell_begin();
105 for(;cellIter!=theCluster->cell_end();cellIter++) {
106 const CaloCell* pCell = *cellIter;
107 double CellEnergy = pCell->e();
108 //Identifier myId = pCell->ID();
109 //IdentifierHash myHashId = calo_id->calo_cell_hash(myId);
110 if( CellEnergy < 0. ) CellEnergy = -1 * pCell->e();
111 myCellColl.push_back(new CaloCell(pCell->caloDDE(), pCell->ID(), CellEnergy, pCell->time(), pCell->quality(), pCell->provenance(), pCell->gain() ));
112 double cellWeight = cellIter.weight();
113 myCluster->addCell(cellIndex,cellWeight);
114 cellIndex++;
115 }
116
117 CaloClusterKineHelper::calculateKine(myCluster.get(),false,false);
118 myCluster->setRawE(myCluster->e());
119
120// Set sample energy of the new cluster to the one of the old cluster, other wise it is zero, important for dm correction
121 for(unsigned int i=0; i != CaloSampling::Unknown; ++ i) {
123 if (myCluster->hasSampling(s)) myCluster->setEnergy((CaloSampling::CaloSample)i, theCluster->eSample((CaloSampling::CaloSample)i));
124 }//end loop over samplings
125
126 CaloClusterKineHelper::calculateKine(myCluster.get(),true,false);
127// Give the new cluster the same moments as the old one
128 myCluster->insertMoment(xAOD::CaloCluster::CENTER_LAMBDA,centLambd);
129 myCluster->insertMoment(xAOD::CaloCluster::FIRST_ENG_DENS,engdens);
130 myCluster->insertMoment(xAOD::CaloCluster::EM_PROBABILITY,emprobability);
131 myCluster->insertMoment(xAOD::CaloCluster::ISOLATION,isolation);
132
133// Weight the new cluster
134 for (const ToolHandle<IClusterCellWeightTool>& tool : m_calibTools) {
135 if (tool->weight(myCluster.get(),ctx).isFailure())
136 msg(MSG::ERROR) << " failed to weight cluster " << endmsg;
137 }
138
139// Iterate over new, calibrated cluster and write out the weights of every cell into a map
140 std::map<IdentifierHash,double> weightMap;
141 xAOD::CaloCluster::cell_iterator mycellIter = myCluster->cell_begin();
142 xAOD::CaloCluster::cell_iterator mycellIterEnd = myCluster->cell_end();
143 for(;mycellIter!=mycellIterEnd;mycellIter++) {
144 const CaloCell* pCell = *mycellIter;
145 double cellWeight = mycellIter.weight();
146 Identifier myId = pCell->ID();
147 IdentifierHash myHashId = calo_id->calo_cell_hash(myId);
148 weightMap[myHashId] = cellWeight;
149 }
150
151
152// Apply cellweight on the corresponding cell of the original cluster
153
154 cellIter = theCluster->cell_begin();
155 for(;cellIter!=theCluster->cell_end();cellIter++) {
156 const CaloCell* pCell = *cellIter;
157 IdentifierHash myHashId = calo_id->calo_cell_hash(pCell->ID());
158 double weight = weightMap[myHashId];
159 theCluster->reweightCell(cellIter,weight);
160 }
161
162// Update kinematics of new cluster
163 CaloClusterKineHelper::calculateKine(theCluster,true,false);
164
165
166 //Manually insert weight moments to the original cluster, in the OOC case this is a multiplicative weight from LCOut and LCOutPi0
167 double newWeightMoment = theCluster->e()/oldEnergy;
168 if(m_calibTools[0].typeAndName() == "CaloLCWeightTool/LCWeight") theCluster->insertMoment(xAOD::CaloCluster::HAD_WEIGHT,newWeightMoment);
169 if(m_calibTools[0].typeAndName() == "CaloLCDeadMaterialTool/LCDeadMaterial") theCluster->insertMoment(xAOD::CaloCluster::DM_WEIGHT, newWeightMoment);
170 if(m_calibTools[0].typeAndName() == "CaloLCOutOfClusterTool/LCOut") theCluster->insertMoment(xAOD::CaloCluster::OOC_WEIGHT,newWeightMoment);
171 if(m_calibTools[0].typeAndName() == "CaloLCOutOfClusterTool/LCOutPi0")
172 {
173 double ooc_weight;
174 if (theCluster->retrieveMoment(xAOD::CaloCluster::OOC_WEIGHT,ooc_weight)) {
175 newWeightMoment *= ooc_weight;
176 theCluster->insertMoment(xAOD::CaloCluster::OOC_WEIGHT,newWeightMoment);
177 }
178 }
179 }
180// else, what as was always done
181 else{
182
183 for (const ToolHandle<IClusterCellWeightTool>& tool : m_calibTools) {
184 if (tool->weight(theCluster,ctx).isFailure())
185 msg(MSG::ERROR) << " failed to weight cluster " << endmsg;
186 }
187
188 }
189 //report <<MSG::DEBUG<<"new cluster energy="<<theCluster->e()<<endmsg;
190 }//end of "has correct reco status" if statement
191
192 // PL add calibration method bits to reco status
194
195 return StatusCode::SUCCESS;
196}
#define endmsg
#define ATH_CHECK
Evaluate an expression and check for errors.
const ServiceHandle< StoreGateSvc > & detStore() const
IdentifierHash calo_cell_hash(const Identifier cellId) const
create hash id from 'global' cell id
float time() const
get time (data member)
Definition CaloCell.h:368
virtual double e() const override final
get energy (data member) (synonym to method energy()
Definition CaloCell.h:333
const CaloDetDescrElement * caloDDE() const
get pointer to CaloDetDescrElement (data member)
Definition CaloCell.h:321
uint16_t provenance() const
get provenance (data member)
Definition CaloCell.h:354
uint16_t quality() const
get quality (data member)
Definition CaloCell.h:348
CaloGain::CaloGain gain() const
get gain (data member )
Definition CaloCell.h:361
Identifier ID() const
get ID (from cached data member) non-virtual and inline for fast access
Definition CaloCell.h:295
static void calculateKine(xAOD::CaloCluster *clu, const bool useweight=true, const bool updateLayers=true, const bool useGPUCriteria=false)
Helper class to calculate cluster kinematics based on cells.
static std::unique_ptr< xAOD::CaloCluster > makeCluster(const CaloCellContainer *cellCont)
Creates a valid CaloCluster with a private Aux-Store and CellLink container.
StatusIndicator
reconstruction status word
virtual bool checkStatus(const StatusIndicator &statusIndicator) const
Check status.
virtual void setStatus(const StatusIndicator &statusIndicator)
Set status.
CaloClusterCellLink::iterator cell_iterator
Iterator of the underlying CaloClusterCellLink (non-const version)
@ OOC_WEIGHT
Out-of-cluster weight (E_ooc/E_w)
@ EM_PROBABILITY
Classification probability to be em-like.
@ DM_WEIGHT
Dead-material weight (E_dm/E_ooc)
@ FIRST_ENG_DENS
First Moment in E/V.
@ HAD_WEIGHT
Hadronic weight (E_w/E_em)
@ CENTER_LAMBDA
Shower depth at Cluster Centroid.
@ ISOLATION
Energy weighted fraction of non-clustered perimeter cells.
CaloSampling::CaloSample CaloSample
@ OWN_ELEMENTS
this data object owns its elements
retrieve(aClass, aKey=None)
Definition PyKernel.py:110
MsgStream & msg
Definition testRead.cxx:32

◆ execute() [2/3]

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

Apply corrections to cluster.

Reimplemented from CaloClusterProcessor.

Definition at line 65 of file CaloClusterProcessor.cxx.

47{
48 for (xAOD::CaloCluster* clu : *collection) {
49 ATH_CHECK( execute (ctx, clu) );
50 }
51 return StatusCode::SUCCESS;
52}
virtual StatusCode execute(const EventContext &ctx, xAOD::CaloCluster *theCluster) const override
Execute on a single cluster.
CaloCluster_v1 CaloCluster
Define the latest version of the calorimeter cluster class.

◆ execute() [3/3]

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

Execute on an entire collection of clusters.

Parameters
collectionThe container of clusters. (deprecated)

Reimplemented from CaloClusterCollectionProcessor.

Definition at line 50 of file CaloClusterCollectionProcessor.h.

51 {
52 return execute (Gaudi::Hive::currentContext(), collection);
53 }
virtual StatusCode execute(const EventContext &ctx, xAOD::CaloCluster *cluster) const =0
Execute on a single cluster.

◆ 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 CaloClusterLocalCalib::initialize ( )
overridevirtual

Tool initialization: load calibration tools specified by jobOptions.

Definition at line 35 of file CaloClusterLocalCalib.cxx.

35 {
36
37 if (m_classificationTool.size()>1) {
38 msg(MSG::ERROR) << "More than one classification tool specified!" << endmsg;
39 return StatusCode::FAILURE;
40 }
41 //Retrieve classification tool (if necessary)
42 if (!m_classificationTool.empty()) {
44 msg(MSG::INFO) << "Found classification tool " << m_classificationTool[0] << endmsg;
45 }
46
47 //Retrieve calibration tools
48 ATH_CHECK(m_calibTools.retrieve());
49 msg(MSG::INFO) <<"Loaded "<< m_calibTools.size() <<" hadronic calibration tools"<<endmsg;
50
51 // check that at least one reco status is defined
52 if ( m_recoStatus.empty() ) {
53 msg(MSG::ERROR) << "Please specify at least one valid reco status with ClusterRecoStatus = [...] for this calib tool " << endmsg;
54 return StatusCode::FAILURE;
55 }
56 return StatusCode::SUCCESS;
57}

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

◆ interfaceID()

const InterfaceID & CaloClusterProcessor::interfaceID ( )
inlinestaticinherited

Standard Gaudi interface ID method.

Definition at line 72 of file CaloClusterProcessor.h.

static const InterfaceID IID_CaloClusterProcessor("CaloClusterProcessor", 1, 0)

◆ msg()

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

Definition at line 24 of file AthCommonMsg.h.

24 {
25 return this->msgStream();
26 }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30 {
31 return this->msgLevel(lvl);
32 }

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

381 {
382 h.renounce();
384 }
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)

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

364 {
366 }

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

308 {
309 // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310 // << " size: " << m_vhka.size() << endmsg;
311 for (auto &a : m_vhka) {
313 for (auto k : keys) {
314 k->setOwner(this);
315 }
316 }
317 }
std::vector< SG::VarHandleKeyArray * > m_vhka

Member Data Documentation

◆ m_absOpt

bool CaloClusterLocalCalib::m_absOpt
private

if set to true, negative clusters are weighted as well

Definition at line 72 of file CaloClusterLocalCalib.h.

◆ m_calibTools

ToolHandleArray<IClusterCellWeightTool> CaloClusterLocalCalib::m_calibTools
private

property: Array of IClusterCellWeightTool

Definition at line 64 of file CaloClusterLocalCalib.h.

◆ m_classificationTool

ToolHandleArray<IClusterClassificationTool> CaloClusterLocalCalib::m_classificationTool
private

property: Classification tools

Definition at line 56 of file CaloClusterLocalCalib.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_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_recoStatus

std::vector<int> CaloClusterLocalCalib::m_recoStatus
private

property: vector of valid Reco Statuses for the clusters in order to be calibrated

Definition at line 69 of file CaloClusterLocalCalib.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: