ATLAS Offline Software
Public Types | Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
egammaMVACalibTool Class Reference

A tool used by the egammaMVASvc to help calibrate energy for one particle type. More...

#include <egammaMVACalibTool.h>

Inheritance diagram for egammaMVACalibTool:
Collaboration diagram for egammaMVACalibTool:

Public Types

enum  CalibrationType { correctEaccordion, fullCalibration }
 how the output of the BDT is used correctEaccordion: energy = raw energy * BDT fullCalibration: energy = BDT More...
 
enum  ShiftType { NOSHIFT =0, MEAN10TOTRUE }
 shift to be applied after the BDT. More...
 

Public Member Functions

 egammaMVACalibTool (const std::string &type)
 
virtual ~egammaMVACalibTool () override=default
 
virtual StatusCode initialize () override
 Dummy implementation of the initialisation function. More...
 
float getEnergy (const xAOD::CaloCluster &clus, const xAOD::Egamma *eg) const override final
 returns the calibrated energy More...
 
virtual void print () const
 Print the state of the tool. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

StatusCode setupBDT (const egammaMVAFunctions::funcMap_t &funcLibrary, const std::string &fileName)
 a function called by initialize to setup the BDT, funcs, and shifts. More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Static Private Member Functions

static const TString & getString (TObject *obj)
 a utility to get a TString out of an TObjString pointer More...
 

Private Attributes

Gaudi::Property< int > m_particleType
 
Gaudi::Property< int > m_shiftType
 
Gaudi::Property< int > m_calibrationType
 
Gaudi::Property< bool > m_clusterEif0
 
Gaudi::Property< std::string > m_folder
 string with folder for weight files More...
 
Gaudi::Property< bool > m_useLayerCorrected
 
std::unique_ptr< TH2Poly > m_hPoly
 A TH2Poly used to extract bin numbers. Note there is an offset of 1. More...
 
std::vector< MVAUtils::BDTm_BDTs
 Where the BDTs are stored. More...
 
std::vector< std::vector< std::function< float(const xAOD::Egamma *, const xAOD::CaloCluster *)> > > m_funcs
 where the pointers to the funcs to calculate the vars per BDT More...
 
std::vector< TFormula > m_shifts
 shifts formulas More...
 
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

A tool used by the egammaMVASvc to help calibrate energy for one particle type.

The particle type to be calibrated must be specified by the property ParticleType. The property folder must be set with the path to a folder containig three files:

The ROOT files should have in the following content:

On data the property use_layer_corrected should be set to true. In reconstruction this flag is always false. In PhysicsAnalysis it should be set appropriately. When set to true when using the layer energies as input the data-driver-corrected version are used.

Definition at line 66 of file egammaMVACalibTool.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ CalibrationType

how the output of the BDT is used correctEaccordion: energy = raw energy * BDT fullCalibration: energy = BDT

Enumerator
correctEaccordion 
fullCalibration 

Definition at line 78 of file egammaMVACalibTool.h.

◆ ShiftType

shift to be applied after the BDT.

Only MEAN10TOTRUE and MEAN10TOTRUE are supperted

Enumerator
NOSHIFT 
MEAN10TOTRUE 

Definition at line 83 of file egammaMVACalibTool.h.

Constructor & Destructor Documentation

◆ egammaMVACalibTool()

egammaMVACalibTool::egammaMVACalibTool ( const std::string &  type)

Definition at line 28 of file egammaMVACalibTool.cxx.

28  :
30 {
31 }

◆ ~egammaMVACalibTool()

virtual egammaMVACalibTool::~egammaMVACalibTool ( )
overridevirtualdefault

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ 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
nameName of the property.
hndlObject holding the property value.
docDocumentation 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.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

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

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ 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
nameName of the property.
propertyObject holding the property value.
docDocumentation 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.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
148  }

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

◆ 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

◆ getEnergy()

float egammaMVACalibTool::getEnergy ( const xAOD::CaloCluster clus,
const xAOD::Egamma eg 
) const
finaloverridevirtual

returns the calibrated energy

Implements IegammaMVACalibTool.

Definition at line 213 of file egammaMVACalibTool.cxx.

