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

This algorithm produces a column-wise NTuple out of several complete structures. More...

#include <LArParams2Ntuple.h>

Inheritance diagram for LArParams2Ntuple:
Collaboration diagram for LArParams2Ntuple:

Classes

class  DumpFlags
 

Public Member Functions

 LArParams2Ntuple (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~LArParams2Ntuple ()
 
StatusCode initialize ()
 
StatusCode execute ()
 
virtual StatusCode stop ()
 
StatusCode finalize ()
 
bool fillFromIdentifier (const HWIdentifier &id)
 
const SG::ReadCondHandleKey< LArOnOffIdMapping > & cablingKey () const
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. 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 sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Types

enum  { NOT_VALID = -999 }
 

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

Protected Attributes

Gaudi::Property< bool > m_addBC {this, "AddBadChannelInfo", true, "dump BadChan info ?"}
 
Gaudi::Property< bool > m_addFEBTemp {this, "AddFEBTempInfo", false, "dump FEB temperature info ?"}
 
Gaudi::Property< bool > m_isSC {this, "isSC", false, "are we working with SC?"}
 
Gaudi::Property< bool > m_isFlat {this, "isFlat", false, "are we working with Flat conditions ?"}
 
Gaudi::Property< bool > m_OffId {this, "OffId", false, "dump also offline ID ?"}
 
Gaudi::Property< bool > m_addHash {this, "AddHash", false, "add also ID hash info ?"}
 
Gaudi::Property< bool > m_addCalib {this, "AddCalib", false, "add also calib line info info ?"}
 
Gaudi::Property< bool > m_realgeom {this, "RealGeometry", false, "add real geometry values ?"}
 
Gaudi::Property< bool > m_expandId {this,"ExpandId", true ,"add online Id decoded fields ?"}
 
std::string m_ntpath
 
std::string m_ntTitle
 
NTuple::Tuple * m_nt
 
NTuple::Item< long > m_detector
 
NTuple::Item< long > m_region
 
NTuple::Item< long > m_layer
 
NTuple::Item< long > m_eta
 
NTuple::Item< long > m_phi
 
NTuple::Item< long > m_onlChanId
 
NTuple::Item< long > m_oflChanId
 
NTuple::Item< long > m_pos_neg
 
NTuple::Item< long > m_barrel_ec
 
NTuple::Item< long > m_FT
 
NTuple::Item< long > m_slot
 
NTuple::Item< long > m_channel
 
NTuple::Item< long > m_calibLine
 
NTuple::Item< long > m_badChanWord
 
NTuple::Item< long > m_isConnected
 
NTuple::Item< long > m_chanHash
 
NTuple::Item< long > m_febHash
 
NTuple::Item< long > m_oflHash
 
NTuple::Item< float > m_reta
 
NTuple::Item< float > m_rphi
 
NTuple::Item< float > m_FEBTemp1
 
NTuple::Item< float > m_FEBTemp2
 
StoreGateSvc * m_detStore
 
const LArEM_Base_ID * m_emId
 
const LArHEC_Base_ID * m_hecId
 
const LArFCAL_Base_ID * m_fcalId
 
const LArOnlineID_Base * m_onlineId
 
const CaloCell_Base_ID * m_caloId
 
ToolHandle< ILArFEBTempTool > m_FEBTempTool
 
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
 
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingSCKey {this,"CablingSCKey","LArOnOffIdMapSC","SG Key of LArOnOffIdMapping object"}
 
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey {this, "BadChanKey", "LArBadChannel", "SG bad channels key"}
 
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapKey {this,"CalibMapKey","LArCalibLineMap","SG Key of calib line mapping object"}
 
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapSCKey {this,"CalibMapSCKey","LArCalibIdMapSC","SG Key of calib line mapping object"}
 
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey {this, "CaloDetDescrManager", "CaloDetDescrManager", "SG Key for CaloDetDescrManager in the Condition Store"}
 
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSuperCellMgrKey {this, "CaloSuperCellDetDescrManager", "CaloSuperCellDetDescrManager", "SG key of the resulting CaloSuperCellDetDescrManager" }
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

template<class DATA >
StatusCode scanReadoutChannels (const DATA *&data_object)
 
template<class DATA >
StatusCode scanCalibChannels (const DATA *&data_object)
 
template<class DATA >
StatusCode retrieveFromDetStore (const DATA *&data_object)
 
StatusCode retrieveAbstractInterface (const LArCaliPulseParamsComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArDetCellParamsComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArPhysCaliTdiffComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArTdriftComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArMphysOverMcalComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArRinjComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArTshaperComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArEMEC_CphiComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArEMEC_HValphaComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArEMEC_HVbetaComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArCableLengthComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArCableAttenuationComplete *&data_object)
 
StatusCode retrieveAbstractInterface (const LArOFCBinComplete *&)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::vector< std::string > m_classNames
 
std::vector< std::string > m_detStoreKeys
 
std::vector< std::string > m_detStoreJo
 
bool m_allChannels2Ntuple
 
bool m_useAbstractInterface
 
std::string m_ntName
 
std::vector< std::string > m_keylist
 
DumpFlags m_dumpFlags
 
std::string m_suffix
 
std::vector< std::map< HWIdentifier, DumpFlags > > m_dump_flags_map
 
const LArCaliPulseParamsComplete * m_completeCaliPulseParams
 
const LArDetCellParamsComplete * m_completeDetCellParams
 
const LArPhysCaliTdiffComplete * m_completePhysCaliTdiff
 
const LArTdriftComplete * m_completeTdrift
 
const LArMphysOverMcalComplete * m_completeMphysOverMcal
 
const LArRinjComplete * m_completeRinj
 
const LArTshaperComplete * m_completeTshaper
 
const LArEMEC_CphiComplete * m_completeEMEC_Cphi
 
const LArEMEC_HValphaComplete * m_completeEMEC_HValpha
 
const LArEMEC_HVbetaComplete * m_completeEMEC_HVbeta
 
const LArCableLengthComplete * m_completeCableLength
 
const LArCableAttenuationComplete * m_completeCableAttenuation
 
const LArOFCBinComplete * m_completeOFCBin
 
bool m_initialized
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Static Private Attributes

static const unsigned m_nClasses = LArParamsProperties::END_OF_LIST
 

Detailed Description

This algorithm produces a column-wise NTuple out of several complete structures.

Only the finalize method is used, initalize and execute are empty.

Author
M. Fanti
  1. 2. 2004

Definition at line 23 of file LArParams2Ntuple.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
protectedinherited
Enumerator
NOT_VALID 

Definition at line 63 of file LArCond2NtupleBase.h.

63 {NOT_VALID = -999};

Constructor & Destructor Documentation

◆ LArParams2Ntuple()

LArParams2Ntuple::LArParams2Ntuple ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 12 of file LArParams2Ntuple.cxx.

13  : LArCond2NtupleBase(name, pSvcLocator),
14  m_completeCaliPulseParams(nullptr), m_completeDetCellParams(nullptr), m_completePhysCaliTdiff(nullptr),
15  m_completeTdrift(nullptr), m_completeMphysOverMcal(nullptr), m_completeRinj(nullptr), m_completeTshaper(nullptr),
16  m_completeEMEC_Cphi(nullptr), m_completeEMEC_HValpha(nullptr), m_completeEMEC_HVbeta(nullptr),
17  m_completeCableLength(nullptr), m_completeCableAttenuation(nullptr),
18  m_completeOFCBin(nullptr)
19 {
20  //declareProperty("DumpAllOnlineChannels",m_dumpAllOnlineChannels=std::string("")) ;
21  declareProperty("DetStoreSuffix",m_suffix=std::string("")) ;
22  declareProperty("AllChannels2Ntuple",m_allChannels2Ntuple=false) ;
23  declareProperty("UseAbstractInterface",m_useAbstractInterface=false) ;
24  declareProperty("NtupleName",m_ntName="PARAMS");
25  m_keylist.clear() ;
26  declareProperty("KeyList",m_keylist);
27  m_detStoreJo.clear();
28  declareProperty("DBKeysList",m_detStoreJo);
29 
30  m_classNames = LArParamsProperties::ClassNames() ;
31 
32  // set default keywords for detector store retrieval
33 
34  m_detStoreKeys.resize(m_nClasses) ;
35  for ( unsigned i=0 ; i<m_nClasses ; i++ )
36  m_detStoreKeys[i] = LArParamsProperties::keyword( m_classNames[i] ) ;
37 
38 }

◆ ~LArParams2Ntuple()

LArParams2Ntuple::~LArParams2Ntuple ( )
default

Member Function Documentation

◆ cablingKey()

const SG::ReadCondHandleKey< LArOnOffIdMapping > & LArCond2NtupleBase::cablingKey ( ) const
inherited

Definition at line 456 of file LArCond2NtupleBase.cxx.

457 {
458  if(m_isSC) return m_cablingSCKey;
459  return m_cablingKey;
460 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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< Algorithm > >::evtStore ( ) const
inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode LArParams2Ntuple::execute ( )
inline

Definition at line 32 of file LArParams2Ntuple.h.

32 {return StatusCode::SUCCESS;}

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ fillFromIdentifier()

bool LArCond2NtupleBase::fillFromIdentifier ( const HWIdentifier &  id)
inherited

Definition at line 288 of file LArCond2NtupleBase.cxx.

288  {
289 
290  ATH_MSG_VERBOSE("Starting fillFromIdentifier");
291  const LArBadChannelCont *bcCont = nullptr;
292  if ( m_addBC ) {
293  SG::ReadCondHandle<LArBadChannelCont> readHandle{m_BCKey};
294  bcCont =*readHandle;
295  if( !bcCont) {
296  ATH_MSG_WARNING( "Do not have Bad chan container " << m_BCKey.key() );
297  return false;
298  }
299  }
300 
301  const LArCalibLineMapping *clCont=nullptr;
302  if(m_addCalib) {
303  if(m_isSC){
304  SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_calibMapSCKey};
305  clCont={*clHdl};
306  }
307  else{
308  SG::ReadCondHandle<LArCalibLineMapping> clHdl{m_calibMapKey};
309  clCont={*clHdl};
310  }
311  if(!clCont) {
312  ATH_MSG_WARNING( "Do not have calib line mapping !!!" );
313  return false;
314  }
315  }
316 
317  const LArOnOffIdMapping* cabling=nullptr;
318  if(m_isSC){
319  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingSCKey};
320  cabling=*cablingHdl;
321  }
322  else{
323  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{m_cablingKey};
324  cabling=*cablingHdl;
325  }
326 
327  if(!cabling) {
328  ATH_MSG_WARNING( "Do not have cabling !" );
329  return false;
330  }
331 
332  m_onlChanId = hwid.get_identifier32().get_compact();
333 
334  if(m_expandId) {
335  m_barrel_ec = m_onlineId->barrel_ec(hwid);
336  m_pos_neg = m_onlineId->pos_neg(hwid);
337  m_FT = m_onlineId->feedthrough(hwid);
338  m_slot = m_onlineId->slot(hwid);
339  m_channel = m_onlineId->channel(hwid);
340  }
341 
342  if (m_addHash) {
343  m_chanHash=m_onlineId->channel_Hash(hwid);
344  m_febHash=m_onlineId->feb_Hash(m_onlineId->feb_Id(hwid));
345  }
346 
347  if(m_addCalib) {
348  m_calibLine=NOT_VALID;
349  const std::vector<HWIdentifier>& calibLineV=clCont->calibSlotLine(hwid);
350  if(!calibLineV.empty()) {
351  if(m_isSC) {
352  //FIXME - that is hacky, but do not have legacy helper in case of SC
353  m_calibLine = ((hwid.get_identifier32().get_compact())>>8)&0x7F;
354  } else {
355  m_calibLine = m_onlineId->channel(calibLineV[0]);
356  }
357  }
358  }
359 
360 
361  if ( m_OffId ) {
362  m_detector=NOT_VALID;
363  m_region=NOT_VALID;
364  m_eta=NOT_VALID;
365  m_phi=NOT_VALID;
366 
367  if(m_realgeom){
368  m_reta=NOT_VALID;
369  m_rphi=NOT_VALID;
370  }
371  m_layer=NOT_VALID;
372  m_oflChanId=NOT_VALID;
373  if (m_addHash) m_oflHash=NOT_VALID;
374  }
375 
376  if (m_addBC) m_badChanWord=0;
377  bool connected=false;
378 
379  const CaloDetDescrManager_Base* dd_man = nullptr;
380  if (m_realgeom) {
381  if(m_isSC) {
382  SG::ReadCondHandle<CaloSuperCellDetDescrManager> caloSuperCellMgrHandle{m_caloSuperCellMgrKey};
383  dd_man = *caloSuperCellMgrHandle;
384  }
385  else {
386  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
387  dd_man = *caloMgrHandle;
388  }
389  }
390 
391  try {
392  if (cabling->isOnlineConnected(hwid)) {
393  Identifier id=cabling->cnvToIdentifier(hwid);
394  if ( m_OffId ) {
395  m_oflChanId = id.get_identifier32().get_compact();
396  if (m_addHash) m_oflHash=m_caloId->calo_cell_hash(id);
397 
398  if (dd_man) {
399  const CaloDetDescrElement *elem = dd_man->get_element(id);
400  if(!elem) {
401  ATH_MSG_WARNING("Do not have CDDE for "<<id.getString());
402  } else {
403  m_reta = elem->eta_raw();
404  m_rphi = elem->phi_raw();
405  }
406  }
407 
408  if (m_emId->is_lar_em(id)) {
409  m_eta = m_emId->eta(id);
410  m_phi = m_emId->phi(id);
411  m_layer = m_emId->sampling(id);
412  m_region = m_emId->region(id);
413  m_detector = std::abs(m_emId->barrel_ec(id)) - 1; //0-barrel, 1-EMEC-OW, 2-EMEC-IW
414  }
415  else if (m_hecId->is_lar_hec(id)) {
416  m_eta = m_hecId->eta(id);
417  m_phi = m_hecId->phi(id);
418  m_layer = m_hecId->sampling(id);
419  m_region = m_hecId->region(id);
420  m_detector = 3;
421  }
422  else if (m_fcalId->is_lar_fcal(id)) {
423  m_eta = m_fcalId->eta(id);
424  m_phi = m_fcalId->phi(id);
425  m_layer = m_fcalId->module(id);
426  m_region = 0;
427  m_detector = 4;
428  }
429  } // m_OffId
430  connected=true;
431  }//end if is connected
432  }catch (LArID_Exception & except) {}
433 
434  //bad-channel word
435  if (m_addBC) m_badChanWord=bcCont->status(hwid).packedData();
436  // FEB temperatures
437  if (m_addFEBTemp) {
438  FEBTemp tv = m_FEBTempTool->getFebTemp(hwid);
439  if( !tv.empty() ) {
440  FEBTemp::const_iterator itb = tv.begin();
441  FEBTemp::const_iterator ite = tv.end();
442  for(;itb!=ite;++itb) {
443  m_FEBTemp1 = (*itb).first;
444  m_FEBTemp2 = (*itb).second;
445  }
446  }
447  }
448 
449  if(m_addCalib) m_isConnected = (long)connected;
450 
451  return connected;
452 }

