ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
DerivationFramework::TileCellsDecorator Class Reference

#include <TileCellsDecorator.h>

Inheritance diagram for DerivationFramework::TileCellsDecorator:
Collaboration diagram for DerivationFramework::TileCellsDecorator:

Public Member Functions

 TileCellsDecorator (const std::string &type, const std::string &name, const IInterface *parent)
 Constructor with parameters: More...
 
StatusCode initialize () override final
 
StatusCode decorate (const std::map< const xAOD::IParticle *, std::vector< const CaloCell * >> &muonCellsMap, const EventContext &ctx) const
 
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< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

Private Attributes

Gaudi::Property< std::string > m_prefix {this, "Prefix", "TCAL1_"}
 
Gaudi::Property< std::string > m_muonContainer {this, "MuonContainer", "Muons"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsEnergyKey {this, "CellsEnergy", "cells_energy"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsEtKey {this, "CellsEt", "cells_et"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsEtaKey {this, "CellsEta", "cells_eta"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPhiKey {this, "CellsPhi", "cells_phi"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsGainKey {this, "CellsGain", "cells_gain"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsBadKey {this, "CellsBad", "cells_bad"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSamplingKey {this, "CellsSampling", "cells_sampling"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsTimeKey {this, "CellsTime", "cells_time"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsQualityKey {this, "CellsQuality", "cells_quality"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSinThKey {this, "CellsSinTh", "cells_sinTh"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsCosThKey {this, "CellsCosTh", "cells_cosTh"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsCotThKey {this, "CellsCotTh", "cells_cotTh"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsXKey {this, "CellsX", "cells_x"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsYKey {this, "CellsY", "cells_y"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsZKey {this, "CellsZ", "cells_z"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsRKey {this, "CellsR", "cells_r"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDxKey {this, "CellsDx", "cells_dx"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDyKey {this, "CellsDy", "cells_dy"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDzKey {this, "CellsDz", "cells_dz"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDrKey {this, "CellsDr", "cells_dr"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsVolumeKey {this, "CellsVolume", "cells_volume"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDetaKey {this, "CellsDeta", "cells_deta"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDphiKey {this, "CellsDphi", "cells_dphi"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSideKey {this, "CellsSide", "cells_side"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSectionKey {this, "CellsSection", "cells_section"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsModuleKey {this, "CellsModule", "cells_module"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsTowerKey {this, "CellsTower", "cells_tower"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSampleKey {this, "CellsSample", "cells_sample"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1RosKey {this, "CellsPmt1Ros", "cells_pmt1_ros"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2RosKey {this, "CellsPmt2Ros", "cells_pmt2_ros"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1DrawerKey {this, "CellsPmt1Drawer", "cells_pmt1_drawer"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2DrawerKey {this, "CellsPmt2Drawer", "cells_pmt2_drawer"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1ChannelKey {this, "CellsPmt1Channel", "cells_pmt1_channel"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2ChannelKey {this, "CellsPmt2Channel", "cells_pmt2_channel"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1EnergyKey {this, "CellsPmt1Energy", "cells_pmt1_energy"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2EnergyKey {this, "CellsPmt2Energy", "cells_pmt2_energy"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1TimeKey {this, "CellsPmt1Time", "cells_pmt1_time"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2TimeKey {this, "CellsPmt2Time", "cells_pmt2_time"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1QualityKey {this, "CellsPmt1Quality", "cells_pmt1_quality"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2QualityKey {this, "CellsPmt2Quality", "cells_pmt2_quality"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1QbitKey {this, "CellsPmt1Qbit", "cells_pmt1_qbit"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2QbitKey {this, "CellsPmt2Qbit", "cells_pmt2_qbit"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1BadKey {this, "CellsPmt1Bad", "cells_pmt1_bad"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2BadKey {this, "CellsPmt2Bad", "cells_pmt2_bad"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1GainKey {this, "CellsPmt1Gain", "cells_pmt1_gain"}
 
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2GainKey {this, "CellsPmt2Gain", "cells_pmt2_gain"}
 
ServiceHandle< TileCablingSvc > m_cablingSvc
 Name of Tile cabling service. More...
 
const TileID * m_tileID {nullptr}
 
const TileHWID * m_tileHWID {nullptr}
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 41 of file TileCellsDecorator.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

◆ TileCellsDecorator()

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

Constructor with parameters:

Definition at line 33 of file TileCellsDecorator.cxx.

34  : AthAlgTool(type, name, parent)
35  {
36  }

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;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ decorate()

StatusCode DerivationFramework::TileCellsDecorator::decorate ( const std::map< const xAOD::IParticle *, std::vector< const CaloCell * >> &  muonCellsMap,
const EventContext &  ctx 
) const

Definition at line 188 of file TileCellsDecorator.cxx.

188  {
189 
190  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsEnergy(m_cellsEnergyKey, ctx);
191  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsEt(m_cellsEtKey, ctx);
192  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsEta(m_cellsEtaKey, ctx);
193  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsPhi(m_cellsPhiKey, ctx);
194  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<int>> cellsGain(m_cellsGainKey, ctx);
195  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<bool>> cellsBad(m_cellsBadKey, ctx);
196  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<int>> cellsSampling(m_cellsSamplingKey, ctx);
197  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsTime(m_cellsTimeKey, ctx);
198  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsQuality(m_cellsQualityKey, ctx);
199  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsSinTh(m_cellsSinThKey, ctx);
200  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsCosTh(m_cellsCosThKey, ctx);
201  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsCotTh(m_cellsCotThKey, ctx);
202  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsX(m_cellsXKey, ctx);
203  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsY(m_cellsYKey, ctx);
204  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsZ(m_cellsZKey, ctx);
205  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsR(m_cellsRKey, ctx);
206  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsDx(m_cellsDxKey, ctx);
207  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsDy(m_cellsDyKey, ctx);
208  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsDz(m_cellsDzKey, ctx);
209  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsDr(m_cellsDrKey, ctx);
210  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsVolume(m_cellsVolumeKey, ctx);
211  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsDeta(m_cellsDetaKey, ctx);
212  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsDphi(m_cellsDphiKey, ctx);
213  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<int>> cellsSide(m_cellsSideKey, ctx);
214  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsSection(m_cellsSectionKey, ctx);
215  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsModule(m_cellsModuleKey, ctx);
216  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsTower(m_cellsTowerKey, ctx);
217  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsSample(m_cellsSampleKey, ctx);
218  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt1Ros(m_cellsPmt1RosKey, ctx);
219  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt2Ros(m_cellsPmt2RosKey, ctx);
220  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt1Drawer(m_cellsPmt1DrawerKey, ctx);
221  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt2Drawer(m_cellsPmt2DrawerKey, ctx);
222  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt1Channel(m_cellsPmt1ChannelKey, ctx);
223  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt2Channel(m_cellsPmt2ChannelKey, ctx);
224  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsPmt1Energy(m_cellsPmt1EnergyKey, ctx);
225  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsPmt2Energy(m_cellsPmt2EnergyKey, ctx);
226  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsPmt1Time(m_cellsPmt1TimeKey, ctx);
227  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<float>> cellsPmt2Time(m_cellsPmt2TimeKey, ctx);
228  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt1Quality(m_cellsPmt1QualityKey, ctx);
229  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt2Quality(m_cellsPmt2QualityKey, ctx);
230  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt1_Qbit(m_cellsPmt1QbitKey, ctx);
231  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt2_Qbit(m_cellsPmt2QbitKey, ctx);
232  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<bool>> cellsPmt1Bad(m_cellsPmt1BadKey, ctx);
233  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<bool>> cellsPmt2Bad(m_cellsPmt2BadKey, ctx);
234  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt1Gain(m_cellsPmt1GainKey, ctx);
235  SG::WriteDecorHandle<xAOD::MuonContainer, std::vector<unsigned short>> cellsPmt2Gain(m_cellsPmt2GainKey, ctx);
236 
237  for (std::pair<const xAOD::IParticle*, const std::vector<const CaloCell*>> particleCellsPair : muonCellsMap) {
238 
239  const xAOD::IParticle* particle = particleCellsPair.first;
240  const std::vector<const CaloCell*>& cells = particleCellsPair.second;
241 
242  std::vector< float > cells_energy;
243  std::vector< float > cells_et;
244  std::vector< float > cells_eta;
245  std::vector< float > cells_phi;
246 
247  std::vector< int > cells_gain;
248  std::vector< bool > cells_bad;
249  std::vector< int > cells_sampling;
250  std::vector< float > cells_time;
251  std::vector< unsigned short > cells_quality;
252 
253  std::vector< float > cells_sinTh;
254  std::vector< float > cells_cosTh;
255  std::vector< float > cells_cotTh;
256  std::vector< float > cells_x;
257  std::vector< float > cells_y;
258  std::vector< float > cells_z;
259 
260  std::vector< float > cells_r;
261  std::vector< float > cells_dx;
262  std::vector< float > cells_dy;
263  std::vector< float > cells_dz;
264  std::vector< float > cells_dr;
265  std::vector< float > cells_volume;
266  std::vector< float > cells_dphi;
267  std::vector< float > cells_deta;
268 
269  std::vector< int > cells_side;
270  std::vector< unsigned short > cells_section;
271  std::vector< unsigned short > cells_module;
272  std::vector< unsigned short > cells_tower;
273  std::vector< unsigned short > cells_sample;
274 
275  std::vector< unsigned short > cells_pmt1_ros;
276  std::vector< unsigned short > cells_pmt2_ros;
277  std::vector< unsigned short > cells_pmt1_drawer;
278  std::vector< unsigned short > cells_pmt2_drawer;
279  std::vector< unsigned short > cells_pmt1_channel;
280  std::vector< unsigned short > cells_pmt2_channel;
281 
282  std::vector< float > cells_pmt1_energy;
283  std::vector< float > cells_pmt2_energy;
284  std::vector< float > cells_pmt1_time;
285  std::vector< float > cells_pmt2_time;
286 
287  std::vector< unsigned short > cells_pmt1_quality;
288  std::vector< unsigned short > cells_pmt2_quality;
289  std::vector< unsigned short > cells_pmt1_qbit;
290  std::vector< unsigned short > cells_pmt2_qbit;
291 
292  std::vector< bool > cells_pmt1_bad;
293  std::vector< bool > cells_pmt2_bad;
294  std::vector< unsigned short > cells_pmt1_gain;
295  std::vector< unsigned short > cells_pmt2_gain;
296 
297 
298  for (const CaloCell* cell : cells) {
299 
300  const CaloDetDescrElement* cell_dde = cell->caloDDE();
301 
302  // Cell energy and eta/phi
303  cells_energy.push_back( cell->energy() );
304  cells_et.push_back( cell->et() );
305  cells_eta.push_back( cell->eta() );
306  cells_phi.push_back( cell->phi() );
307 
308 
309  cells_gain.push_back( cell->gain() );
310  cells_bad.push_back( cell->badcell() );
311  cells_sampling.push_back( cell_dde->getSampling() );
312  cells_time.push_back( cell->time() );
313  cells_quality.push_back( cell->quality() );
314 
315  // Cell positioning
316  cells_sinTh.push_back( cell->sinTh() );
317  cells_cosTh.push_back( cell->cosTh() );
318  cells_cotTh.push_back( cell->cotTh() );
319  cells_x.push_back( cell->x() );
320  cells_y.push_back( cell->y() );
321  cells_z.push_back( cell->z() );
322 
323  // Cells dimensions
324  cells_r.push_back( cell_dde->r() );
325  cells_dx.push_back( cell_dde->dx() );
326  cells_dy.push_back( cell_dde->dy() );
327  cells_dz.push_back( cell_dde->dz() );
328  cells_dr.push_back( cell_dde->dr() );
329  cells_volume.push_back( cell_dde->volume() );
330  cells_dphi.push_back( cell_dde->dphi() );
331  cells_deta.push_back( cell_dde->deta() );
332 
333  cells_side.push_back( m_tileID->side(cell->ID()) );
334  cells_section.push_back( m_tileID->section(cell->ID()) );
335  cells_module.push_back( m_tileID->module(cell->ID()) );
336  cells_tower.push_back( m_tileID->tower(cell->ID()) );
337  cells_sample.push_back( m_tileID->sample(cell->ID()) );
338 
339  // Tile PMT information
340  const TileCell* tile_cell = dynamic_cast<const TileCell*> (cell);
341 
342  IdentifierHash hash1 = cell_dde->onl1();
343  IdentifierHash hash2 = cell_dde->onl2();
344 
345  // Tile cell positioning
346  int ros1 = -1;
347  int drawer1 = -1;
348  int channel1 = -1;
349  if (hash1 != TileHWID::NOT_VALID_HASH) {
350  ros1 = m_tileHWID->ros(m_tileHWID->adc_id(hash1, tile_cell->gain1()));
351  drawer1 = m_tileHWID->drawer(m_tileHWID->adc_id(hash1, tile_cell->gain1()));
352  channel1 = m_tileHWID->channel(m_tileHWID->adc_id(hash1, tile_cell->gain1()));
353  }
354 
355  int ros2 = -1;
356  int drawer2 = -1;
357  int channel2 = -1;
358  if (hash2 != TileHWID::NOT_VALID_HASH) {
359  ros2 = m_tileHWID->ros(m_tileHWID->adc_id(hash2, tile_cell->gain2()));
360  drawer2 = m_tileHWID->drawer(m_tileHWID->adc_id(hash2, tile_cell->gain2()));
361  channel2 = m_tileHWID->channel(m_tileHWID->adc_id(hash2, tile_cell->gain2()));
362  }
363 
364  cells_pmt1_ros.push_back( ros1 );
365  cells_pmt2_ros.push_back( ros2 );
366  cells_pmt1_drawer.push_back( drawer1 );
367  cells_pmt2_drawer.push_back( drawer2 );
368  cells_pmt1_channel.push_back( channel1 );
369  cells_pmt2_channel.push_back( channel2 );
370 
371  cells_pmt1_energy.push_back( tile_cell->ene1() );
372  cells_pmt2_energy.push_back( tile_cell->ene2() );
373  cells_pmt1_time.push_back( tile_cell->time1() );
374  cells_pmt2_time.push_back( tile_cell->time2() );
375  cells_pmt1_quality.push_back( tile_cell->qual1() );
376  cells_pmt2_quality.push_back( tile_cell->qual2() );
377  cells_pmt1_qbit.push_back( tile_cell->qbit1() );
378  cells_pmt2_qbit.push_back( tile_cell->qbit2() );
379  cells_pmt1_bad.push_back( tile_cell->badch1() );
380  cells_pmt2_bad.push_back( tile_cell->badch2() );
381  cells_pmt1_gain.push_back( tile_cell->gain1() );
382  cells_pmt2_gain.push_back( tile_cell->gain2() );
383  }
384 
385  cellsEnergy(*particle) = std::move(cells_energy);
386  cellsEt(*particle) = std::move(cells_et);
387  cellsEta(*particle) = std::move(cells_eta);
388  cellsPhi(*particle) = std::move(cells_phi);
389  cellsGain(*particle) = std::move(cells_gain);
390  cellsBad(*particle) = std::move(cells_bad);
391  cellsSampling(*particle) = std::move(cells_sampling);
392  cellsTime(*particle) = std::move(cells_time);
393  cellsQuality(*particle) = std::move(cells_quality);
394 
395  cellsSinTh(*particle) = std::move(cells_sinTh);
396  cellsCosTh(*particle) = std::move(cells_cosTh);
397  cellsCotTh(*particle) = std::move(cells_cotTh);
398  cellsX(*particle) = std::move(cells_x);
399  cellsY(*particle) = std::move(cells_y);
400  cellsZ(*particle) = std::move(cells_z);
401  cellsR(*particle) = std::move(cells_r);
402  cellsDx(*particle) = std::move(cells_dx);
403  cellsDy(*particle) = std::move(cells_dy);
404  cellsDz(*particle) = std::move(cells_dz);
405  cellsDr(*particle) = std::move(cells_dr);
406  cellsVolume(*particle) = std::move(cells_volume);
407  cellsDeta(*particle) = std::move(cells_deta);
408  cellsDphi(*particle) = std::move(cells_dphi);
409  cellsSide(*particle) = std::move(cells_side);
410  cellsSection(*particle) = std::move(cells_section);
411  cellsModule(*particle) = std::move(cells_module);
412  cellsTower(*particle) = std::move(cells_tower);
413  cellsSample(*particle) = std::move(cells_sample);
414 
415  cellsPmt1Ros(*particle) = std::move(cells_pmt1_ros);
416  cellsPmt2Ros(*particle) = std::move(cells_pmt2_ros);
417  cellsPmt1Drawer(*particle) = std::move(cells_pmt1_drawer);
418  cellsPmt2Drawer(*particle) = std::move(cells_pmt2_drawer);
419  cellsPmt1Channel(*particle) = std::move(cells_pmt1_channel);
420  cellsPmt2Channel(*particle) = std::move(cells_pmt2_channel);
421  cellsPmt1Energy(*particle) = std::move(cells_pmt1_energy);
422  cellsPmt2Energy(*particle) = std::move(cells_pmt2_energy);
423  cellsPmt1Time(*particle) = std::move(cells_pmt1_time);
424  cellsPmt2Time(*particle) = std::move(cells_pmt2_time);
425  cellsPmt1Quality(*particle) = std::move(cells_pmt1_quality);
426  cellsPmt2Quality(*particle) = std::move(cells_pmt2_quality);
427  cellsPmt1_Qbit(*particle) = std::move(cells_pmt1_qbit);
428  cellsPmt2_Qbit(*particle) = std::move(cells_pmt2_qbit);
429  cellsPmt1Bad(*particle) = std::move(cells_pmt1_bad);
430  cellsPmt2Bad(*particle) = std::move(cells_pmt2_bad);
431  cellsPmt1Gain(*particle) = std::move(cells_pmt1_gain);
432  cellsPmt2Gain(*particle) = std::move(cells_pmt2_gain);
433 
434  }
435 
436  return StatusCode::SUCCESS;
437  }

◆ 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

◆ initialize()

StatusCode DerivationFramework::TileCellsDecorator::initialize ( )
finaloverride

Definition at line 39 of file TileCellsDecorator.cxx.

39  {
40 
41  ATH_CHECK( m_cablingSvc.retrieve() );
42  ATH_CHECK( detStore()->retrieve(m_tileID) );
43  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
44 
45  const std::string baseName = m_muonContainer + ".";
46 
47  m_cellsEnergyKey = baseName + m_prefix + m_cellsEnergyKey.key();
48  ATH_CHECK( m_cellsEnergyKey.initialize() );
49 
50  m_cellsEtKey = baseName + m_prefix + m_cellsEtKey.key();
51  ATH_CHECK( m_cellsEtKey.initialize() );
52 
53  m_cellsEtaKey = baseName + m_prefix + m_cellsEtaKey.key();
54  ATH_CHECK( m_cellsEtaKey.initialize() );
55 
56  m_cellsPhiKey = baseName + m_prefix + m_cellsPhiKey.key();
57  ATH_CHECK( m_cellsPhiKey.initialize() );
58 
59  m_cellsGainKey = baseName + m_prefix + m_cellsGainKey.key();
60  ATH_CHECK( m_cellsGainKey.initialize() );
61 
62  m_cellsBadKey = baseName + m_prefix + m_cellsBadKey.key();
63  ATH_CHECK( m_cellsBadKey.initialize() );
64 
65  m_cellsSamplingKey = baseName + m_prefix + m_cellsSamplingKey.key();
66  ATH_CHECK( m_cellsSamplingKey.initialize() );
67 
68  m_cellsTimeKey = baseName + m_prefix + m_cellsTimeKey.key();
69  ATH_CHECK( m_cellsTimeKey.initialize() );
70 
71  m_cellsQualityKey = baseName + m_prefix + m_cellsQualityKey.key();
72  ATH_CHECK( m_cellsQualityKey.initialize() );
73 
74  m_cellsSinThKey = baseName + m_prefix + m_cellsSinThKey.key();
75  ATH_CHECK( m_cellsSinThKey.initialize() );
76 
77  m_cellsCosThKey = baseName + m_prefix + m_cellsCosThKey.key();
78  ATH_CHECK( m_cellsCosThKey.initialize() );
79 
80  m_cellsCotThKey = baseName + m_prefix + m_cellsCotThKey.key();
81  ATH_CHECK( m_cellsCotThKey.initialize() );
82 
83  m_cellsXKey = baseName + m_prefix + m_cellsXKey.key();
84  ATH_CHECK( m_cellsXKey.initialize() );
85 
86  m_cellsYKey = baseName + m_prefix + m_cellsYKey.key();
87  ATH_CHECK( m_cellsYKey.initialize() );
88 
89  m_cellsZKey = baseName + m_prefix + m_cellsZKey.key();
90  ATH_CHECK( m_cellsZKey.initialize() );
91 
92  m_cellsRKey = baseName + m_prefix + m_cellsRKey.key();
93  ATH_CHECK( m_cellsRKey.initialize() );
94 
95  m_cellsDxKey = baseName + m_prefix + m_cellsDxKey.key();
96  ATH_CHECK( m_cellsDxKey.initialize() );
97 
98  m_cellsDyKey = baseName + m_prefix + m_cellsDyKey.key();
99  ATH_CHECK( m_cellsDyKey.initialize() );
100 
101  m_cellsDzKey = baseName + m_prefix + m_cellsDzKey.key();
102  ATH_CHECK( m_cellsDzKey.initialize() );
103 
104  m_cellsDrKey = baseName + m_prefix + m_cellsDrKey.key();
105  ATH_CHECK( m_cellsDrKey.initialize() );
106 
107  m_cellsVolumeKey = baseName + m_prefix + m_cellsVolumeKey.key();
108  ATH_CHECK( m_cellsVolumeKey.initialize() );
109 
110  m_cellsDetaKey = baseName + m_prefix + m_cellsDetaKey.key();
111  ATH_CHECK( m_cellsDetaKey.initialize() );
112 
113  m_cellsDphiKey = baseName + m_prefix + m_cellsDphiKey.key();
114  ATH_CHECK( m_cellsDphiKey.initialize() );
115 
116  m_cellsSideKey = baseName + m_prefix + m_cellsSideKey.key();
117  ATH_CHECK( m_cellsSideKey.initialize() );
118 
119  m_cellsSectionKey = baseName + m_prefix + m_cellsSectionKey.key();
120  ATH_CHECK( m_cellsSectionKey.initialize() );
121 
122  m_cellsModuleKey = baseName + m_prefix + m_cellsModuleKey.key();
123  ATH_CHECK( m_cellsModuleKey.initialize() );
124 
125  m_cellsTowerKey = baseName + m_prefix + m_cellsTowerKey.key();
126  ATH_CHECK( m_cellsTowerKey.initialize() );
127 
128  m_cellsSampleKey = baseName + m_prefix + m_cellsSampleKey.key();
129  ATH_CHECK( m_cellsSampleKey.initialize() );
130 
131  m_cellsPmt1RosKey = baseName + m_prefix + m_cellsPmt1RosKey.key();
132  ATH_CHECK( m_cellsPmt1RosKey.initialize() );
133 
134  m_cellsPmt2RosKey = baseName + m_prefix + m_cellsPmt2RosKey.key();
135  ATH_CHECK( m_cellsPmt2RosKey.initialize() );
136 
137  m_cellsPmt1DrawerKey = baseName + m_prefix + m_cellsPmt1DrawerKey.key();
138  ATH_CHECK( m_cellsPmt1DrawerKey.initialize() );
139 
140  m_cellsPmt2DrawerKey = baseName + m_prefix + m_cellsPmt2DrawerKey.key();
141  ATH_CHECK( m_cellsPmt2DrawerKey.initialize() );
142 
143  m_cellsPmt1ChannelKey = baseName + m_prefix + m_cellsPmt1ChannelKey.key();
144  ATH_CHECK( m_cellsPmt1ChannelKey.initialize() );
145 
146  m_cellsPmt2ChannelKey = baseName + m_prefix + m_cellsPmt2ChannelKey.key();
147  ATH_CHECK( m_cellsPmt2ChannelKey.initialize() );
148 
149  m_cellsPmt1EnergyKey = baseName + m_prefix + m_cellsPmt1EnergyKey.key();
150  ATH_CHECK( m_cellsPmt1EnergyKey.initialize() );
151 
152  m_cellsPmt2EnergyKey = baseName + m_prefix + m_cellsPmt2EnergyKey.key();
153  ATH_CHECK( m_cellsPmt2EnergyKey.initialize() );
154 
155  m_cellsPmt1TimeKey = baseName + m_prefix + m_cellsPmt1TimeKey.key();
156  ATH_CHECK( m_cellsPmt1TimeKey.initialize() );
157 
158  m_cellsPmt2TimeKey = baseName + m_prefix + m_cellsPmt2TimeKey.key();
159  ATH_CHECK( m_cellsPmt2TimeKey.initialize() );
160 
161  m_cellsPmt1QualityKey = baseName + m_prefix + m_cellsPmt1QualityKey.key();
162  ATH_CHECK( m_cellsPmt1QualityKey.initialize() );
163 
164  m_cellsPmt2QualityKey = baseName + m_prefix + m_cellsPmt2QualityKey.key();
165  ATH_CHECK( m_cellsPmt2QualityKey.initialize() );
166 
167  m_cellsPmt1QbitKey = baseName + m_prefix + m_cellsPmt1QbitKey.key();
168  ATH_CHECK( m_cellsPmt1QbitKey.initialize() );
169 
170  m_cellsPmt2QbitKey = baseName + m_prefix + m_cellsPmt2QbitKey.key();
171  ATH_CHECK( m_cellsPmt2QbitKey.initialize() );
172 
173  m_cellsPmt1BadKey = baseName + m_prefix + m_cellsPmt1BadKey.key();
174  ATH_CHECK( m_cellsPmt1BadKey.initialize() );
175 
176  m_cellsPmt2BadKey = baseName + m_prefix + m_cellsPmt2BadKey.key();
177  ATH_CHECK( m_cellsPmt2BadKey.initialize() );
178 
179  m_cellsPmt1GainKey = baseName + m_prefix + m_cellsPmt1GainKey.key();
180  ATH_CHECK( m_cellsPmt1GainKey.initialize() );
181 
182  m_cellsPmt2GainKey = baseName + m_prefix + m_cellsPmt2GainKey.key();
183  ATH_CHECK( m_cellsPmt2GainKey.initialize() );
184 
185  return StatusCode::SUCCESS;
186  }

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

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

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

ServiceHandle<TileCablingSvc> DerivationFramework::TileCellsDecorator::m_cablingSvc
private
Initial value:
{ this,
"TileCablingSvc", "TileCablingSvc", "The Tile cabling service"}

Name of Tile cabling service.

Definition at line 116 of file TileCellsDecorator.h.

◆ m_cellsBadKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsBadKey {this, "CellsBad", "cells_bad"}
private

Definition at line 64 of file TileCellsDecorator.h.

◆ m_cellsCosThKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsCosThKey {this, "CellsCosTh", "cells_cosTh"}
private

Definition at line 70 of file TileCellsDecorator.h.

◆ m_cellsCotThKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsCotThKey {this, "CellsCotTh", "cells_cotTh"}
private

Definition at line 71 of file TileCellsDecorator.h.

◆ m_cellsDetaKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsDetaKey {this, "CellsDeta", "cells_deta"}
private

Definition at line 82 of file TileCellsDecorator.h.

◆ m_cellsDphiKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsDphiKey {this, "CellsDphi", "cells_dphi"}
private

Definition at line 83 of file TileCellsDecorator.h.

◆ m_cellsDrKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsDrKey {this, "CellsDr", "cells_dr"}
private

Definition at line 80 of file TileCellsDecorator.h.

◆ m_cellsDxKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsDxKey {this, "CellsDx", "cells_dx"}
private

Definition at line 77 of file TileCellsDecorator.h.

◆ m_cellsDyKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsDyKey {this, "CellsDy", "cells_dy"}
private

Definition at line 78 of file TileCellsDecorator.h.

◆ m_cellsDzKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsDzKey {this, "CellsDz", "cells_dz"}
private

Definition at line 79 of file TileCellsDecorator.h.

◆ m_cellsEnergyKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsEnergyKey {this, "CellsEnergy", "cells_energy"}
private

Definition at line 58 of file TileCellsDecorator.h.

◆ m_cellsEtaKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsEtaKey {this, "CellsEta", "cells_eta"}
private

Definition at line 60 of file TileCellsDecorator.h.

◆ m_cellsEtKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsEtKey {this, "CellsEt", "cells_et"}
private

Definition at line 59 of file TileCellsDecorator.h.

◆ m_cellsGainKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsGainKey {this, "CellsGain", "cells_gain"}
private

Definition at line 63 of file TileCellsDecorator.h.

◆ m_cellsModuleKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsModuleKey {this, "CellsModule", "cells_module"}
private

Definition at line 87 of file TileCellsDecorator.h.

◆ m_cellsPhiKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPhiKey {this, "CellsPhi", "cells_phi"}
private

Definition at line 61 of file TileCellsDecorator.h.

◆ m_cellsPmt1BadKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt1BadKey {this, "CellsPmt1Bad", "cells_pmt1_bad"}
private

Definition at line 108 of file TileCellsDecorator.h.

◆ m_cellsPmt1ChannelKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt1ChannelKey {this, "CellsPmt1Channel", "cells_pmt1_channel"}
private

Definition at line 95 of file TileCellsDecorator.h.

◆ m_cellsPmt1DrawerKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt1DrawerKey {this, "CellsPmt1Drawer", "cells_pmt1_drawer"}
private

Definition at line 93 of file TileCellsDecorator.h.

◆ m_cellsPmt1EnergyKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt1EnergyKey {this, "CellsPmt1Energy", "cells_pmt1_energy"}
private

Definition at line 98 of file TileCellsDecorator.h.

◆ m_cellsPmt1GainKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt1GainKey {this, "CellsPmt1Gain", "cells_pmt1_gain"}
private

Definition at line 110 of file TileCellsDecorator.h.

◆ m_cellsPmt1QbitKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt1QbitKey {this, "CellsPmt1Qbit", "cells_pmt1_qbit"}
private

Definition at line 105 of file TileCellsDecorator.h.

◆ m_cellsPmt1QualityKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt1QualityKey {this, "CellsPmt1Quality", "cells_pmt1_quality"}
private

Definition at line 103 of file TileCellsDecorator.h.

◆ m_cellsPmt1RosKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt1RosKey {this, "CellsPmt1Ros", "cells_pmt1_ros"}
private

Definition at line 91 of file TileCellsDecorator.h.

◆ m_cellsPmt1TimeKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt1TimeKey {this, "CellsPmt1Time", "cells_pmt1_time"}
private

Definition at line 100 of file TileCellsDecorator.h.

◆ m_cellsPmt2BadKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt2BadKey {this, "CellsPmt2Bad", "cells_pmt2_bad"}
private

Definition at line 109 of file TileCellsDecorator.h.

◆ m_cellsPmt2ChannelKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt2ChannelKey {this, "CellsPmt2Channel", "cells_pmt2_channel"}
private

Definition at line 96 of file TileCellsDecorator.h.

◆ m_cellsPmt2DrawerKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt2DrawerKey {this, "CellsPmt2Drawer", "cells_pmt2_drawer"}
private

Definition at line 94 of file TileCellsDecorator.h.

◆ m_cellsPmt2EnergyKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt2EnergyKey {this, "CellsPmt2Energy", "cells_pmt2_energy"}
private

Definition at line 99 of file TileCellsDecorator.h.

◆ m_cellsPmt2GainKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt2GainKey {this, "CellsPmt2Gain", "cells_pmt2_gain"}
private

Definition at line 111 of file TileCellsDecorator.h.

◆ m_cellsPmt2QbitKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt2QbitKey {this, "CellsPmt2Qbit", "cells_pmt2_qbit"}
private

Definition at line 106 of file TileCellsDecorator.h.

◆ m_cellsPmt2QualityKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt2QualityKey {this, "CellsPmt2Quality", "cells_pmt2_quality"}
private

Definition at line 104 of file TileCellsDecorator.h.

◆ m_cellsPmt2RosKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt2RosKey {this, "CellsPmt2Ros", "cells_pmt2_ros"}
private

Definition at line 92 of file TileCellsDecorator.h.

◆ m_cellsPmt2TimeKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsPmt2TimeKey {this, "CellsPmt2Time", "cells_pmt2_time"}
private

Definition at line 101 of file TileCellsDecorator.h.

◆ m_cellsQualityKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsQualityKey {this, "CellsQuality", "cells_quality"}
private

Definition at line 67 of file TileCellsDecorator.h.

◆ m_cellsRKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsRKey {this, "CellsR", "cells_r"}
private

Definition at line 76 of file TileCellsDecorator.h.

◆ m_cellsSampleKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsSampleKey {this, "CellsSample", "cells_sample"}
private

Definition at line 89 of file TileCellsDecorator.h.

◆ m_cellsSamplingKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsSamplingKey {this, "CellsSampling", "cells_sampling"}
private

Definition at line 65 of file TileCellsDecorator.h.

◆ m_cellsSectionKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsSectionKey {this, "CellsSection", "cells_section"}
private

Definition at line 86 of file TileCellsDecorator.h.

◆ m_cellsSideKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsSideKey {this, "CellsSide", "cells_side"}
private

Definition at line 85 of file TileCellsDecorator.h.

◆ m_cellsSinThKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsSinThKey {this, "CellsSinTh", "cells_sinTh"}
private

Definition at line 69 of file TileCellsDecorator.h.

◆ m_cellsTimeKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsTimeKey {this, "CellsTime", "cells_time"}
private

Definition at line 66 of file TileCellsDecorator.h.

◆ m_cellsTowerKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsTowerKey {this, "CellsTower", "cells_tower"}
private

Definition at line 88 of file TileCellsDecorator.h.

◆ m_cellsVolumeKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsVolumeKey {this, "CellsVolume", "cells_volume"}
private

Definition at line 81 of file TileCellsDecorator.h.

◆ m_cellsXKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsXKey {this, "CellsX", "cells_x"}
private

Definition at line 72 of file TileCellsDecorator.h.

◆ m_cellsYKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsYKey {this, "CellsY", "cells_y"}
private

Definition at line 73 of file TileCellsDecorator.h.

◆ m_cellsZKey

SG::WriteDecorHandleKey<xAOD::MuonContainer> DerivationFramework::TileCellsDecorator::m_cellsZKey {this, "CellsZ", "cells_z"}
private

Definition at line 74 of file TileCellsDecorator.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_muonContainer

Gaudi::Property<std::string> DerivationFramework::TileCellsDecorator::m_muonContainer {this, "MuonContainer", "Muons"}
private

Definition at line 56 of file TileCellsDecorator.h.

◆ m_prefix

Gaudi::Property<std::string> DerivationFramework::TileCellsDecorator::m_prefix {this, "Prefix", "TCAL1_"}
private

Definition at line 55 of file TileCellsDecorator.h.

◆ m_tileHWID

const TileHWID* DerivationFramework::TileCellsDecorator::m_tileHWID {nullptr}
private

Definition at line 120 of file TileCellsDecorator.h.

◆ m_tileID

const TileID* DerivationFramework::TileCellsDecorator::m_tileID {nullptr}
private

Definition at line 119 of file TileCellsDecorator.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:
CaloDetDescrElement::deta
float deta() const
cell deta
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:356
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileCell
Definition: TileCell.h:57
CaloDetDescrElement::onl2
IdentifierHash onl2() const
cell online identifier 2
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:408
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:280
DerivationFramework::TileCellsDecorator::m_cellsPmt1TimeKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1TimeKey
Definition: TileCellsDecorator.h:100
DerivationFramework::TileCellsDecorator::m_cellsPmt2RosKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2RosKey
Definition: TileCellsDecorator.h:92
TileCell::time1
float time1(void) const
get time of first PMT
Definition: TileCell.h:198
DerivationFramework::TileCellsDecorator::m_cellsPmt1EnergyKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1EnergyKey
Definition: TileCellsDecorator.h:98
DerivationFramework::TileCellsDecorator::m_cellsBadKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsBadKey
Definition: TileCellsDecorator.h:64
Trk::ParticleSwitcher::particle
constexpr ParticleHypothesis particle[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:76
DerivationFramework::TileCellsDecorator::m_cellsPmt1ChannelKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1ChannelKey
Definition: TileCellsDecorator.h:95
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
DerivationFramework::TileCellsDecorator::m_cellsTowerKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsTowerKey
Definition: TileCellsDecorator.h:88
DerivationFramework::TileCellsDecorator::m_cellsPmt2GainKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2GainKey
Definition: TileCellsDecorator.h:111
DerivationFramework::TileCellsDecorator::m_cellsSampleKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSampleKey
Definition: TileCellsDecorator.h:89
DerivationFramework::TileCellsDecorator::m_cellsDyKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDyKey
Definition: TileCellsDecorator.h:78
TileCell::time2
float time2(void) const
get time of second PMT
Definition: TileCell.h:200
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
DerivationFramework::TileCellsDecorator::m_cellsPmt1DrawerKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1DrawerKey
Definition: TileCellsDecorator.h:93
DerivationFramework::TileCellsDecorator::m_prefix
Gaudi::Property< std::string > m_prefix
Definition: TileCellsDecorator.h:55
TileCell::ene1
float ene1(void) const
get energy of first PMT
Definition: TileCell.h:193
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
TileCell::badch1
bool badch1(void) const
check if first PMT is in bad channel list and masked
Definition: TileCell.h:215
DerivationFramework::TileCellsDecorator::m_cellsPmt2DrawerKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2DrawerKey
Definition: TileCellsDecorator.h:94
DerivationFramework::TileCellsDecorator::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileCellsDecorator.h:120
Tile_Base_ID::side
int side(const Identifier &id) const
Definition: Tile_Base_ID.cxx:153
CaloDetDescrElement::dr
float dr() const
cell dr
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:360
Tile_Base_ID::sample
int sample(const Identifier &id) const
Definition: Tile_Base_ID.cxx:171
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
DerivationFramework::TileCellsDecorator::m_tileID
const TileID * m_tileID
Definition: TileCellsDecorator.h:119
DerivationFramework::TileCellsDecorator::m_cellsPmt1BadKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1BadKey
Definition: TileCellsDecorator.h:108
DerivationFramework::TileCellsDecorator::m_cellsSideKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSideKey
Definition: TileCellsDecorator.h:85
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
DerivationFramework::TileCellsDecorator::m_muonContainer
Gaudi::Property< std::string > m_muonContainer
Definition: TileCellsDecorator.h:56
DerivationFramework::TileCellsDecorator::m_cellsPmt2BadKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2BadKey
Definition: TileCellsDecorator.h:109
xAOD::IParticle
Class providing the definition of the 4-vector interface.
Definition: Event/xAOD/xAODBase/xAODBase/IParticle.h:41
DerivationFramework::TileCellsDecorator::m_cellsGainKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsGainKey
Definition: TileCellsDecorator.h:63
DerivationFramework::TileCellsDecorator::m_cellsEtaKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsEtaKey
Definition: TileCellsDecorator.h:60
TileHWID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: TileHWID.h:314
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
DerivationFramework::TileCellsDecorator::m_cellsSinThKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSinThKey
Definition: TileCellsDecorator.h:69
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
DerivationFramework::TileCellsDecorator::m_cellsVolumeKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsVolumeKey
Definition: TileCellsDecorator.h:81
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
CaloDetDescrElement::dz
float dz() const
cell dz
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:379
CaloDetDescrElement::onl1
IdentifierHash onl1() const
cell online identifier 1
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:404
DerivationFramework::TileCellsDecorator::m_cellsEtKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsEtKey
Definition: TileCellsDecorator.h:59
DerivationFramework::TileCellsDecorator::m_cellsDzKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDzKey
Definition: TileCellsDecorator.h:79
TileCell::qual2
uint8_t qual2(void) const
get quality of second PMT (data member)
Definition: TileCell.h:206
DerivationFramework::TileCellsDecorator::m_cellsPmt1GainKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1GainKey
Definition: TileCellsDecorator.h:110
DerivationFramework::TileCellsDecorator::m_cellsPmt1QbitKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1QbitKey
Definition: TileCellsDecorator.h:105
DerivationFramework::TileCellsDecorator::m_cellsRKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsRKey
Definition: TileCellsDecorator.h:76
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
DerivationFramework::TileCellsDecorator::m_cellsDphiKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDphiKey
Definition: TileCellsDecorator.h:83
AthCommonDataStore
Definition: AthCommonDataStore.h:52
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
DerivationFramework::TileCellsDecorator::m_cellsPhiKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPhiKey
Definition: TileCellsDecorator.h:61
DerivationFramework::TileCellsDecorator::m_cellsQualityKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsQualityKey
Definition: TileCellsDecorator.h:67
Tile_Base_ID::module
int module(const Identifier &id) const
Definition: Tile_Base_ID.cxx:159
DerivationFramework::TileCellsDecorator::m_cellsSectionKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSectionKey
Definition: TileCellsDecorator.h:86
DerivationFramework::TileCellsDecorator::m_cellsPmt2TimeKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2TimeKey
Definition: TileCellsDecorator.h:101
DerivationFramework::TileCellsDecorator::m_cellsPmt2ChannelKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2ChannelKey
Definition: TileCellsDecorator.h:96
DerivationFramework::TileCellsDecorator::m_cellsDetaKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDetaKey
Definition: TileCellsDecorator.h:82
TileCell::badch2
bool badch2(void) const
check if second PMT is in bad channel list and masked
Definition: TileCell.h:218
SG::WriteDecorHandle
Handle class for adding a decoration to an object.
Definition: StoreGate/StoreGate/WriteDecorHandle.h:100
DerivationFramework::TileCellsDecorator::m_cellsCotThKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsCotThKey
Definition: TileCellsDecorator.h:71
test_pyathena.parent
parent
Definition: test_pyathena.py:15
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
TileCell::qbit1
uint8_t qbit1(void) const
get quality bits of first PMT (data member)
Definition: TileCell.h:209
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
TileCell::gain1
int gain1(void) const
get gain of first PMT
Definition: TileCell.cxx:182
DerivationFramework::TileCellsDecorator::m_cellsSamplingKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsSamplingKey
Definition: TileCellsDecorator.h:65
AthAlgTool::AthAlgTool
AthAlgTool()
Default constructor:
DerivationFramework::TileCellsDecorator::m_cablingSvc
ServiceHandle< TileCablingSvc > m_cablingSvc
Name of Tile cabling service.
Definition: TileCellsDecorator.h:116
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
DerivationFramework::TileCellsDecorator::m_cellsCosThKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsCosThKey
Definition: TileCellsDecorator.h:70
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
DerivationFramework::TileCellsDecorator::m_cellsModuleKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsModuleKey
Definition: TileCellsDecorator.h:87
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
DerivationFramework::TileCellsDecorator::m_cellsPmt2QbitKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2QbitKey
Definition: TileCellsDecorator.h:106
CaloDetDescrElement::volume
float volume() const
cell volume
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:381
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
DerivationFramework::TileCellsDecorator::m_cellsXKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsXKey
Definition: TileCellsDecorator.h:72
DerivationFramework::TileCellsDecorator::m_cellsTimeKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsTimeKey
Definition: TileCellsDecorator.h:66
TileHWID::adc_id
HWIdentifier adc_id(int ros, int drawer, int channel, int adc) const
adc HWIdentifer
Definition: TileHWID.cxx:229
TileCell::qbit2
uint8_t qbit2(void) const
get quality bits of second PMT (data member)
Definition: TileCell.h:212
DerivationFramework::TileCellsDecorator::m_cellsPmt1QualityKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1QualityKey
Definition: TileCellsDecorator.h:103
CaloDetDescrElement::dphi
float dphi() const
cell dphi
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:358
TileCell::gain2
int gain2(void) const
get gain of second PMT
Definition: TileCell.cxx:189
TileCell::ene2
float ene2(void) const
get energy of second PMT
Definition: TileCell.h:195
a
TList * a
Definition: liststreamerinfos.cxx:10
h
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
DerivationFramework::TileCellsDecorator::m_cellsDrKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDrKey
Definition: TileCellsDecorator.h:80
CaloDetDescrElement::dx
float dx() const
cell dx
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:375
CaloDetDescrElement::getSampling
CaloCell_ID::CaloSample getSampling() const
cell sampling
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:395
DerivationFramework::TileCellsDecorator::m_cellsYKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsYKey
Definition: TileCellsDecorator.h:73
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
TileCell::qual1
uint8_t qual1(void) const
get quality of first PMT (data member)
Definition: TileCell.h:203
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
DerivationFramework::TileCellsDecorator::m_cellsZKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsZKey
Definition: TileCellsDecorator.h:74
Tile_Base_ID::section
int section(const Identifier &id) const
Definition: Tile_Base_ID.cxx:147
CaloDetDescrElement::r
float r() const
cell r
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:348
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
CaloDetDescrElement::dy
float dy() const
cell dy
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:377
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
DerivationFramework::TileCellsDecorator::m_cellsDxKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsDxKey
Definition: TileCellsDecorator.h:77
DerivationFramework::TileCellsDecorator::m_cellsPmt1RosKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt1RosKey
Definition: TileCellsDecorator.h:91
fitman.k
k
Definition: fitman.py:528
DerivationFramework::TileCellsDecorator::m_cellsPmt2EnergyKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2EnergyKey
Definition: TileCellsDecorator.h:99
DerivationFramework::TileCellsDecorator::m_cellsPmt2QualityKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsPmt2QualityKey
Definition: TileCellsDecorator.h:104
DerivationFramework::TileCellsDecorator::m_cellsEnergyKey
SG::WriteDecorHandleKey< xAOD::MuonContainer > m_cellsEnergyKey
Definition: TileCellsDecorator.h:58
Generated on Fri Apr 18 2025 22:02:03 for ATLAS Offline Software by   doxygen 1.8.18