215 {
216 
217  ATH_MSG_DEBUG("calling getEnergy with cluster index (" << clus.index());
218 
219  // find the bin of BDT and the shift
220  const auto initEnergy = (m_useLayerCorrected ?
223 
224  const auto etVarGeV = (initEnergy / std::cosh(clus.eta())) / GeV;
225  const auto etaVar = std::abs(clus.eta());
226 
227  ATH_MSG_DEBUG("Looking at object with initEnergy = " << initEnergy
228  << ", etVarGeV = " << etVarGeV
229  << ", etaVar = " << etaVar
230  << ", clus->e() = " << clus.e());
231 
232  // Normally, we'd just use FindFixBin here. But TH2Poly overrides FindBin
233  // to handle its special bin definitions, but it doesn't also override
234  // FindFixBin. But TH2Poly::FindBin (unlike TH1::FindBin) doesn't actually
235  // do anything non-const, so just suppress the warning here.
236  TH2Poly* hPoly ATLAS_THREAD_SAFE = m_hPoly.get();
237  const int bin = hPoly->FindBin(etaVar, etVarGeV) - 1; // poly bins are shifted by one
238 
239  ATH_MSG_DEBUG("Using bin: " << bin);
240 
241  if (bin < 0) {
242  ATH_MSG_DEBUG("The bin is under/overflow; just return the energy");
243  return clus.e();
244  }
245 
246  if (bin >= static_cast<int>(m_BDTs.size())) {
247  ATH_MSG_WARNING("The bin is outside the range, so just return the energy");
248  return clus.e();
249  }
250 
251  // select the bdt and functions. (shifts are done later if needed)
252  // if there is only one BDT just use that
253  const int bin_BDT = m_BDTs.size() != 1 ? bin : 0;
254  const auto& bdt = m_BDTs[bin_BDT];
255  const auto& funcs = m_funcs[bin_BDT];
256 
257  const size_t sz = funcs.size();
258 
259  // could consider adding std::array support to the BDTs
260  std::vector<float> vars(sz);
261 
262  for (size_t i = 0; i < sz; ++i) {
263  vars[i] = funcs[i](eg, &clus);
264  }
265 
266  // evaluate the BDT response
267  const float mvaOutput = bdt.GetResponse(vars);
268 
269  // what to do if the MVA response is 0;
270  if (mvaOutput == 0.) {
271  if (m_clusterEif0) {
272  return clus.e();
273  }
274  return 0.;
275  }
276 
277  // calculate the unshifted energy
278  const auto energy = (m_calibrationType == fullCalibration) ?
279  mvaOutput : (initEnergy * mvaOutput);
280 
281  ATH_MSG_DEBUG("energy after MVA = " << energy);
282 
283  if (m_shiftType == NOSHIFT) {
284  // if no shift, just return the unshifted energy
285  return energy;
286  }
287 
288  // have to do a shift if here. It's based on the corrected Et in GeV
289  const auto etGeV = (energy / std::cosh(clus.eta())) / GeV;
290 
291  // evaluate the TFormula associated with the bin
292  const auto shift = m_shifts[bin].Eval(etGeV);
293  ATH_MSG_DEBUG("shift = " << shift);
294  if (shift > 0.5) {
295  return energy / shift;
296  }
297  ATH_MSG_WARNING("Shift value too small: " << shift << "; not applying shift");
298  return energy;
299 
300 }

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

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

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

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

◆ getProperty()

template<class T >
const T* asg::AsgTool::getProperty ( const std::string &  name) const
inherited

Get one of the tool's properties.

◆ getString()

const TString & egammaMVACalibTool::getString ( TObject *  obj)
staticprivate

a utility to get a TString out of an TObjString pointer

Definition at line 204 of file egammaMVACalibTool.cxx.

205 {
206  TObjString *objS = dynamic_cast<TObjString*>(obj);
207  if (!objS) {
208  throw std::runtime_error("egammaMVACalibTool::getString was passed something that was not a string object");
209  }
210  return objS->GetString();
211 }

◆ initialize()

StatusCode egammaMVACalibTool::initialize ( )
overridevirtual

Dummy implementation of the initialisation function.

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

Reimplemented from asg::AsgTool.

Definition at line 33 of file egammaMVACalibTool.cxx.

34 {
36  ATH_MSG_FATAL("Particle type not set: you have to set property ParticleType to a valid value");
37  return StatusCode::FAILURE;
38  }
39  ATH_MSG_DEBUG("Initializing with particle " << m_particleType);
40 
41  if (m_shiftType == MEAN10TOTRUE) {
42  ATH_MSG_DEBUG("Using Mean10 shift");
43  } else if (m_shiftType == NOSHIFT) {
44  ATH_MSG_DEBUG("Not using a shift");
45  } else {
46  ATH_MSG_FATAL("Unsupported shift: " << m_shiftType);
47  return StatusCode::FAILURE;
48  }
49 
50  // get the BDTs and initialize functions
51  ATH_MSG_DEBUG("get BDTs in folder: " << m_folder);
52  switch (m_particleType) {
54  {
55  std::unique_ptr<egammaMVAFunctions::funcMap_t> funcLibraryPtr =
57  ATH_CHECK(setupBDT(*funcLibraryPtr,
58  PathResolverFindCalibFile(m_folder + "/MVACalib_electron.weights.root")));
59  }
60  break;
62  {
63  std::unique_ptr<egammaMVAFunctions::funcMap_t> funcLibraryPtr =
65  ATH_CHECK(setupBDT(*funcLibraryPtr,
66  PathResolverFindCalibFile(m_folder + "/MVACalib_unconvertedPhoton.weights.root")));
67  }
68  break;
70  {
71  std::unique_ptr<egammaMVAFunctions::funcMap_t> funcLibraryPtr =
73  ATH_CHECK(setupBDT(*funcLibraryPtr,
74  PathResolverFindCalibFile(m_folder + "/MVACalib_convertedPhoton.weights.root")));
75  }
76  break;
77  default:
78  ATH_MSG_FATAL("Particle type not set properly: " << m_particleType);
79  return StatusCode::FAILURE;
80  }
81 
82  // Load these dictionaries now, so we don't need to try to do so
83  // while multiple threads are running.
84  TClass::GetClass ("TH2Poly");
85  TClass::GetClass ("TMultiGraph");
86 
87  return StatusCode::SUCCESS;
88 }

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

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

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