◆ finalize()

StatusCode LArParams2Ntuple::finalize ( )
inline

Definition at line 34 of file LArParams2Ntuple.h.

34 {return StatusCode::SUCCESS;}

◆ initialize()

StatusCode LArParams2Ntuple::initialize ( )

Definition at line 43 of file LArParams2Ntuple.cxx.

43  {
44 
45  m_ntTitle=m_ntName;
46  m_ntpath=std::string("/NTUPLES/FILE1/")+m_ntName;
47 
48  if ( m_classNames.size() != m_nClasses ) { // should never happen! but just to be sure...
49  ATH_MSG_FATAL( "List of class names does not match foreseen number of classes, cannot go on!" ) ;
50  return StatusCode::FAILURE ;
51  }
52  for ( unsigned i=0 ; i<m_keylist.size() ; i++ ) {
53  ATH_MSG_DEBUG("examinimg key " << m_keylist[i] << "...");
54  unsigned idx = LArParamsProperties::getClassIndex(m_keylist[i]) ;
55  ATH_MSG_DEBUG("... class index " << idx);
56  if ( idx >= m_nClasses ) {
57  ATH_MSG_DEBUG("key " << m_keylist[i] << " does not correspond to any foreseen class");
58  return StatusCode::FAILURE ;
59  } else {
60  ATH_MSG_INFO( "will dump " << m_keylist[i] << " to Ntuple" ) ;
61  m_dumpFlags.set(idx) ;
62  }
63  }
64 
65  ATH_MSG_INFO("LArParams2Ntuple 3");
66  if ( m_useAbstractInterface ) {
67  ATH_MSG_INFO( "All parameters will be accessed through abstract interface" ) ;
68  if ( ! m_allChannels2Ntuple ) {
69  ATH_MSG_WARNING( "This will force dumping to Ntuple all foreseen online channels!" ) ;
70  m_allChannels2Ntuple = true ;
71  }
72  } else {
73  ATH_MSG_INFO( "All parameters will be accessed through their Complete/VsCalib class" ) ;
74  }
75  if ( m_allChannels2Ntuple ) {
76  ATH_MSG_INFO( "All foreseen online channels will be written to Ntuple" ) ;
77  } else {
78  ATH_MSG_INFO( "Only channels with sensible parameters will be written to Ntuple (default)" ) ;
79  }
80 
81  return LArCond2NtupleBase::initialize();
82 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::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< Algorithm >::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< Algorithm > >::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< Algorithm > >::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< Algorithm > >::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  }

◆ retrieveAbstractInterface() [1/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArCableAttenuationComplete *&  data_object)
inlineprivate

Definition at line 753 of file LArParams2Ntuple.cxx.

753  {
754  const ILArCableAttenuation* abstract_object = nullptr;
755  StatusCode sc = m_detStore->retrieve(abstract_object) ;
756  data_object = dynamic_cast<const LArCableAttenuationComplete*>(abstract_object) ;
757  return sc ;
758 }

◆ retrieveAbstractInterface() [2/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArCableLengthComplete *&  data_object)
inlineprivate

Definition at line 747 of file LArParams2Ntuple.cxx.

747  {
748  const ILArCableLength* abstract_object = nullptr;
749  StatusCode sc = m_detStore->retrieve(abstract_object) ;
750  data_object = dynamic_cast<const LArCableLengthComplete*>(abstract_object) ;
751  return sc ;
752 }

◆ retrieveAbstractInterface() [3/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArCaliPulseParamsComplete *&  data_object)
inlineprivate

Definition at line 681 of file LArParams2Ntuple.cxx.

681  {
682  const ILArCaliPulseParams* abstract_object = nullptr;
683  StatusCode sc = m_detStore->retrieve(abstract_object) ;
684  data_object = dynamic_cast<const LArCaliPulseParamsComplete*>(abstract_object) ;
685  return sc ;
686 }

◆ retrieveAbstractInterface() [4/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArDetCellParamsComplete *&  data_object)
inlineprivate

Definition at line 693 of file LArParams2Ntuple.cxx.

693  {
694  const ILArDetCellParams* abstract_object = nullptr;
695  StatusCode sc = m_detStore->retrieve(abstract_object) ;
696  data_object = dynamic_cast<const LArDetCellParamsComplete*>(abstract_object) ;
697  return sc ;
698 }

◆ retrieveAbstractInterface() [5/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArEMEC_CphiComplete *&  data_object)
inlineprivate

Definition at line 729 of file LArParams2Ntuple.cxx.

729  {
730  const ILArEMEC_Cphi* abstract_object = nullptr;
731  StatusCode sc = m_detStore->retrieve(abstract_object) ;
732  data_object = dynamic_cast<const LArEMEC_CphiComplete*>(abstract_object) ;
733  return sc ;
734 }

◆ retrieveAbstractInterface() [6/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArEMEC_HValphaComplete *&  data_object)
inlineprivate

Definition at line 735 of file LArParams2Ntuple.cxx.

735  {
736  const ILArEMEC_HValpha* abstract_object = nullptr;
737  StatusCode sc = m_detStore->retrieve(abstract_object) ;
738  data_object = dynamic_cast<const LArEMEC_HValphaComplete*>(abstract_object) ;
739  return sc ;
740 }

◆ retrieveAbstractInterface() [7/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArEMEC_HVbetaComplete *&  data_object)
inlineprivate

Definition at line 741 of file LArParams2Ntuple.cxx.

741  {
742  const ILArEMEC_HVbeta* abstract_object = nullptr;
743  StatusCode sc = m_detStore->retrieve(abstract_object) ;
744  data_object = dynamic_cast<const LArEMEC_HVbetaComplete*>(abstract_object) ;
745  return sc ;
746 }

◆ retrieveAbstractInterface() [8/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArMphysOverMcalComplete *&  data_object)
inlineprivate

Definition at line 711 of file LArParams2Ntuple.cxx.

711  {
712  const ILArMphysOverMcal* abstract_object = nullptr;
713  StatusCode sc = m_detStore->retrieve(abstract_object) ;
714  data_object = dynamic_cast<const LArMphysOverMcalComplete*>(abstract_object) ;
715  return sc ;
716 }

◆ retrieveAbstractInterface() [9/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArOFCBinComplete *&  )
inlineprivate

Definition at line 128 of file LArParams2Ntuple.h.

128 {return StatusCode::SUCCESS;};

◆ retrieveAbstractInterface() [10/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArPhysCaliTdiffComplete *&  data_object)
inlineprivate

Definition at line 699 of file LArParams2Ntuple.cxx.

699  {
700  const ILArPhysCaliTdiff* abstract_object = nullptr;
701  StatusCode sc = m_detStore->retrieve(abstract_object) ;
702  data_object = dynamic_cast<const LArPhysCaliTdiffComplete*>(abstract_object) ;
703  return sc ;
704 }

◆ retrieveAbstractInterface() [11/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArRinjComplete *&  data_object)
inlineprivate

Definition at line 717 of file LArParams2Ntuple.cxx.

717  {
718  const ILArRinj* abstract_object = nullptr;
719  StatusCode sc = m_detStore->retrieve(abstract_object) ;
720  data_object = dynamic_cast<const LArRinjComplete*>(abstract_object) ;
721  return sc ;
722 }

◆ retrieveAbstractInterface() [12/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArTdriftComplete *&  data_object)
inlineprivate

Definition at line 705 of file LArParams2Ntuple.cxx.

705  {
706  const ILArTdrift* abstract_object = nullptr;
707  StatusCode sc = m_detStore->retrieve(abstract_object) ;
708  data_object = dynamic_cast<const LArTdriftComplete*>(abstract_object) ;
709  return sc ;
710 }

◆ retrieveAbstractInterface() [13/13]

StatusCode LArParams2Ntuple::retrieveAbstractInterface ( const LArTshaperComplete *&  data_object)
inlineprivate

Definition at line 723 of file LArParams2Ntuple.cxx.

723  {
724  const ILArTshaper* abstract_object = nullptr;
725  StatusCode sc = m_detStore->retrieve(abstract_object) ;
726  data_object = dynamic_cast<const LArTshaperComplete*>(abstract_object) ;
727  return sc ;
728 }

◆ retrieveFromDetStore()

template<class DATA >
StatusCode LArParams2Ntuple::retrieveFromDetStore ( const DATA *&  data_object)
private

Definition at line 641 of file LArParams2Ntuple.cxx.

641  {
642  //
643  // data_object must be a concrete object (Complete or VsCalib)
644  //
645  unsigned classIndex = LArParamsProperties::getClassIndex(data_object) ;
646  //bool useGain = LArParamsProperties::isGainDependent(data_object) ;
647  if ( classIndex >= m_nClasses ) {
648  ATH_MSG_ERROR( "Class index " << classIndex << " beyond number of known classes: " << m_nClasses ) ;
649  return StatusCode::FAILURE ;
650  }
651  std::string detStoreKey = m_detStoreKeys[classIndex] + m_suffix ;
652  std::string dataName = m_classNames[classIndex] ;
653  if ( m_useAbstractInterface ) {
654 
655  ATH_MSG_VERBOSE("Trying to retrieve " << dataName << " from detector store through abstract interface I" << detStoreKey << " ...");
656  StatusCode sc = retrieveAbstractInterface(data_object) ;
657  if ( sc == StatusCode::FAILURE ) {
658  ATH_MSG_WARNING( "Could not retrieve " << dataName << " from detector store!" ) ;
659  return sc ;
660  }
661 
662  } else {
663 
664  ATH_MSG_VERBOSE("Trying to retrieve "<<dataName<<" from detector store with key="<<detStoreKey<<" ...");
665  StatusCode sc = m_detStore->retrieve(data_object,detStoreKey) ;
666  if ( sc == StatusCode::FAILURE ) {
667  ATH_MSG_VERBOSE("... failed! Trying without key ...");
668  StatusCode sc = m_detStore->retrieve(data_object) ;
669  }
670  if ( sc == StatusCode::FAILURE ) {
671  ATH_MSG_WARNING( "Could not retrieve " << dataName << " from detector store!" ) ;
672  return sc ;
673  }
674 
675  }
676  ATH_MSG_INFO(dataName << " retrieved successfully from det store");
677  return StatusCode::SUCCESS ;
678 }

◆ scanCalibChannels()

template<class DATA >
StatusCode LArParams2Ntuple::scanCalibChannels ( const DATA *&  data_object)
private

Definition at line 569 of file LArParams2Ntuple.cxx.

569  {
570 
571  unsigned classIndex = LArParamsProperties::getClassIndex(data_object) ;
572  //bool useGain = LArParamsProperties::isGainDependent(data_object) ;
573  if ( classIndex >= m_nClasses ) {
574  ATH_MSG_ERROR( "Class index " << classIndex << " beyond number of known classes: " << m_nClasses ) ;
575  return StatusCode::FAILURE ;
576  }
577 
578  std::string detStoreKey = m_detStoreKeys[classIndex] + m_suffix ;
579  std::string dataName = m_classNames[classIndex] ;
580 
581  if ( dataName.substr(dataName.length()-7,7) != std::string("VsCalib") ) {
582  ATH_MSG_ERROR( "Function scanCalibChannels cannot be called for data class " << dataName ) ;
583  return StatusCode::FAILURE ;
584  }
585 
586  ATH_MSG_VERBOSE("Trying to retrieve " << dataName << " from detector store with key="<< detStoreKey << " ...");
587 
588  StatusCode sc = m_detStore->retrieve(data_object,detStoreKey) ;
589  if ( sc == StatusCode::FAILURE ) {
590  ATH_MSG_VERBOSE("... failed! Trying without key ...");
591  StatusCode sc = m_detStore->retrieve(data_object) ;
592  }
593 
594  if ( sc == StatusCode::FAILURE ) {
595  ATH_MSG_ERROR( "Could not retrieve " << dataName << " from detector store!" ) ;
596  return sc ;
597  }
598 
599  // loop through the data object and keep memory of valid items
600 
601  ATH_MSG_VERBOSE("... " << dataName << " retrieved");
602  ATH_MSG_DEBUG(dataName << " successfully retrieved!");
603  // data_object->initialize() ;
604 
605  typename DATA::Const_CB_It cb_it = data_object->begin() ;
606  typename DATA::Const_CB_It cb_it_e = data_object->end() ;
607  for ( ; cb_it!=cb_it_e ; cb_it++ ) { // loop through calibration boards
608  const typename DATA::CB_Tvec_pair & cb_params_set = *cb_it ;
609  const typename DATA::CB_Id & cb_identifier = cb_params_set.first ;
610  const typename DATA::T_vector & cb_params = cb_params_set.second ;
611  HWIdentifier cb_HWid(cb_identifier) ;
612  unsigned nchan = cb_params.size() ;
613  if (msgLvl(MSG::VERBOSE)) {
614  unsigned b_ec = m_onlineId->barrel_ec(cb_HWid) ;
615  unsigned p_n = m_onlineId->pos_neg(cb_HWid) ;
616  unsigned ft = m_onlineId->feedthrough(cb_HWid) ;
617  unsigned slot = m_onlineId->slot(cb_HWid) ;
618  ATH_MSG_VERBOSE( " ... B/EC=" << b_ec << " P/N=" << p_n << " FT=" << ft << " slot=" << slot
619  << " nchan=" << nchan ) ;
620  }//end if verbose
621 
622  for ( unsigned ichan=0 ; ichan<nchan ; ichan++ ) { // loop through channels in a CB
623  if ( !m_isSC ) {
624  HWIdentifier chid = m_onlineId->calib_channel_Id(cb_HWid , ichan) ;
625  ATH_MSG_VERBOSE(" ... calib channel " << chid);
626  if ( LArParamsProperties::isValid( data_object->get(chid) ) ) {
627  for ( unsigned g=0 ; g<3 ; g++ ) {
628  DumpFlags & flags = m_dump_flags_map[g][chid] ;
629  flags.set(classIndex) ;
630  }
631  }
632  } // end of m_isSC
633  }
634 
635  } // end loop over calib boards
636  return sc ;
637 
638 }

◆ scanReadoutChannels()

template<class DATA >
StatusCode LArParams2Ntuple::scanReadoutChannels ( const DATA *&  data_object)
private

Definition at line 497 of file LArParams2Ntuple.cxx.

497  {
498 
499  unsigned classIndex = LArParamsProperties::getClassIndex(data_object) ;
500  bool useGain = LArParamsProperties::isGainDependent(data_object) ;
501 
502  if ( classIndex >= m_nClasses ) {
503  ATH_MSG_ERROR( "Class index " << classIndex << " beyond number of known classes: " << m_nClasses ) ;
504  return StatusCode::FAILURE ;
505  }
506 
507  std::string detStoreKey;
508  if (!m_detStoreJo.empty() && !m_detStoreJo[classIndex].empty()) {
509  detStoreKey = m_detStoreJo[classIndex];
510  ATH_MSG_VERBOSE(classIndex<<" detStoreKey = "<<detStoreKey);
511  } else {
512  detStoreKey = m_detStoreKeys[classIndex] + m_suffix ;
513  }
514 
515  std::string dataName = m_classNames[classIndex] ;
516 
517  if ( dataName.substr(dataName.length()-8,8) != std::string("Complete") ) {
518  ATH_MSG_ERROR( "Function scanReadoutChannels cannot be called for data class " << dataName ) ;
519  return StatusCode::FAILURE ;
520  }
521 
522  ATH_MSG_VERBOSE("Trying to retrieve " << dataName << " from detector store with key="<< detStoreKey << " ...");
523 
524  StatusCode sc = m_detStore->retrieve(data_object,detStoreKey) ;
525  if ( sc == StatusCode::FAILURE ) {
526  ATH_MSG_VERBOSE("... failed! Trying without key ...");
527  StatusCode sc = m_detStore->retrieve(data_object) ;
528  }
529 
530  if ( sc == StatusCode::FAILURE ) {
531  ATH_MSG_ERROR( "Could not retrieve " << dataName << " from detector store!" ) ;
532  return sc ;
533  }
534 
535  // loop through the data object and keep memory of valid items
536 
537  ATH_MSG_VERBOSE("... " << dataName << " retrieved");
538 
539  unsigned nGains = (int)CaloGain::LARNGAIN ;
540  if ( ! useGain ) nGains = 1 ; // data are gain-independent
541 
542  for ( unsigned gain=0 ; gain<nGains ; gain++) {
543  ATH_MSG_VERBOSE("... parsing gain " << gain);
544  typename DATA::ConstConditionsMapIterator it = data_object->begin(gain) ;
545  typename DATA::ConstConditionsMapIterator it_e = data_object->end(gain) ;
546  for ( ; it!=it_e ; it++ ) {
547  HWIdentifier chid = m_onlineId->channel_Id( HWIdentifier(it.getFebId()) , it.getChannel() ) ;
548  ATH_MSG_VERBOSE(" ... channel " << std::hex << chid.get_compact()<< std::dec);
549  if ( LArParamsProperties::isValid( data_object->get(chid,gain) ) ) {
550  if ( useGain ) {
551  DumpFlags & flags = m_dump_flags_map[gain][chid] ;
552  flags.set(classIndex) ;
553  } else {
554  for ( unsigned g=0 ; g<3 ; g++ ) {
555  DumpFlags & flags = m_dump_flags_map[g][chid] ;
556  flags.set(classIndex) ;
557  }
558  }
559  } else {
560  ATH_MSG_VERBOSE(" (looks empty!)");
561  } // endif isValid
562  } // end loop over channels
563  } // end loop over gains
564  return sc ;
565 
566 }

◆ stop()

StatusCode LArParams2Ntuple::stop ( )
virtual

Definition at line 85 of file LArParams2Ntuple.cxx.