101  {
102 
103  return MSG::name( msg().level() );
104  }

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

◆ print()

void asg::AsgTool::print ( ) const
virtualinherited

◆ 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();
383  PBASE::renounce (h);
384  }

◆ 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  {
365  handlesArray.renounce();
366  }

◆ setupBDT()

StatusCode egammaMVACalibTool::setupBDT ( const egammaMVAFunctions::funcMap_t funcLibrary,
const std::string &  fileName 
)
private

a function called by initialize to setup the BDT, funcs, and shifts.

Definition at line 90 of file egammaMVACalibTool.cxx.

92 {
93  ATH_MSG_DEBUG("Trying to open " << fileName);
94 
95  std::unique_ptr<TFile> f(TFile::Open(fileName.c_str()));
96  if (!f || f->IsZombie()) {
97  ATH_MSG_FATAL("Could not open file: " << fileName);
98  return StatusCode::FAILURE;
99  }
100 
101  // Load hPoly
102  TH2Poly *hPoly = nullptr;
103  f->GetObject("hPoly", hPoly);
104  if (!hPoly) {
105  ATH_MSG_FATAL("Could not find hPoly");
106  return StatusCode::FAILURE;
107  }
108  //pass ownership to class variable
109  m_hPoly.reset(static_cast<TH2Poly*>(hPoly));
110  m_hPoly->SetDirectory(nullptr);
111 
112  // Load variables
113  TObjArray *variablesTmp = nullptr;
114  f->GetObject("variables", variablesTmp);
115  if (!variablesTmp) {
116  ATH_MSG_FATAL("Could not find variables");
117  return StatusCode::FAILURE;
118  }
119  auto variables = std::unique_ptr<TObjArray>(variablesTmp);
120  variables->SetOwner(); // to delete the objects when d-tor is called
121 
122  // Load shifts
123  TObjArray *shiftsTmp = nullptr;
124  f->GetObject("shifts", shiftsTmp);
125  if (!shiftsTmp) {
126  ATH_MSG_FATAL("Could not find shifts");
127  return StatusCode::FAILURE;
128  }
129  auto shifts = std::unique_ptr<TObjArray>(shiftsTmp);
130  shifts->SetOwner(); // to delete the objects when d-tor is called
131 
132  // Load trees
133  TObjArray *treesTmp = nullptr;
134  std::unique_ptr<TObjArray> trees;
135  f->GetObject("trees", treesTmp);
136  if (treesTmp) {
137  trees = std::unique_ptr<TObjArray>(treesTmp);
138  trees->SetOwner(); // to delete the objects when d-tor is called
139  ATH_MSG_DEBUG("setupBDT " << "BDTs read from TObjArray");
140  } else {
141  ATH_MSG_DEBUG("setupBDT " << "Reading trees individually");
142  trees = std::make_unique<TObjArray>();
143  trees->SetOwner(); // to delete the objects when d-tor is called
144  for (int i = 0; i < variables->GetEntries(); ++i)
145  {
146  TTree *tree = nullptr;
147  f->GetObject(Form("BDT%d", i), tree);
148  if (tree) tree->SetCacheSize(0);
149  trees->AddAtAndExpand(tree, i);
150  }
151  }
152 
153  // Ensure the objects have (the same number of) entries
154  if (!trees->GetEntries() || !(trees->GetEntries() == variables->GetEntries())) {
155  ATH_MSG_FATAL("Tree has size " << trees->GetEntries()
156  << " while variables has size " << variables->GetEntries());
157  return StatusCode::FAILURE;
158  }
159 
160  // Loop simultaneously over trees, variables and shifts
161  // Define the BDTs, the list of variables and the shift for each BDT
162  TObjString *str2;
163  TObjString *shift;
164  TTree *tree;
165  TIter nextTree(trees.get());
166  TIter nextVariables(variables.get());
167  TIter nextShift(shifts.get());
168  for (int i=0; (tree = (TTree*) nextTree()) && ((TObjString*) nextVariables()); ++i)
169  {
170  m_BDTs.emplace_back(tree);
171 
172  std::vector<std::function<float(const xAOD::Egamma*, const xAOD::CaloCluster*)> > funcs;
173  // Loop over variables, which are separated by comma
174  char separator_var = ';';
175  if (getString(variables->At(i)).Index(";") < 1) separator_var = ','; // old versions
176  std::unique_ptr<TObjArray> tokens(getString(variables->At(i)).Tokenize(separator_var));
177  TIter nextVar(tokens.get());
178  while ((str2 = (TObjString*) nextVar()))
179  {
180  const TString& varName = getString(str2);
181  if (!varName.Length()) {
182  ATH_MSG_FATAL("There was an empty variable name!");
183  return StatusCode::FAILURE;
184  }
185  try {
186  funcs.push_back(funcLibrary.at(varName.Data()));
187  } catch(const std::out_of_range& e) {
188  ATH_MSG_FATAL("Could not find formula for variable " << varName << ", error: " << e.what());
189  return StatusCode::FAILURE;
190  }
191  }
192  m_funcs.push_back(std::move(funcs));
193 
194  if (m_shiftType == MEAN10TOTRUE) {
195  shift = (TObjString*) nextShift();
196  const TString& shiftFormula = getString(shift);
197  m_shifts.emplace_back("", shiftFormula);
198  }
199  }
200  return StatusCode::SUCCESS;
201 
202 }

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

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