85  {
86 
87 
88  // ntuple handling:
89  //------------------
90  NTuple::Item<long> ntcellIndex;
91  NTuple::Item<long> ntflag, ntgain;
92 
93  // .................... CaliPulseParams:
94  NTuple::Item<double> ntTcal, ntFstep, ntOffset, ntdTimeCal ;
95  NTuple::Item<long> ntnCB ;
96  // .................... DetCellParams:
97  NTuple::Item<double> ntOmega0, ntTaur ;
98  // .................... PhysCaliTdiff, Tdrift:
99  NTuple::Item<double> ntTdiff, ntTdrift ;
100  // .................... MphysOverMcal:
101  NTuple::Item<double> ntMphysOverMcal ;
102  // .................... Rinj, Tshaper:
103  NTuple::Item<double> ntRinj, ntTshaper ;
104  // .................... EMEC stuff:
105  NTuple::Item<double> ntEMEC_Cphi, ntEMEC_HValpha, ntEMEC_HVbeta ;
106  // .................... Cable stuff:
107  NTuple::Item<double> ntCableLength, ntCableAttenuation ;
108  // OFCBin
109  NTuple::Item<long> ntbin;
110 
111  StatusCode sc=m_nt->addItem("cellIndex",ntcellIndex,0,2000);
112  if (sc!=StatusCode::SUCCESS) {
113  ATH_MSG_ERROR( "addItem 'Cell Index' failed" );
114  return StatusCode::FAILURE;
115  }
116  sc=m_nt->addItem("gain",ntgain,-1,2);
117  if (sc!=StatusCode::SUCCESS) {
118  ATH_MSG_ERROR( "addItem 'Gain' failed" );
119  return StatusCode::FAILURE;
120  }
121 
122  if ( m_dumpFlags[CaliPulseParamsComplete] ) {
123  sc=m_nt->addItem("Tcal",ntTcal);
124  if (sc!=StatusCode::SUCCESS) {
125  ATH_MSG_ERROR( "addItem 'Tcal' failed" );
126  return StatusCode::FAILURE;
127  }
128  sc=m_nt->addItem("Fstep",ntFstep);
129  if (sc!=StatusCode::SUCCESS) {
130  ATH_MSG_ERROR( "addItem 'Fstep' failed" );
131  return StatusCode::FAILURE;
132  }
133  sc=m_nt->addItem("Offset",ntOffset);
134  if (sc!=StatusCode::SUCCESS) {
135  ATH_MSG_ERROR( "addItem 'Offset' failed" );
136  return StatusCode::FAILURE;
137  }
138  sc=m_nt->addItem("dTimeCal",ntdTimeCal);
139  if (sc!=StatusCode::SUCCESS) {
140  ATH_MSG_ERROR( "addItem 'dTimeCal' failed" );
141  return StatusCode::FAILURE;
142  }
143  sc=m_nt->addItem("nCB",ntnCB);
144  if (sc!=StatusCode::SUCCESS) {
145  ATH_MSG_ERROR( "addItem 'nCB' failed" );
146  return StatusCode::FAILURE;
147  }
148  }
149 
150  if ( m_dumpFlags[DetCellParamsComplete] ) {
151  sc=m_nt->addItem("Omega0",ntOmega0);
152  if (sc!=StatusCode::SUCCESS) {
153  ATH_MSG_ERROR( "addItem 'Omega0' failed" );
154  return StatusCode::FAILURE;
155  }
156  sc=m_nt->addItem("Taur",ntTaur);
157  if (sc!=StatusCode::SUCCESS) {
158  ATH_MSG_ERROR( "addItem 'Taur' failed" );
159  return StatusCode::FAILURE;
160  }
161  }
162 
163  if ( m_dumpFlags[PhysCaliTdiffComplete] ) {
164  sc=m_nt->addItem("Tdiff",ntTdiff);
165  if (sc!=StatusCode::SUCCESS) {
166  ATH_MSG_ERROR( "addItem 'Tdiff' failed" );
167  return StatusCode::FAILURE;
168  }
169  }
170 
171  if ( m_dumpFlags[TdriftComplete] ) {
172  sc=m_nt->addItem("Tdrift",ntTdrift);
173  if (sc!=StatusCode::SUCCESS) {
174  ATH_MSG_ERROR( "addItem 'Tdrift' failed" );
175  return StatusCode::FAILURE;
176  }
177  }
178 
179  if ( m_dumpFlags[MphysOverMcalComplete] ) {
180  sc=m_nt->addItem("MphysOverMcal",ntMphysOverMcal);
181  if (sc!=StatusCode::SUCCESS) {
182  ATH_MSG_ERROR( "addItem 'MphysOverMcal' failed" );
183  return StatusCode::FAILURE;
184  }
185  }
186 
187  if ( m_dumpFlags[RinjComplete] ) {
188  sc=m_nt->addItem("Rinj",ntRinj);
189  if (sc!=StatusCode::SUCCESS) {
190  ATH_MSG_ERROR( "addItem 'Rinj' failed" );
191  return StatusCode::FAILURE;
192  }
193  }
194 
195  if ( m_dumpFlags[TshaperComplete] ) {
196  sc=m_nt->addItem("Tshaper",ntTshaper);
197  if (sc!=StatusCode::SUCCESS) {
198  ATH_MSG_ERROR( "addItem 'Tshaper' failed" );
199  return StatusCode::FAILURE;
200  }
201  }
202 
203  if ( m_dumpFlags[EMEC_CphiComplete] ) {
204  sc=m_nt->addItem("EMEC_Cphi",ntEMEC_Cphi);
205  if (sc!=StatusCode::SUCCESS) {
206  ATH_MSG_ERROR( "addItem 'EMEC_Cphi' failed" );
207  return StatusCode::FAILURE;
208  }
209  }
210 
211  if ( m_dumpFlags[EMEC_HValphaComplete] ) {
212  sc=m_nt->addItem("EMEC_HValpha",ntEMEC_HValpha);
213  if (sc!=StatusCode::SUCCESS) {
214  ATH_MSG_ERROR( "addItem 'EMEC_HValpha' failed" );
215  return StatusCode::FAILURE;
216  }
217  }
218 
219  if ( m_dumpFlags[EMEC_HVbetaComplete] ) {
220  sc=m_nt->addItem("EMEC_HVbeta",ntEMEC_HVbeta);
221  if (sc!=StatusCode::SUCCESS) {
222  ATH_MSG_ERROR( "addItem 'EMEC_HVbeta' failed" );
223  return StatusCode::FAILURE;
224  }
225  }
226 
227  if ( m_dumpFlags[CableLengthComplete] ) {
228  sc=m_nt->addItem("CableLength",ntCableLength);
229  if (sc!=StatusCode::SUCCESS) {
230  ATH_MSG_ERROR( "addItem 'CableLength' failed" );
231  return StatusCode::FAILURE;
232  }
233  }
234 
235  if ( m_dumpFlags[CableAttenuationComplete] ) {
236  sc=m_nt->addItem("CableAttenuation",ntCableAttenuation);
237  if (sc!=StatusCode::SUCCESS) {
238  ATH_MSG_ERROR( "addItem 'CableAttenuation' failed" );
239  return StatusCode::FAILURE;
240  }
241  }
242 
243  if ( m_dumpFlags[OFCBinComplete] ) {
244  sc=m_nt->addItem("OFCBin",ntbin);
245  if (sc!=StatusCode::SUCCESS) {
246  ATH_MSG_ERROR( "addItem 'OFCBin' failed" );
247  return StatusCode::FAILURE;
248  }
249  }
250 
251  //=======================================================================================================
252  // dump smaller complete structures to a common Ntuple
253  //=======================================================================================================
254 
255  //
256  // first, scan all complete data structures to collect a map of channels
257  //
258 
259  int nGains = (int)CaloGain::LARNGAIN ;
260 
261  m_dump_flags_map.resize(nGains) ; // map of channels to be dumped; resized to host 3 gains
262 
263  if ( m_allChannels2Ntuple ) {
264 
265  // *** all readout channels will go into the ntuple ***
266 
267  if ( m_dumpFlags[CaliPulseParamsComplete] ) {
268  sc = retrieveFromDetStore(m_completeCaliPulseParams) ;
269  if ( sc.isFailure() ) m_dumpFlags.clear(CaliPulseParamsComplete) ;
270  }
271  if ( m_dumpFlags[DetCellParamsComplete] ) {
272  sc = retrieveFromDetStore(m_completeDetCellParams) ;
273  if ( sc.isFailure() ) m_dumpFlags.clear(DetCellParamsComplete) ;
274  }
275  if ( m_dumpFlags[PhysCaliTdiffComplete] ) {
276  sc = retrieveFromDetStore(m_completePhysCaliTdiff) ;
277  if ( sc.isFailure() ) m_dumpFlags.clear(PhysCaliTdiffComplete) ;
278  }
279  if ( m_dumpFlags[TdriftComplete] ) {
280  sc = retrieveFromDetStore(m_completeTdrift) ;
281  if ( sc.isFailure() ) m_dumpFlags.clear(TdriftComplete) ;
282  }
283  if ( m_dumpFlags[MphysOverMcalComplete] ) {
284  sc = retrieveFromDetStore(m_completeMphysOverMcal) ;
285  if ( sc.isFailure() ) m_dumpFlags.clear(MphysOverMcalComplete) ;
286  }
287  if ( m_dumpFlags[RinjComplete] ) {
288  sc = retrieveFromDetStore(m_completeRinj) ;
289  if ( sc.isFailure() ) m_dumpFlags.clear(RinjComplete) ;
290  }
291  if ( m_dumpFlags[TshaperComplete] ) {
292  sc = retrieveFromDetStore(m_completeTshaper) ;
293  if ( sc.isFailure() ) m_dumpFlags.clear(TshaperComplete) ;
294  }
295  if ( m_dumpFlags[EMEC_CphiComplete] ) {
296  sc = retrieveFromDetStore(m_completeEMEC_Cphi) ;
297  if ( sc.isFailure() ) m_dumpFlags.clear(EMEC_CphiComplete) ;
298  }
299  if ( m_dumpFlags[EMEC_HValphaComplete] ) {
300  sc = retrieveFromDetStore(m_completeEMEC_HValpha) ;
301  if ( sc.isFailure() ) m_dumpFlags.clear(EMEC_HValphaComplete) ;
302  }
303  if ( m_dumpFlags[EMEC_HVbetaComplete] ) {
304  sc = retrieveFromDetStore(m_completeEMEC_HVbeta) ;
305  if ( sc.isFailure() ) m_dumpFlags.clear(EMEC_HVbetaComplete) ;
306  }
307  if ( m_dumpFlags[CableLengthComplete] ) {
308  sc = retrieveFromDetStore(m_completeCableLength) ;
309  if ( sc.isFailure() ) m_dumpFlags.clear(CableLengthComplete) ;
310  }
311  if ( m_dumpFlags[CableAttenuationComplete] ) {
312  sc = retrieveFromDetStore(m_completeCableAttenuation) ;
313  if ( sc.isFailure() ) m_dumpFlags.clear(CableAttenuationComplete) ;
314  }
315  //if ( m_dumpFlags[CaliPulseParamsVsCalib] ) {
316  // sc = retrieveFromDetStore(m_calibCaliPulseParams) ;
317  // if ( sc.isFailure() ) m_dumpFlags.clear(CaliPulseParamsVsCalib) ;
318  //}
319  if ( m_dumpFlags[OFCBinComplete] ) {
320  sc = retrieveFromDetStore(m_completeOFCBin) ;
321  if ( sc.isFailure() ) m_dumpFlags.clear(OFCBinComplete) ;
322  }
323 
324  for (HWIdentifier chid : m_onlineId->channel_range()) {
325  for ( unsigned gain=0 ; (int)gain<nGains ; ++gain ) {
326  DumpFlags & flags = m_dump_flags_map[gain][chid] ;
327  flags = m_dumpFlags ;
328  }
329  }
330  if ( ! m_isSC ) {
331  for (HWIdentifier chid : m_onlineId->calib_channel_range()) {
332  for ( unsigned gain=0 ; (int)gain<nGains ; ++gain ) {
333  DumpFlags & flags = m_dump_flags_map[gain][chid] ;
334  flags = m_dumpFlags ;
335  }
336  }
337  }
338 
339  } else {
340 
341  // *** scan all complete data structures to collect a map of valid channels ***
342 
343  for ( unsigned i=0 ; i<m_nClasses ; i++ ) {
344  if ( ! m_dumpFlags[i] ) continue ;
345  ATH_MSG_DEBUG(m_classNames[i] << " was selected to be dumped...");
346 
347  switch ( i ) {
348  case CaliPulseParamsComplete: {
349  sc = scanReadoutChannels(m_completeCaliPulseParams) ;
350  break ;
351  }
352  case DetCellParamsComplete: {
353  sc = scanReadoutChannels(m_completeDetCellParams) ;
354  break ;
355  }
356  case PhysCaliTdiffComplete: {
357  sc = scanReadoutChannels(m_completePhysCaliTdiff) ;
358  break ;
359  }
360  case TdriftComplete: {
361  sc = scanReadoutChannels(m_completeTdrift) ;
362  break ;
363  }
364  case MphysOverMcalComplete: {
365  sc = scanReadoutChannels(m_completeMphysOverMcal) ;
366  break ;
367  }
368  case RinjComplete: {
369  sc = scanReadoutChannels(m_completeRinj) ;
370  break ;
371  }
372  case TshaperComplete: {
373  sc = scanReadoutChannels(m_completeTshaper) ;
374  break ;
375  }
376  case EMEC_CphiComplete: {
377  sc = scanReadoutChannels(m_completeEMEC_Cphi) ;
378  break ;
379  }
380  case EMEC_HValphaComplete: {
381  sc = scanReadoutChannels(m_completeEMEC_HValpha) ;
382  break ;
383  }
384  case EMEC_HVbetaComplete: {
385  sc = scanReadoutChannels(m_completeEMEC_HVbeta) ;
386  break ;
387  }
388  case CableLengthComplete: {
389  sc = scanReadoutChannels(m_completeCableLength) ;
390  break ;
391  }
392  case CableAttenuationComplete: {
393  sc = scanReadoutChannels(m_completeCableAttenuation) ;
394  break ;
395  }
396  //case CaliPulseParamsVsCalib: {
397  //sc = scanCalibChannels(m_calibCaliPulseParams) ;
398  //break ;
399  //}
400  case OFCBinComplete: {
401  sc = scanReadoutChannels(m_completeOFCBin) ;
402  break ;
403  }
404  } // end switch
405 
406  } // end of the channels scan
407 
408  }
409 
410  //
411  // ... then fill the ntuple
412  //
413 
414  for ( unsigned gain=0 ; (int)gain<nGains ; gain++) {
415 
416  for (const std::pair<const HWIdentifier, DumpFlags>& p : m_dump_flags_map[gain]) {
417  HWIdentifier chid = HWIdentifier(p.first) ;
418 
419  const std::vector<bool> & flags = (p.second).flags() ;
420  if ( flags.empty() ) continue ;
421  if ( flags.size() < m_nClasses ) { // should never happen...
422  ATH_MSG_WARNING( "... flags vector shorter than " << m_nClasses << ": " << flags.size() ) ;
423  continue ;
424  }
425 
426  fillFromIdentifier(chid); //Fill common values by base-class
427 
428  if ( flags[CaliPulseParamsComplete] ) {
429  ntTcal = m_completeCaliPulseParams->Tcal(chid,gain) ;
430  ntFstep = m_completeCaliPulseParams->Fstep(chid,gain) ;
431  ntOffset = m_completeCaliPulseParams->Offset(chid,gain) ;
432  ntdTimeCal = m_completeCaliPulseParams->dTimeCal(chid,gain) ;
433  ntnCB = m_completeCaliPulseParams->nCB(chid,gain) ;
434 
435  }
436  if ( flags[DetCellParamsComplete] ) {
437  ntOmega0 = m_completeDetCellParams->Omega0(chid,gain) ;
438  ntTaur = m_completeDetCellParams->Taur(chid,gain) ;
439  }
440  if ( flags[PhysCaliTdiffComplete] ) {
441  ntTdiff = m_completePhysCaliTdiff->Tdiff(chid,gain) ;
442  }
443  if ( flags[TdriftComplete] ) {
444  ntTdrift = m_completeTdrift->Tdrift(chid) ;
445  }
446  if ( flags[MphysOverMcalComplete] ) {
447  ntMphysOverMcal = m_completeMphysOverMcal->MphysOverMcal(chid,gain) ;
448  }
449  if ( flags[RinjComplete] ) {
450  ntRinj = m_completeRinj->Rinj(chid) ;
451  }
452  if ( flags[TshaperComplete] ) {
453  ntTshaper = m_completeTshaper->Tshaper(chid) ;
454  }
455  if ( flags[EMEC_CphiComplete] ) {
456  ntEMEC_Cphi = m_completeEMEC_Cphi->EMEC_Cphi(chid) ;
457  }
458  if ( flags[EMEC_HValphaComplete] ) {
459  ntEMEC_HValpha = m_completeEMEC_HValpha->EMEC_HValpha(chid) ;
460  }
461  if ( flags[EMEC_HVbetaComplete] ) {
462  ntEMEC_HVbeta = m_completeEMEC_HVbeta->EMEC_HVbeta(chid) ;
463  }
464  if ( flags[CableLengthComplete] ) {
465  ntCableLength = m_completeCableLength->CableLength(chid) ;
466  }
467  if ( flags[CableAttenuationComplete] ) {
468  ntCableAttenuation = m_completeCableAttenuation->CableAttenuation(chid) ;
469  }
470  /*
471  if ( flags[CaliPulseParamsVsCalib] ) {
472  ntTcal = m_calibCaliPulseParams->Tcal(chid,gain) ;
473  ntFstep = m_calibCaliPulseParams->Fstep(chid,gain) ;
474  ntOffset = m_calibCaliPulseParams->Offset(chid,gain) ;
475  ntdTimeCal = m_calibCaliPulseParams->dTimeCal(chid,gain) ;
476  ntnCB = m_calibCaliPulseParams->nCB(chid,gain) ;
477  }
478  */
479  if ( flags[OFCBinComplete] ) {
480  ntbin = m_completeOFCBin->bin(chid,gain) ;
481  }
482  sc=ntupleSvc()->writeRecord(m_nt);
483  if (sc!=StatusCode::SUCCESS) {
484  ATH_MSG_ERROR( "writeRecord failed" );
485  return StatusCode::FAILURE;
486  }
487  ATH_MSG_DEBUG("... record written to ntuple");
488  } // end channel loop
489  } // end gain loop
490 
491 ATH_MSG_INFO("LArParams2Ntuple has finished.");
492  return StatusCode::SUCCESS;
493 }// end stop-method.

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::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< Algorithm > >::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_addBC