Member Data Documentation

◆ m_BDTs

std::vector<MVAUtils::BDT> egammaMVACalibTool::m_BDTs
private

Where the BDTs are stored.

Definition at line 119 of file egammaMVACalibTool.h.

◆ m_calibrationType

Gaudi::Property<int> egammaMVACalibTool::m_calibrationType
private
Initial value:
{this,
"CalibrationType", correctEaccordion,
"What type of calibration to apply"}

Definition at line 98 of file egammaMVACalibTool.h.

◆ m_clusterEif0

Gaudi::Property<bool> egammaMVACalibTool::m_clusterEif0
private
Initial value:
{this,
"useClusterIf0", true,
"Use cluster energy if MVA response is 0"}

Definition at line 102 of file egammaMVACalibTool.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_folder

Gaudi::Property<std::string> egammaMVACalibTool::m_folder
private
Initial value:
{this,
"folder", "",
"string with folder for weight files"}

string with folder for weight files

Definition at line 107 of file egammaMVACalibTool.h.

◆ m_funcs

std::vector<std::vector<std::function<float(const xAOD::Egamma*, const xAOD::CaloCluster*)> > > egammaMVACalibTool::m_funcs
private

where the pointers to the funcs to calculate the vars per BDT

Definition at line 122 of file egammaMVACalibTool.h.