Gaudi::Property< bool > LArCond2NtupleBase::m_addBC {this, "AddBadChannelInfo", true, "dump BadChan info ?"}
protectedinherited

Definition at line 53 of file LArCond2NtupleBase.h.

◆ m_addCalib

Gaudi::Property< bool > LArCond2NtupleBase::m_addCalib {this, "AddCalib", false, "add also calib line info info ?"}
protectedinherited

Definition at line 59 of file LArCond2NtupleBase.h.

◆ m_addFEBTemp

Gaudi::Property< bool > LArCond2NtupleBase::m_addFEBTemp {this, "AddFEBTempInfo", false, "dump FEB temperature info ?"}
protectedinherited

Definition at line 54 of file LArCond2NtupleBase.h.

◆ m_addHash

Gaudi::Property< bool > LArCond2NtupleBase::m_addHash {this, "AddHash", false, "add also ID hash info ?"}
protectedinherited

Definition at line 58 of file LArCond2NtupleBase.h.

◆ m_allChannels2Ntuple

bool LArParams2Ntuple::m_allChannels2Ntuple
private

Definition at line 42 of file LArParams2Ntuple.h.

◆ m_badChanWord

NTuple::Item<long> LArCond2NtupleBase::m_badChanWord
protectedinherited

Definition at line 73 of file LArCond2NtupleBase.h.

◆ m_barrel_ec

NTuple::Item<long> LArCond2NtupleBase::m_barrel_ec
protectedinherited

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_BCKey

SG::ReadCondHandleKey<LArBadChannelCont> LArCond2NtupleBase::m_BCKey {this, "BadChanKey", "LArBadChannel", "SG bad channels key"}
protectedinherited

Definition at line 92 of file LArCond2NtupleBase.h.

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCond2NtupleBase::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
protectedinherited

Definition at line 89 of file LArCond2NtupleBase.h.

◆ m_cablingSCKey

SG::ReadCondHandleKey<LArOnOffIdMapping> LArCond2NtupleBase::m_cablingSCKey {this,"CablingSCKey","LArOnOffIdMapSC","SG Key of LArOnOffIdMapping object"}
protectedinherited

Definition at line 90 of file LArCond2NtupleBase.h.

◆ m_calibLine

NTuple::Item<long> LArCond2NtupleBase::m_calibLine
protectedinherited

Definition at line 73 of file LArCond2NtupleBase.h.

◆ m_calibMapKey

SG::ReadCondHandleKey<LArCalibLineMapping> LArCond2NtupleBase::m_calibMapKey {this,"CalibMapKey","LArCalibLineMap","SG Key of calib line mapping object"}
protectedinherited

Definition at line 93 of file LArCond2NtupleBase.h.

◆ m_calibMapSCKey

SG::ReadCondHandleKey<LArCalibLineMapping> LArCond2NtupleBase::m_calibMapSCKey {this,"CalibMapSCKey","LArCalibIdMapSC","SG Key of calib line mapping object"}
protectedinherited

Definition at line 94 of file LArCond2NtupleBase.h.

◆ m_caloId

const CaloCell_Base_ID* LArCond2NtupleBase::m_caloId
protectedinherited

Definition at line 86 of file LArCond2NtupleBase.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> LArCond2NtupleBase::m_caloMgrKey {this, "CaloDetDescrManager", "CaloDetDescrManager", "SG Key for CaloDetDescrManager in the Condition Store"}
protectedinherited

Definition at line 96 of file LArCond2NtupleBase.h.

◆ m_caloSuperCellMgrKey

SG::ReadCondHandleKey<CaloSuperCellDetDescrManager> LArCond2NtupleBase::m_caloSuperCellMgrKey {this, "CaloSuperCellDetDescrManager", "CaloSuperCellDetDescrManager", "SG key of the resulting CaloSuperCellDetDescrManager" }
protectedinherited

Definition at line 97 of file LArCond2NtupleBase.h.

◆ m_chanHash

NTuple::Item<long> LArCond2NtupleBase::m_chanHash
protectedinherited

Definition at line 75 of file LArCond2NtupleBase.h.

◆ m_channel

NTuple::Item<long> LArCond2NtupleBase::m_channel
protectedinherited

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_classNames

std::vector<std::string> LArParams2Ntuple::m_classNames
private

Definition at line 39 of file LArParams2Ntuple.h.

◆ m_completeCableAttenuation

const LArCableAttenuationComplete* LArParams2Ntuple::m_completeCableAttenuation
private

Definition at line 76 of file LArParams2Ntuple.h.

◆ m_completeCableLength

const LArCableLengthComplete* LArParams2Ntuple::m_completeCableLength
private

Definition at line 75 of file LArParams2Ntuple.h.

◆ m_completeCaliPulseParams

const LArCaliPulseParamsComplete* LArParams2Ntuple::m_completeCaliPulseParams
private

Definition at line 65 of file LArParams2Ntuple.h.

◆ m_completeDetCellParams

const LArDetCellParamsComplete* LArParams2Ntuple::m_completeDetCellParams
private

Definition at line 66 of file LArParams2Ntuple.h.

◆ m_completeEMEC_Cphi

const LArEMEC_CphiComplete* LArParams2Ntuple::m_completeEMEC_Cphi
private

Definition at line 72 of file LArParams2Ntuple.h.

◆ m_completeEMEC_HValpha

const LArEMEC_HValphaComplete* LArParams2Ntuple::m_completeEMEC_HValpha
private

Definition at line 73 of file LArParams2Ntuple.h.

◆ m_completeEMEC_HVbeta

const LArEMEC_HVbetaComplete* LArParams2Ntuple::m_completeEMEC_HVbeta
private

Definition at line 74 of file LArParams2Ntuple.h.

◆ m_completeMphysOverMcal

const LArMphysOverMcalComplete* LArParams2Ntuple::m_completeMphysOverMcal
private

Definition at line 69 of file LArParams2Ntuple.h.

◆ m_completeOFCBin

const LArOFCBinComplete* LArParams2Ntuple::m_completeOFCBin
private

Definition at line 78 of file LArParams2Ntuple.h.

◆ m_completePhysCaliTdiff

const LArPhysCaliTdiffComplete* LArParams2Ntuple::m_completePhysCaliTdiff
private

Definition at line 67 of file LArParams2Ntuple.h.

◆ m_completeRinj

const LArRinjComplete* LArParams2Ntuple::m_completeRinj
private

Definition at line 70 of file LArParams2Ntuple.h.

◆ m_completeTdrift

const LArTdriftComplete* LArParams2Ntuple::m_completeTdrift
private

Definition at line 68 of file LArParams2Ntuple.h.

◆ m_completeTshaper

const LArTshaperComplete* LArParams2Ntuple::m_completeTshaper
private

Definition at line 71 of file LArParams2Ntuple.h.

◆ m_detector

NTuple::Item<long> LArCond2NtupleBase::m_detector
protectedinherited

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_detStore

StoreGateSvc* LArCond2NtupleBase::m_detStore
protectedinherited

Definition at line 81 of file LArCond2NtupleBase.h.

◆ m_detStoreJo

std::vector<std::string> LArParams2Ntuple::m_detStoreJo
private

Definition at line 41 of file LArParams2Ntuple.h.

◆ m_detStoreKeys

std::vector<std::string> LArParams2Ntuple::m_detStoreKeys
private

Definition at line 40 of file LArParams2Ntuple.h.

◆ m_dump_flags_map

std::vector< std::map< HWIdentifier , DumpFlags > > LArParams2Ntuple::m_dump_flags_map
private

Definition at line 63 of file LArParams2Ntuple.h.

◆ m_dumpFlags

DumpFlags LArParams2Ntuple::m_dumpFlags
private

Definition at line 60 of file LArParams2Ntuple.h.

◆ m_emId

const LArEM_Base_ID* LArCond2NtupleBase::m_emId
protectedinherited

Definition at line 82 of file LArCond2NtupleBase.h.

◆ m_eta

NTuple::Item<long> LArCond2NtupleBase::m_eta
protectedinherited

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_expandId

Gaudi::Property< bool > LArCond2NtupleBase::m_expandId {this,"ExpandId", true ,"add online Id decoded fields ?"}
protectedinherited

Definition at line 61 of file LArCond2NtupleBase.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_fcalId

const LArFCAL_Base_ID* LArCond2NtupleBase::m_fcalId
protectedinherited

Definition at line 84 of file LArCond2NtupleBase.h.

◆ m_febHash

NTuple::Item<long> LArCond2NtupleBase::m_febHash
protectedinherited

Definition at line 75 of file LArCond2NtupleBase.h.

◆ m_FEBTemp1

NTuple::Item<float> LArCond2NtupleBase::m_FEBTemp1
protectedinherited

Definition at line 78 of file LArCond2NtupleBase.h.

◆ m_FEBTemp2

NTuple::Item<float> LArCond2NtupleBase::m_FEBTemp2
protectedinherited

Definition at line 78 of file LArCond2NtupleBase.h.

◆ m_FEBTempTool

ToolHandle<ILArFEBTempTool> LArCond2NtupleBase::m_FEBTempTool
protectedinherited

Definition at line 87 of file LArCond2NtupleBase.h.

◆ m_FT

NTuple::Item<long> LArCond2NtupleBase::m_FT
protectedinherited

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_hecId

const LArHEC_Base_ID* LArCond2NtupleBase::m_hecId
protectedinherited

Definition at line 83 of file LArCond2NtupleBase.h.

◆ m_initialized

bool LArCond2NtupleBase::m_initialized
privateinherited

Definition at line 50 of file LArCond2NtupleBase.h.

◆ m_isConnected

NTuple::Item<long> LArCond2NtupleBase::m_isConnected
protectedinherited

Definition at line 74 of file LArCond2NtupleBase.h.

◆ m_isFlat

Gaudi::Property< bool > LArCond2NtupleBase::m_isFlat {this, "isFlat", false, "are we working with Flat conditions ?"}
protectedinherited

Definition at line 56 of file LArCond2NtupleBase.h.

◆ m_isSC

Gaudi::Property< bool > LArCond2NtupleBase::m_isSC {this, "isSC", false, "are we working with SC?"}
protectedinherited

Definition at line 55 of file LArCond2NtupleBase.h.

◆ m_keylist

std::vector<std::string> LArParams2Ntuple::m_keylist
private

Definition at line 59 of file LArParams2Ntuple.h.

◆ m_layer

NTuple::Item<long> LArCond2NtupleBase::m_layer
protectedinherited

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_nClasses

const unsigned LArParams2Ntuple::m_nClasses = LArParamsProperties::END_OF_LIST
staticprivate

Definition at line 46 of file LArParams2Ntuple.h.

◆ m_nt

NTuple::Tuple* LArCond2NtupleBase::m_nt
protectedinherited

Definition at line 68 of file LArCond2NtupleBase.h.

◆ m_ntName

std::string LArParams2Ntuple::m_ntName
private

Definition at line 44 of file LArParams2Ntuple.h.

◆ m_ntpath

std::string LArCond2NtupleBase::m_ntpath
protectedinherited

Definition at line 65 of file LArCond2NtupleBase.h.

◆ m_ntTitle

std::string LArCond2NtupleBase::m_ntTitle
protectedinherited

Definition at line 65 of file LArCond2NtupleBase.h.

◆ m_OffId

Gaudi::Property< bool > LArCond2NtupleBase::m_OffId {this, "OffId", false, "dump also offline ID ?"}
protectedinherited

Definition at line 57 of file LArCond2NtupleBase.h.

◆ m_oflChanId

NTuple::Item<long> LArCond2NtupleBase::m_oflChanId
protectedinherited

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_oflHash

NTuple::Item<long> LArCond2NtupleBase::m_oflHash
protectedinherited

Definition at line 75 of file LArCond2NtupleBase.h.

◆ m_onlChanId

NTuple::Item<long> LArCond2NtupleBase::m_onlChanId
protectedinherited

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_onlineId

const LArOnlineID_Base* LArCond2NtupleBase::m_onlineId
protectedinherited

Definition at line 85 of file LArCond2NtupleBase.h.

◆ m_phi

NTuple::Item<long> LArCond2NtupleBase::m_phi
protectedinherited

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_pos_neg

NTuple::Item<long> LArCond2NtupleBase::m_pos_neg
protectedinherited

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_realgeom

Gaudi::Property< bool > LArCond2NtupleBase::m_realgeom {this, "RealGeometry", false, "add real geometry values ?"}
protectedinherited

Definition at line 60 of file LArCond2NtupleBase.h.

◆ m_region

NTuple::Item<long> LArCond2NtupleBase::m_region
protectedinherited

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_reta

NTuple::Item<float> LArCond2NtupleBase::m_reta
protectedinherited

Definition at line 77 of file LArCond2NtupleBase.h.

◆ m_rphi

NTuple::Item<float> LArCond2NtupleBase::m_rphi
protectedinherited

Definition at line 77 of file LArCond2NtupleBase.h.

◆ m_slot

NTuple::Item<long> LArCond2NtupleBase::m_slot
protectedinherited

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_suffix

std::string LArParams2Ntuple::m_suffix
private

Definition at line 61 of file LArParams2Ntuple.h.

◆ m_useAbstractInterface

bool LArParams2Ntuple::m_useAbstractInterface
private