◆ m_hPoly

std::unique_ptr<TH2Poly> egammaMVACalibTool::m_hPoly
private

A TH2Poly used to extract bin numbers. Note there is an offset of 1.

Definition at line 116 of file egammaMVACalibTool.h.

◆ m_particleType

Gaudi::Property<int> egammaMVACalibTool::m_particleType
private
Initial value:
{this,
"What type of particle do we use"}

Definition at line 90 of file egammaMVACalibTool.h.

◆ m_shifts

std::vector<TFormula> egammaMVACalibTool::m_shifts
private

shifts formulas

Definition at line 125 of file egammaMVACalibTool.h.

◆ m_shiftType

Gaudi::Property<int> egammaMVACalibTool::m_shiftType
private
Initial value:
{this,
"ShiftType", MEAN10TOTRUE,
"Shift corrections to apply to value"}

Definition at line 94 of file egammaMVACalibTool.h.

◆ m_useLayerCorrected

Gaudi::Property<bool> egammaMVACalibTool::m_useLayerCorrected
private
Initial value:
{this,
"use_layer_corrected", false,
"whether to use layer corrections"}

Definition at line 111 of file egammaMVACalibTool.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:
egammaMVACalibTool::m_calibrationType
Gaudi::Property< int > m_calibrationType
Definition: egammaMVACalibTool.h:98
egammaMVAFunctions::compute_rawcl_Eacc
float compute_rawcl_Eacc(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:94
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
egammaMVACalibTool::m_particleType
Gaudi::Property< int > m_particleType
Definition: egammaMVACalibTool.h:90
asg::AsgTool
Base class for the dual-use tool implementation classes.
Definition: AsgTool.h:47
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
egammaMVACalibTool::MEAN10TOTRUE
@ MEAN10TOTRUE
Definition: egammaMVACalibTool.h:83
xAOD::EgammaParameters::convertedPhoton
@ convertedPhoton
Definition: EgammaEnums.h:20
fitman.sz
sz
Definition: fitman.py:527
StateLessPT_NewConfig.proxy
proxy
Definition: StateLessPT_NewConfig.py:392
checkCoolLatestUpdate.variables
variables
Definition: checkCoolLatestUpdate.py:13
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
ParticleTest.eg
eg
Definition: ParticleTest.py:29
egammaMVAFunctions
These functions are for calculating variables used by the MVA calibration.
Definition: egammaMVAFunctions.h:44
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
egammaMVACalibTool::setupBDT
StatusCode setupBDT(const egammaMVAFunctions::funcMap_t &funcLibrary, const std::string &fileName)
a function called by initialize to setup the BDT, funcs, and shifts.
Definition: egammaMVACalibTool.cxx:90
egammaMVACalibTool::m_folder
Gaudi::Property< std::string > m_folder
string with folder for weight files
Definition: egammaMVACalibTool.h:107
RTTAlgmain.trees
list trees
Definition: RTTAlgmain.py:40
tree
TChain * tree
Definition: tile_monitor.h:30
bin
Definition: BinsDiffFromStripMedian.h:43
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
xAOD::Egamma_v1
Definition: Egamma_v1.h:56
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
beamspotman.tokens
tokens
Definition: beamspotman.py:1284
dbg::ptr
void * ptr(T *p)
Definition: SGImplSvc.cxx:74
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
egammaMVACalibTool::NOSHIFT
@ NOSHIFT
Definition: egammaMVACalibTool.h:83
xAOD::EgammaParameters::NumberOfEgammaTypes
@ NumberOfEgammaTypes
Definition: EgammaEnums.h:21
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
xAOD::CaloCluster_v1
Description of a calorimeter cluster.
Definition: CaloCluster_v1.h:59
egammaMVAFunctions::initializeConvertedPhotonFuncs
std::unique_ptr< funcMap_t > initializeConvertedPhotonFuncs(bool useLayerCorrected)
A function to build the map for converted photons.
Definition: egammaMVAFunctions.cxx:72
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
FortranAlgorithmOptions.fileName
fileName
Definition: FortranAlgorithmOptions.py:13
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
egammaMVACalibTool::getString
static const TString & getString(TObject *obj)
a utility to get a TString out of an TObjString pointer
Definition: egammaMVACalibTool.cxx:204
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
egammaMVACalibTool::m_useLayerCorrected
Gaudi::Property< bool > m_useLayerCorrected
Definition: egammaMVACalibTool.h:111
xAOD::CaloCluster_v1::eta
virtual double eta() const
The pseudorapidity ( ) of the particle.
Definition: CaloCluster_v1.cxx:251
lumiFormat.i
int i
Definition: lumiFormat.py:85
PixelAthClusterMonAlgCfg.varName
string varName
end cluster ToT and charge
Definition: PixelAthClusterMonAlgCfg.py:125
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
egammaMVACalibTool::correctEaccordion
@ correctEaccordion
Definition: egammaMVACalibTool.h:78
egammaMVAFunctions::initializeUnconvertedPhotonFuncs
std::unique_ptr< funcMap_t > initializeUnconvertedPhotonFuncs(bool useLayerCorrected)
A function to build the map for uncoverted photons.
Definition: egammaMVAFunctions.cxx:59
python.xAODType.dummy
dummy
Definition: xAODType.py:4
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
egammaMVACalibTool::m_clusterEif0
Gaudi::Property< bool > m_clusterEif0
Definition: egammaMVACalibTool.h:102
MSG::name
const std::string & name(Level lvl)
Convenience function for translating message levels to strings.
Definition: MsgLevel.cxx:19
hist_file_dump.f
f
Definition: hist_file_dump.py:135
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
egammaMVACalibTool::m_shifts
std::vector< TFormula > m_shifts
shifts formulas
Definition: egammaMVACalibTool.h:125
egammaMVAFunctions::compute_correctedcl_Eacc
float compute_correctedcl_Eacc(const xAOD::CaloCluster &cl)
Definition: egammaMVAFunctions.h:97
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
egammaMVACalibTool::m_funcs
std::vector< std::vector< std::function< float(const xAOD::Egamma *, const xAOD::CaloCluster *)> > > m_funcs
where the pointers to the funcs to calculate the vars per BDT
Definition: egammaMVACalibTool.h:122
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
plotBeamSpotVxVal.bin
int bin
Definition: plotBeamSpotVxVal.py:83
egammaMVAFunctions::initializeElectronFuncs
std::unique_ptr< funcMap_t > initializeElectronFuncs(bool useLayerCorrected)
A function to build the map for electrons.
Definition: egammaMVAFunctions.cxx:34
PathResolverFindCalibFile
std::string PathResolverFindCalibFile(const std::string &logical_file_name)
Definition: PathResolver.cxx:431
a
TList * a
Definition: liststreamerinfos.cxx:10
h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
xAOD::EgammaParameters::electron
@ electron
Definition: EgammaEnums.h:18
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
egammaMVACalibTool::m_shiftType
Gaudi::Property< int > m_shiftType
Definition: egammaMVACalibTool.h:94
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
egammaMVACalibTool::fullCalibration
@ fullCalibration
Definition: egammaMVACalibTool.h:78
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
egammaMVACalibTool::m_hPoly
std::unique_ptr< TH2Poly > m_hPoly
A TH2Poly used to extract bin numbers. Note there is an offset of 1.
Definition: egammaMVACalibTool.h:116
python.PyAthena.obj
obj
Definition: PyAthena.py:132
SG::DataProxy
Definition: DataProxy.h:45
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
xAOD::CaloCluster_v1::e
virtual double e() const
The total energy of the particle.
Definition: CaloCluster_v1.cxx:265
readCCLHist.float
float
Definition: readCCLHist.py:83
egammaMVACalibTool::m_BDTs
std::vector< MVAUtils::BDT > m_BDTs
Where the BDTs are stored.
Definition: egammaMVACalibTool.h:119
fitman.k
k
Definition: fitman.py:528
xAOD::EgammaParameters::unconvertedPhoton
@ unconvertedPhoton
Definition: EgammaEnums.h:19