Definition at line 43 of file LArParams2Ntuple.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
ILArEMEC_Cphi
Definition: ILArEMEC_Cphi.h:14
ILArEMEC_HVbeta
Definition: ILArEMEC_HVbeta.h:13
LArParamsProperties::DetCellParamsComplete
@ DetCellParamsComplete
Definition: LArParamsProperties.h:82
LArEM_Base_ID::phi
int phi(const Identifier id) const
return phi according to :
LArParams2Ntuple::m_allChannels2Ntuple
bool m_allChannels2Ntuple
Definition: LArParams2Ntuple.h:42
LArEMEC_CphiComplete
This class implements the ILArEMEC_Cphi interface.
Definition: LArEMEC_CphiComplete.h:28
LArParams2Ntuple::DumpFlags::set
void set(unsigned i)
Definition: LArParams2Ntuple.h:53
ATH_MSG_FATAL
#define ATH_MSG_FATAL(x)
Definition: AthMsgStreamMacros.h:34
LArOnlineID_Base::channel_Hash
IdentifierHash channel_Hash(HWIdentifier channelId) const
Create channel_hash from channel_Id.
Definition: LArOnlineID_Base.cxx:1636
LArCond2NtupleBase::m_layer
NTuple::Item< long > m_layer
Definition: LArCond2NtupleBase.h:71
PlotCalibFromCool.ft
ft
Definition: PlotCalibFromCool.py:329
LArCond2NtupleBase::m_isConnected
NTuple::Item< long > m_isConnected
Definition: LArCond2NtupleBase.h:74
LArParams2Ntuple::m_completeCaliPulseParams
const LArCaliPulseParamsComplete * m_completeCaliPulseParams
Definition: LArParams2Ntuple.h:65
CaloCell_Base_ID::calo_cell_hash
IdentifierHash calo_cell_hash(const Identifier cellId) const
create hash id from 'global' cell id
LArCond2NtupleBase::m_detector
NTuple::Item< long > m_detector
Definition: LArCond2NtupleBase.h:71
LArTdriftComplete
This class implements the ILArTdrift interface.
Definition: LArTdriftComplete.h:24
LArHEC_Base_ID::eta
int eta(const Identifier id) const
return eta [0,9] outer part [0,3] inner part
LArCond2NtupleBase::m_fcalId
const LArFCAL_Base_ID * m_fcalId
Definition: LArCond2NtupleBase.h:84
LArCaliPulseParamsComplete::nCB
virtual const short & nCB(const HWIdentifier &CellID, int gain) const
Definition: LArCaliPulseParamsComplete.cxx:74
LArCond2NtupleBase::m_addFEBTemp
Gaudi::Property< bool > m_addFEBTemp
Definition: LArCond2NtupleBase.h:54
LArParams2Ntuple::m_dump_flags_map
std::vector< std::map< HWIdentifier, DumpFlags > > m_dump_flags_map
Definition: LArParams2Ntuple.h:63
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LArPhysCaliTdiffComplete::Tdiff
virtual const float & Tdiff(const HWIdentifier &CellID, int gain) const
Definition: LArPhysCaliTdiffComplete.cxx:38
LArParams2Ntuple::m_completePhysCaliTdiff
const LArPhysCaliTdiffComplete * m_completePhysCaliTdiff
Definition: LArParams2Ntuple.h:67
LArCond2NtupleBase::m_slot
NTuple::Item< long > m_slot
Definition: LArCond2NtupleBase.h:72
AtlasDetectorID::is_lar_fcal
bool is_lar_fcal(Identifier id) const
Definition: AtlasDetectorID.h:834
LArCond2NtupleBase::m_addCalib
Gaudi::Property< bool > m_addCalib
Definition: LArCond2NtupleBase.h:59
LArCond2NtupleBase::m_pos_neg
NTuple::Item< long > m_pos_neg
Definition: LArCond2NtupleBase.h:72
LArOFCBinComplete::bin
virtual const int & bin(const HWIdentifier &chid, const int &gain) const
Definition: LArOFCBinComplete.h:19
ILArEMEC_HValpha
Definition: ILArEMEC_HValpha.h:13
LArCond2NtupleBase::m_onlChanId
NTuple::Item< long > m_onlChanId
Definition: LArCond2NtupleBase.h:71
LArParamsProperties::MphysOverMcalComplete
@ MphysOverMcalComplete
Definition: LArParamsProperties.h:85
LArParams2Ntuple::m_ntName
std::string m_ntName
Definition: LArParams2Ntuple.h:44
LArParams2Ntuple::m_keylist
std::vector< std::string > m_keylist
Definition: LArParams2Ntuple.h:59
LArParams2Ntuple::m_dumpFlags
DumpFlags m_dumpFlags
Definition: LArParams2Ntuple.h:60
AthenaPoolTestRead.flags
flags
Definition: AthenaPoolTestRead.py:8
ILArDetCellParams
Definition: ILArDetCellParams.h:13
LArBadXCont
Conditions-Data class holding LAr Bad Channel or Bad Feb information.
Definition: LArBadChannelCont.h:28
LArCalibLineMapping::calibSlotLine
const std::vector< HWIdentifier > & calibSlotLine(const HWIdentifier id) const
Definition: LArCalibLineMapping.cxx:15
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
defineDB.ichan
ichan
Definition: JetTagCalibration/share/defineDB.py:28
LArParamsProperties::EMEC_HVbetaComplete
@ EMEC_HVbetaComplete
Definition: LArParamsProperties.h:90
LArCalibLineMapping
Definition: LArCalibLineMapping.h:17
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
skel.it
it
Definition: skel.GENtoEVGEN.py:407
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx:1961
LArCond2NtupleBase::m_rphi
NTuple::Item< float > m_rphi
Definition: LArCond2NtupleBase.h:77
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
LArFCAL_Base_ID::module
int module(const Identifier id) const
module [1,3]
LArParams2Ntuple::m_completeOFCBin
const LArOFCBinComplete * m_completeOFCBin
Definition: LArParams2Ntuple.h:78
PlotCalibFromCool.nchan
nchan
Definition: PlotCalibFromCool.py:564
python.getProblemFolderFromLogs.elem
elem
Definition: getProblemFolderFromLogs.py:90
AthCommonMsg< Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
LArEM_Base_ID::region
int region(const Identifier id) const
return region according to :
LArCond2NtupleBase::m_oflHash
NTuple::Item< long > m_oflHash
Definition: LArCond2NtupleBase.h:75
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
LArParamsProperties::CableLengthComplete
@ CableLengthComplete
Definition: LArParamsProperties.h:91
CaloDetDescrManager_Base
Definition: CaloDetDescrManager.h:147
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
LArEMEC_HValphaComplete::EMEC_HValpha
virtual const float & EMEC_HValpha(const HWIdentifier &CellID) const
Definition: LArEMEC_HValphaComplete.cxx:35
CaloGain::LARNGAIN
@ LARNGAIN
Definition: CaloGain.h:19
LArCond2NtupleBase::initialize
StatusCode initialize()
Definition: LArCond2NtupleBase.cxx:33
LArOnlineID_Base::barrel_ec
int barrel_ec(const HWIdentifier id) const
Return the position barrel or endcap of a hardware cell identifier: barrel_ec = [0,...
Definition: LArOnlineID_Base.cxx:1942
LArCond2NtupleBase::m_cablingSCKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingSCKey
Definition: LArCond2NtupleBase.h:90
LArBadXCont::status
LArBC_t status(const HWIdentifier channel) const
Query the status of a particular channel or FEB This is the main client access method.
LArCableLengthComplete
This class implements the ILArCableLength interface.
Definition: LArCableLengthComplete.h:27
LArTshaperComplete::Tshaper
virtual const float & Tshaper(const HWIdentifier &CellID) const
Definition: LArTshaperComplete.cxx:24
LArCond2NtupleBase::NOT_VALID
@ NOT_VALID
Definition: LArCond2NtupleBase.h:63
LArParamsProperties::isGainDependent
bool isGainDependent(unsigned index)
Definition: LArParamsProperties.cxx:101
LArEM_Base_ID::eta
int eta(const Identifier id) const
return eta according to :
FEBTemp
std::vector< std::pair< float, float > > FEBTemp
Definition: ILArFEBTempTool.h:27
LArCond2NtupleBase::m_FEBTempTool
ToolHandle< ILArFEBTempTool > m_FEBTempTool
Definition: LArCond2NtupleBase.h:87
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
LArCond2NtupleBase::m_barrel_ec
NTuple::Item< long > m_barrel_ec
Definition: LArCond2NtupleBase.h:72
LArFCAL_Base_ID::eta
int eta(const Identifier id) const
eta [0,63] module 1 ; [0,31] module 2 ; [0,15] module 3
LArMphysOverMcalComplete::MphysOverMcal
virtual const float & MphysOverMcal(const HWIdentifier &chid, int gain) const override
Definition: LArMphysOverMcalComplete.h:37
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
LArCond2NtupleBase::m_addHash
Gaudi::Property< bool > m_addHash
Definition: LArCond2NtupleBase.h:58
LArCaliPulseParamsComplete::dTimeCal
virtual const float & dTimeCal(const HWIdentifier &CellID, int gain) const
Definition: LArCaliPulseParamsComplete.cxx:68
LArParams2Ntuple::m_completeEMEC_Cphi
const LArEMEC_CphiComplete * m_completeEMEC_Cphi
Definition: LArParams2Ntuple.h:72
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
LArRinjComplete
This class implements the ILArRinj interface.
Definition: LArRinjComplete.h:26
LArCond2NtupleBase::m_febHash
NTuple::Item< long > m_febHash
Definition: LArCond2NtupleBase.h:75
ILArTdrift
Definition: ILArTdrift.h:12
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LArParams2Ntuple::m_completeMphysOverMcal
const LArMphysOverMcalComplete * m_completeMphysOverMcal
Definition: LArParams2Ntuple.h:69
LArFCAL_Base_ID::phi
int phi(const Identifier id) const
phi [0,15]
LArCond2NtupleBase::m_region
NTuple::Item< long > m_region
Definition: LArCond2NtupleBase.h:71
ILArRinj
Definition: ILArRinj.h:12
LArOnlineID_Base::channel
int channel(const HWIdentifier id) const
Return the channel number of a hardware cell identifier channel = [0,127] in all FEB.
Definition: LArOnlineID_Base.cxx:1967
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
AthCommonDataStore
Definition: AthCommonDataStore.h:52
LArCond2NtupleBase::m_addBC
Gaudi::Property< bool > m_addBC
Definition: LArCond2NtupleBase.h:53
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LArOnlineID_Base::channel_range
id_range channel_range() const
Definition: LArOnlineID_Base.cxx:1936
LArParams2Ntuple::retrieveAbstractInterface
StatusCode retrieveAbstractInterface(const LArCaliPulseParamsComplete *&data_object)
Definition: LArParams2Ntuple.cxx:681
LArCond2NtupleBase::m_badChanWord
NTuple::Item< long > m_badChanWord
Definition: LArCond2NtupleBase.h:73
LArCond2NtupleBase::m_phi
NTuple::Item< long > m_phi
Definition: LArCond2NtupleBase.h:71
LArMphysOverMcalComplete
This class implements the ILArMphysOverMcal interface.
Definition: LArMphysOverMcalComplete.h:29
LArDetCellParamsComplete::Omega0
virtual const float & Omega0(const HWIdentifier &CellID, int gain) const
Definition: LArDetCellParamsComplete.cxx:25
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
LArParams2Ntuple::m_classNames
std::vector< std::string > m_classNames
Definition: LArParams2Ntuple.h:39
LArParamsProperties::RinjComplete
@ RinjComplete
Definition: LArParamsProperties.h:86
LArParams2Ntuple::m_completeEMEC_HVbeta
const LArEMEC_HVbetaComplete * m_completeEMEC_HVbeta
Definition: LArParams2Ntuple.h:74
lumiFormat.i
int i
Definition: lumiFormat.py:85
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
LArPhysCaliTdiffComplete
This class implements the ILArPhysCaliTdiff interface ` *.
Definition: LArPhysCaliTdiffComplete.h:22
LArCond2NtupleBase::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArCond2NtupleBase.h:89
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArCond2NtupleBase::m_FEBTemp1
NTuple::Item< float > m_FEBTemp1
Definition: LArCond2NtupleBase.h:78
LArCableLengthComplete::CableLength
virtual const float & CableLength(const HWIdentifier &CellID) const
Definition: LArCableLengthComplete.cxx:25
LArCond2NtupleBase::m_caloSuperCellMgrKey
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSuperCellMgrKey
Definition: LArCond2NtupleBase.h:97
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
LArCond2NtupleBase::m_ntpath
std::string m_ntpath
Definition: LArCond2NtupleBase.h:65
LArParams2Ntuple::DumpFlags::clear
void clear(unsigned i)
Definition: LArParams2Ntuple.h:54
LArParamsProperties::OFCBinComplete
@ OFCBinComplete
Definition: LArParamsProperties.h:94
LArCond2NtupleBase::m_calibMapKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapKey
Definition: LArCond2NtupleBase.h:93
LArCond2NtupleBase::m_BCKey
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey
Definition: LArCond2NtupleBase.h:92
LArCond2NtupleBase::m_nt
NTuple::Tuple * m_nt
Definition: LArCond2NtupleBase.h:68
LArOnlineID_Base::channel_Id
HWIdentifier channel_Id(int barrel_ec, int pos_neg, int feedthrough, int slot, int channel) const
create channel identifier from fields
Definition: LArOnlineID_Base.cxx:1569
LArEMEC_HVbetaComplete
This class implements the ILArEMEC_HVbeta interface.
Definition: LArEMEC_HVbetaComplete.h:28
LArOnlineID_Base::pos_neg
int pos_neg(const HWIdentifier id) const
Return the side of a hardware cell identifier pos_neg = [0,1] positive-side or negative-side Barrel...
Definition: LArOnlineID_Base.cxx:1954
LArEMEC_HValphaComplete
This class implements the ILArEMEC_HValpha interface.
Definition: LArEMEC_HValphaComplete.h:28
AtlasDetectorID::is_lar_hec
bool is_lar_hec(Identifier id) const
Definition: AtlasDetectorID.h:824
LArCond2NtupleBase::m_expandId
Gaudi::Property< bool > m_expandId
Definition: LArCond2NtupleBase.h:61
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
LArDetCellParamsComplete::Taur
virtual const float & Taur(const HWIdentifier &CellID, int gain) const
Definition: LArDetCellParamsComplete.cxx:31
LArCableAttenuationComplete
This class implements the ILArCableAttenuation interface.
Definition: LArCableAttenuationComplete.h:27
ILArCableLength
Definition: ILArCableLength.h:13
LArParamsProperties::CaliPulseParamsComplete
@ CaliPulseParamsComplete
Definition: LArParamsProperties.h:81
LArCaliPulseParamsComplete
This class implements the ILArCaliPulseParams interface.
Definition: LArCaliPulseParamsComplete.h:29
LArOnlineID_Base::feb_Id
HWIdentifier feb_Id(int barrel_ec, int pos_neg, int feedthrough, int slot) const
Create feb_Id from fields.
Definition: LArOnlineID_Base.cxx:1483
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
LArParams2Ntuple::m_suffix
std::string m_suffix
Definition: LArParams2Ntuple.h:61
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
ILArTshaper
Definition: ILArTshaper.h:12
LArCaliPulseParamsComplete::Fstep
virtual const float & Fstep(const HWIdentifier &CellID, int gain) const
Definition: LArCaliPulseParamsComplete.cxx:56
LArCond2NtupleBase::m_eta
NTuple::Item< long > m_eta
Definition: LArCond2NtupleBase.h:71
LArParamsProperties::EMEC_CphiComplete
@ EMEC_CphiComplete
Definition: LArParamsProperties.h:88
LArEMEC_HVbetaComplete::EMEC_HVbeta
virtual const float & EMEC_HVbeta(const HWIdentifier &CellID) const
Definition: LArEMEC_HVbetaComplete.cxx:35
LArParamsProperties::PhysCaliTdiffComplete
@ PhysCaliTdiffComplete
Definition: LArParamsProperties.h:83
LArCond2NtupleBase::LArCond2NtupleBase
LArCond2NtupleBase(const std::string &name, ISvcLocator *pSvcLocator)
Definition: LArCond2NtupleBase.cxx:15
LArCaliPulseParamsComplete::Offset
virtual const float & Offset(const HWIdentifier &CellID, int gain) const
Definition: LArCaliPulseParamsComplete.cxx:62
LArCableAttenuationComplete::CableAttenuation
virtual const float & CableAttenuation(const HWIdentifier &CellID) const
Definition: LArCableAttenuationComplete.cxx:25
LArParams2Ntuple::m_completeRinj
const LArRinjComplete * m_completeRinj
Definition: LArParams2Ntuple.h:70
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
LArParams2Ntuple::retrieveFromDetStore
StatusCode retrieveFromDetStore(const DATA *&data_object)
Definition: LArParams2Ntuple.cxx:641
ILArMphysOverMcal
Definition: ILArMphysOverMcal.h:13
LArCond2NtupleBase::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: LArCond2NtupleBase.h:96
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
LArCond2NtupleBase::m_ntTitle
std::string m_ntTitle
Definition: LArCond2NtupleBase.h:65
LArEM_Base_ID::barrel_ec
int barrel_ec(const Identifier id) const
return barrel_ec according to :
LArParams2Ntuple::m_completeEMEC_HValpha
const LArEMEC_HValphaComplete * m_completeEMEC_HValpha
Definition: LArParams2Ntuple.h:73
LArParams2Ntuple::m_useAbstractInterface
bool m_useAbstractInterface
Definition: LArParams2Ntuple.h:43
LArCond2NtupleBase::m_onlineId
const LArOnlineID_Base * m_onlineId
Definition: LArCond2NtupleBase.h:85
LArParamsProperties::TdriftComplete
@ TdriftComplete
Definition: LArParamsProperties.h:84
LArCond2NtupleBase::m_oflChanId
NTuple::Item< long > m_oflChanId
Definition: LArCond2NtupleBase.h:71
LArParams2Ntuple::m_completeDetCellParams
const LArDetCellParamsComplete * m_completeDetCellParams
Definition: LArParams2Ntuple.h:66
LArCond2NtupleBase::m_realgeom
Gaudi::Property< bool > m_realgeom
Definition: LArCond2NtupleBase.h:60
LArParamsProperties::TshaperComplete
@ TshaperComplete
Definition: LArParamsProperties.h:87
LArOnlineID_Base::calib_channel_range
id_range calib_channel_range() const
Definition: LArOnlineID_Base.h:715
LArParams2Ntuple::m_completeCableAttenuation
const LArCableAttenuationComplete * m_completeCableAttenuation
Definition: LArParams2Ntuple.h:76
LArCond2NtupleBase::fillFromIdentifier
bool fillFromIdentifier(const HWIdentifier &id)
Definition: LArCond2NtupleBase.cxx:288
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
LArRinjComplete::Rinj
virtual const float & Rinj(const HWIdentifier &CellID) const
Definition: LArRinjComplete.cxx:24
ILArPhysCaliTdiff
Definition: ILArPhysCaliTdiff.h:13
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx:1948
LArParamsProperties::CableAttenuationComplete
@ CableAttenuationComplete
Definition: LArParamsProperties.h:92
a
TList * a
Definition: liststreamerinfos.cxx:10
h
python.CaloAddPedShiftConfig.int
int
Definition: CaloAddPedShiftConfig.py:45
LArCond2NtupleBase::m_FEBTemp2
NTuple::Item< float > m_FEBTemp2
Definition: LArCond2NtupleBase.h:78
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LArParams2Ntuple::m_completeTdrift
const LArTdriftComplete * m_completeTdrift
Definition: LArParams2Ntuple.h:68
LArCond2NtupleBase::m_reta
NTuple::Item< float > m_reta
Definition: LArCond2NtupleBase.h:77
LArHEC_Base_ID::sampling
int sampling(const Identifier id) const
return sampling [0,3] (only 0 for supercells)
LArCond2NtupleBase::m_isSC
Gaudi::Property< bool > m_isSC
Definition: LArCond2NtupleBase.h:55
LArParams2Ntuple::m_nClasses
static const unsigned m_nClasses
Definition: LArParams2Ntuple.h:46
LArParamsProperties::isValid
bool isValid(const LArCaliPulseParamsP &p)
Definition: LArParamsProperties.cxx:10
LArNewCalib_DelayDump_OFC_Cali.idx
idx
Definition: LArNewCalib_DelayDump_OFC_Cali.py:69
ILArCableAttenuation
Definition: ILArCableAttenuation.h:14
LArParamsProperties::ClassNames
const std::vector< std::string > & ClassNames()
Definition: LArParamsProperties.cxx:48
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
LArCaliPulseParamsComplete::Tcal
virtual const float & Tcal(const HWIdentifier &CellID, int gain) const
Definition: LArCaliPulseParamsComplete.cxx:50
LArCond2NtupleBase::m_detStore
StoreGateSvc * m_detStore
Definition: LArCond2NtupleBase.h:81
WriteCellNoiseToCool.useGain
useGain
Definition: WriteCellNoiseToCool.py:343
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
LArParamsProperties::getClassIndex
unsigned getClassIndex(const LArCaliPulseParamsComplete *)
Definition: LArParamsProperties.cxx:31
LArParams2Ntuple::m_completeTshaper
const LArTshaperComplete * m_completeTshaper
Definition: LArParams2Ntuple.h:71
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
LArTdriftComplete::Tdrift
virtual const float & Tdrift(const HWIdentifier &CellID) const
Definition: LArTdriftComplete.cxx:26
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
LArCond2NtupleBase::m_chanHash
NTuple::Item< long > m_chanHash
Definition: LArCond2NtupleBase.h:75
LArCond2NtupleBase::m_calibMapSCKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapSCKey
Definition: LArCond2NtupleBase.h:94
LArCond2NtupleBase::m_hecId
const LArHEC_Base_ID * m_hecId
Definition: LArCond2NtupleBase.h:83
LArCond2NtupleBase::m_calibLine
NTuple::Item< long > m_calibLine
Definition: LArCond2NtupleBase.h:73
ntupleSvc
INTupleSvc * ntupleSvc()
Definition: ServiceAccessor.h:14
LArParamsProperties::keyword
std::string keyword(const std::string &classname)
Definition: LArParamsProperties.cxx:160
LArParams2Ntuple::m_completeCableLength
const LArCableLengthComplete * m_completeCableLength
Definition: LArParams2Ntuple.h:75
LArHEC_Base_ID::region
int region(const Identifier id) const
return region [0,1]
LArOnlineID_Base::calib_channel_Id
HWIdentifier calib_channel_Id(int barrel_ec, int pos_neg, int feedthrough, int slot, int channel) const
create calibration channel identifiers from fields
Definition: LArOnlineID_Base.h:616
AtlasDetectorID::is_lar_em
bool is_lar_em(Identifier id) const
Definition: AtlasDetectorID.h:813
LArEMEC_CphiComplete::EMEC_Cphi
virtual const float & EMEC_Cphi(const HWIdentifier &CellID) const
Definition: LArEMEC_CphiComplete.cxx:36
LArCond2NtupleBase::m_FT
NTuple::Item< long > m_FT
Definition: LArCond2NtupleBase.h:72
LArParamsProperties::EMEC_HValphaComplete
@ EMEC_HValphaComplete
Definition: LArParamsProperties.h:89
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
LArOnlineID_Base::feb_Hash
IdentifierHash feb_Hash(HWIdentifier febId) const
Create feb hash identifiers from feb identifiers.
Definition: LArOnlineID_Base.cxx:1516
LArCond2NtupleBase::m_caloId
const CaloCell_Base_ID * m_caloId
Definition: LArCond2NtupleBase.h:86
LArParams2Ntuple::scanReadoutChannels
StatusCode scanReadoutChannels(const DATA *&data_object)
Definition: LArParams2Ntuple.cxx:497
LArCond2NtupleBase::m_OffId
Gaudi::Property< bool > m_OffId
Definition: LArCond2NtupleBase.h:57
LArParams2Ntuple::m_detStoreKeys
std::vector< std::string > m_detStoreKeys
Definition: LArParams2Ntuple.h:40
ILArCaliPulseParams
Definition: ILArCaliPulseParams.h:14
fitman.k
k
Definition: fitman.py:528
LArDetCellParamsComplete
This class implements the ILArDetCellParams interface.
Definition: LArDetCellParamsComplete.h:26
LArHEC_Base_ID::phi
int phi(const Identifier id) const
return phi[0,63] outer part [0,31] inner part
ServiceHandle< ICondSvc >
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
LArCond2NtupleBase::m_channel
NTuple::Item< long > m_channel
Definition: LArCond2NtupleBase.h:72
LArParams2Ntuple::m_detStoreJo
std::vector< std::string > m_detStoreJo
Definition: LArParams2Ntuple.h:41
LArTshaperComplete
This class implements the ILArTshaper interface.
Definition: LArTshaperComplete.h:27
LArCond2NtupleBase::m_emId
const LArEM_Base_ID * m_emId
Definition: LArCond2NtupleBase.h:82
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Oct 30 2025 21:35:40 for ATLAS Offline Software by   doxygen 1.8.18