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

This algrithm produces a column-wise NTuple out of a LArRawRampContainer. More...

#include <LArRamps2Ntuple.h>

Inheritance diagram for LArRamps2Ntuple:
Collaboration diagram for LArRamps2Ntuple:

Public Member Functions

 LArRamps2Ntuple (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~LArRamps2Ntuple ()
 
StatusCode initialize ()
 
virtual StatusCode stop ()
 
StatusCode finalize ()
 
StatusCode execute ()
 
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 > &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
 
StoreGateSvcm_detStore
 
const LArEM_Base_IDm_emId
 
const LArHEC_Base_IDm_hecId
 
const LArFCAL_Base_IDm_fcalId
 
const LArOnlineID_Basem_onlineId
 
const CaloCell_Base_IDm_caloId
 
ToolHandle< ILArFEBTempToolm_FEBTempTool
 
SG::ReadCondHandleKey< LArOnOffIdMappingm_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
 
SG::ReadCondHandleKey< LArOnOffIdMappingm_cablingSCKey {this,"CablingSCKey","LArOnOffIdMapSC","SG Key of LArOnOffIdMapping object"}
 
SG::ReadCondHandleKey< LArBadChannelContm_BCKey {this, "BadChanKey", "LArBadChannel", "SG bad channels key"}
 
SG::ReadCondHandleKey< LArCalibLineMappingm_calibMapKey {this,"CalibMapKey","LArCalibLineMap","SG Key of calib line mapping object"}
 
SG::ReadCondHandleKey< LArCalibLineMappingm_calibMapSCKey {this,"CalibMapSCKey","LArCalibIdMapSC","SG Key of calib line mapping object"}
 
SG::ReadCondHandleKey< CaloDetDescrManagerm_caloMgrKey {this, "CaloDetDescrManager", "CaloDetDescrManager", "SG Key for CaloDetDescrManager in the Condition Store"}
 
SG::ReadCondHandleKey< CaloSuperCellDetDescrManagerm_caloSuperCellMgrKey {this, "CaloSuperCellDetDescrManager", "CaloSuperCellDetDescrManager", "SG key of the resulting CaloSuperCellDetDescrManager" }
 

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

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

Private Attributes

bool m_rawRamp
 
bool m_saveAllSamples
 
bool m_applyCorr
 
bool m_addCorrUndo
 
std::vector< std::string > m_contKey
 
SG::ReadCondHandleKey< ILArRampm_rampKey
 
std::string m_ntName
 
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
 

Detailed Description

This algrithm produces a column-wise NTuple out of a LArRawRampContainer.

Only the finalize method is used, initalize and execute are empty. The key of the container is given by the jobOption 'ContainerKey'.

Author
W. Lampl
  1. 2. 2004 Modifications:
  • S. Laplace: 10/04: added a few fields (max sample, etc...)
  • S. Laplace: 03/05: added individual samples (on demand, driven by jobOption)

Definition at line 28 of file LArRamps2Ntuple.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

◆ LArRamps2Ntuple()

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

Definition at line 11 of file LArRamps2Ntuple.cxx.

11  :
12  LArCond2NtupleBase(name, pSvcLocator),
13  m_rampKey("LArRamp"){
14 
15  declareProperty("ContainerKey", m_contKey,
16  "List of keys of RawRamp containers");
17  declareProperty("RampKey", m_rampKey,
18  "Key of LArRampComplete or LArRampMC objects");
19  declareProperty("NtupleName", m_ntName ="RAMPS");
20  declareProperty("RawRamp", m_rawRamp = false);
21  declareProperty("SaveAllSamples", m_saveAllSamples = false);
22  declareProperty("ApplyCorr", m_applyCorr=false);
23  declareProperty("AddCorrUndo", m_addCorrUndo=true);
24 }

◆ ~LArRamps2Ntuple()

LArRamps2Ntuple::~LArRamps2Ntuple ( )
default

Member Function Documentation

◆ cablingKey()

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

Definition at line 449 of file LArCond2NtupleBase.cxx.

450 {
451  if(m_isSC) return m_cablingSCKey;
452  return m_cablingKey;
453 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< 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 > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

Definition at line 40 of file LArCond2NtupleBase.h.

40 {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()) {
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 ) {
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){
305  clCont={*clHdl};
306  }
307  else{
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){
320  cabling=*cablingHdl;
321  }
322  else{
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) {
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) {
345  }
346 
347  if(m_addCalib) {
349  const std::vector<HWIdentifier>& calibLineV=clCont->calibSlotLine(hwid);
350  if(!calibLineV.empty()) m_calibLine = m_onlineId->channel(calibLineV[0]);
351  }
352 
353 
354  if ( m_OffId ) {
359 
360  if(m_realgeom){
363  }
367  }
368 
369  if (m_addBC) m_badChanWord=0;
370  bool connected=false;
371 
372  const CaloDetDescrManager_Base* dd_man = nullptr;
373  if (m_realgeom) {
374  if(m_isSC) {
376  dd_man = *caloSuperCellMgrHandle;
377  }
378  else {
380  dd_man = *caloMgrHandle;
381  }
382  }
383 
384  try {
385  if (cabling->isOnlineConnected(hwid)) {
386  Identifier id=cabling->cnvToIdentifier(hwid);
387  if ( m_OffId ) {
388  m_oflChanId = id.get_identifier32().get_compact();
390 
391  if (dd_man) {
392  const CaloDetDescrElement *elem = dd_man->get_element(id);
393  if(!elem) {
394  ATH_MSG_WARNING("Do not have CDDE for "<<id.getString());
395  } else {
396  m_reta = elem->eta_raw();
397  m_rphi = elem->phi_raw();
398  }
399  }
400 
401  if (m_emId->is_lar_em(id)) {
402  m_eta = m_emId->eta(id);
403  m_phi = m_emId->phi(id);
404  m_layer = m_emId->sampling(id);
405  m_region = m_emId->region(id);
406  m_detector = std::abs(m_emId->barrel_ec(id)) - 1; //0-barrel, 1-EMEC-OW, 2-EMEC-IW
407  }
408  else if (m_hecId->is_lar_hec(id)) {
409  m_eta = m_hecId->eta(id);
410  m_phi = m_hecId->phi(id);
411  m_layer = m_hecId->sampling(id);
412  m_region = m_hecId->region(id);
413  m_detector = 3;
414  }
415  else if (m_fcalId->is_lar_fcal(id)) {
416  m_eta = m_fcalId->eta(id);
417  m_phi = m_fcalId->phi(id);
418  m_layer = m_fcalId->module(id);
419  m_region = 0;
420  m_detector = 4;
421  }
422  } // m_OffId
423  connected=true;
424  }//end if is connected
425  }catch (LArID_Exception & except) {}
426 
427  //bad-channel word
428  if (m_addBC) m_badChanWord=bcCont->status(hwid).packedData();
429  // FEB temperatures
430  if (m_addFEBTemp) {
431  FEBTemp tv = m_FEBTempTool->getFebTemp(hwid);
432  if( !tv.empty() ) {
433  FEBTemp::const_iterator itb = tv.begin();
434  FEBTemp::const_iterator ite = tv.end();
435  for(;itb!=ite;++itb) {
436  m_FEBTemp1 = (*itb).first;
437  m_FEBTemp2 = (*itb).second;
438  }
439  }
440  }
441 
442  if(m_addCalib) m_isConnected = (long)connected;
443 
444  return connected;
445 }

◆ finalize()

StatusCode LArRamps2Ntuple::finalize ( )
inline

Definition at line 37 of file LArRamps2Ntuple.h.

37 {return StatusCode::SUCCESS;}

◆ initialize()

StatusCode LArRamps2Ntuple::initialize ( )

Definition at line 26 of file LArRamps2Ntuple.cxx.

26  {
27  m_ntTitle="Ramps";
28  m_ntpath=std::string("/NTUPLES/FILE1/")+m_ntName;
29 
32 }

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

◆ stop()

StatusCode LArRamps2Ntuple::stop ( )
virtual

Definition at line 38 of file LArRamps2Ntuple.cxx.

38  {
39  bool hasRawRampContainer=false;
40  StatusCode sc;
41  NTuple::Item<long> cellIndex;
42  NTuple::Item<long> gain;
43  NTuple::Item<long> corrUndo;
44  NTuple::Array<float> SampleMax;
45  NTuple::Array<float> TimeMax;
46  NTuple::Array<float> DAC;
47  NTuple::Array<float> ADC;
48  NTuple::Array<long> NTriggers;
49 
50  // individual samples. Very dirty :-(
51  NTuple::Array<float> Sample0;
52  NTuple::Array<float> Sample1;
53  NTuple::Array<float> Sample2;
54  NTuple::Array<float> Sample3;
55  NTuple::Array<float> Sample4;
56  NTuple::Array<float> Sample5;
57  NTuple::Array<float> Sample6;
58 
59  // idem for RMS
60  NTuple::Array<float> RMS0;
61  NTuple::Array<float> RMS1;
62  NTuple::Array<float> RMS2;
63  NTuple::Array<float> RMS3;
64  NTuple::Array<float> RMS4;
65  NTuple::Array<float> RMS5;
66  NTuple::Array<float> RMS6;
67 
68  NTuple::Item<unsigned long> DACIndex;
69  NTuple::Array<float> coeffs;
70  NTuple::Item<unsigned long> coeffIndex;
71 
72  NTuple::Item<float> RampRMS;
73 
74  if (m_rawRamp && !m_contKey.empty()) {
75  //Retrieve Raw Ramp Container
76  for (const std::string& key : m_contKey) {
77  LArRawRampContainer* rawRampContainer=nullptr;
78  sc=m_detStore->retrieve(rawRampContainer,key);
79  if (sc!=StatusCode::SUCCESS || !rawRampContainer) {
80  ATH_MSG_WARNING( "Unable to retrieve LArRawRampContainer with key " << key );
81  }
82  else {
83  ATH_MSG_DEBUG( "Got LArRawRampContainer with key " << key );
84  hasRawRampContainer = true;
85  }
86  }
87  if (!hasRawRampContainer) ATH_MSG_WARNING( " No LArRawRampContainer found. Only fitted ramp in ntuple " );
88 
89  }
90  //end-if m_rawRamp
91 
92 
93  // For compatibility with existing configurations, look in the detector
94  // store first, then in conditions.
95  const ILArRamp* ramp =
96  detStore()->tryConstRetrieve<ILArRamp> (m_rampKey.key());
97  if (!ramp) {
99  ramp = *readHandle;
100  }
101 
102  LArRampComplete* rampComplete_nc=nullptr; //for (potential) applyCorr
103 
104  if (ramp==nullptr) {
105  ATH_MSG_WARNING( "Unable to retrieve ILArRamp with key: "<<m_rampKey << " from DetectorStore" );
106  }
107 
108  if (!ramp && !hasRawRampContainer) {
109  ATH_MSG_ERROR( "Have neither Raw Ramp nor Fitted Ramp. No Ntuple produced." );
110  return StatusCode::FAILURE;
111  }
112 
113  sc=m_nt->addItem("cellIndex",cellIndex,0,2000);
114  if (sc!=StatusCode::SUCCESS) {
115  ATH_MSG_ERROR( "addItem 'Cell Index' failed" );
116  return StatusCode::FAILURE;
117  }
118 
119  sc=m_nt->addItem("gain",gain,0,3);
120  if (sc!=StatusCode::SUCCESS) {
121  ATH_MSG_ERROR( "addItem 'gain' failed" );
122  return StatusCode::FAILURE;
123  }
124 
125  if (m_addCorrUndo) {
126  sc=m_nt->addItem("corrUndo",corrUndo,0,1);
127  if (sc!=StatusCode::SUCCESS) {
128  ATH_MSG_ERROR( "addItem 'corrUndo' failed" );
129  return StatusCode::FAILURE;
130  }
131  }
132 
133  if (hasRawRampContainer)
134  {
135  sc=m_nt->addItem("DACIndex",DACIndex,0,800);
136  if (sc!=StatusCode::SUCCESS) {
137  ATH_MSG_ERROR( "addItem 'DACIndex' failed" );
138  return StatusCode::FAILURE;
139  }
140 
141  sc=m_nt->addItem("SampleMax",DACIndex,SampleMax);
142  if (sc!=StatusCode::SUCCESS)
143  {ATH_MSG_ERROR( "addItem 'SampleMax' failed" );
144  return StatusCode::FAILURE;
145  }
146 
147  sc=m_nt->addItem("TimeMax",DACIndex,TimeMax);
148  if (sc!=StatusCode::SUCCESS)
149  {ATH_MSG_ERROR( "addItem 'TimeMax' failed" );
150  return StatusCode::FAILURE;
151  }
152  sc=m_nt->addItem("ADC",DACIndex,ADC);
153  if (sc!=StatusCode::SUCCESS)
154  {ATH_MSG_ERROR( "addItem 'ADC' failed" );
155  return StatusCode::FAILURE;
156  }
157 
158  sc=m_nt->addItem("DAC",DACIndex,DAC);
159  if (sc!=StatusCode::SUCCESS)
160  {ATH_MSG_ERROR( "addItem 'DAC' failed" );
161  return StatusCode::FAILURE;
162  }
163 
164  sc=m_nt->addItem("NTriggers",DACIndex,NTriggers);
165  if (sc!=StatusCode::SUCCESS) {
166  ATH_MSG_ERROR( "addItem 'NTriggers' failed" );
167  return StatusCode::FAILURE;
168  }
169 
170  if(m_saveAllSamples){
171  sc=m_nt->addItem("Sample0",DACIndex,Sample0);
172  if (sc!=StatusCode::SUCCESS)
173  {ATH_MSG_ERROR( "addItem 'Sample0' failed" );
174  return StatusCode::FAILURE;
175  }
176  sc=m_nt->addItem("Sample1",DACIndex,Sample1);
177  if (sc!=StatusCode::SUCCESS)
178  {ATH_MSG_ERROR( "addItem 'Sample1' failed" );
179  return StatusCode::FAILURE;
180  }
181  sc=m_nt->addItem("Sample2",DACIndex,Sample2);
182  if (sc!=StatusCode::SUCCESS)
183  {ATH_MSG_ERROR( "addItem 'Sample2' failed" );
184  return StatusCode::FAILURE;
185  }
186  sc=m_nt->addItem("Sample3",DACIndex,Sample3);
187  if (sc!=StatusCode::SUCCESS)
188  {ATH_MSG_ERROR( "addItem 'Sample3' failed" );
189  return StatusCode::FAILURE;
190  }
191  sc=m_nt->addItem("Sample4",DACIndex,Sample4);
192  if (sc!=StatusCode::SUCCESS)
193  {ATH_MSG_ERROR( "addItem 'Sample4' failed" );
194  return StatusCode::FAILURE;
195  }
196  sc=m_nt->addItem("Sample5",DACIndex,Sample5);
197  if (sc!=StatusCode::SUCCESS)
198  {ATH_MSG_ERROR( "addItem 'Sample5' failed" );
199  return StatusCode::FAILURE;
200  }
201  sc=m_nt->addItem("Sample6",DACIndex,Sample6);
202  if (sc!=StatusCode::SUCCESS)
203  {ATH_MSG_ERROR( "addItem 'Sample6' failed" );
204  return StatusCode::FAILURE;
205  }
206 
207  sc=m_nt->addItem("RMS0",DACIndex,RMS0);
208  if (sc!=StatusCode::SUCCESS)
209  {ATH_MSG_ERROR( "addItem 'RMS0' failed" );
210  return StatusCode::FAILURE;
211  }
212  sc=m_nt->addItem("RMS1",DACIndex,RMS1);
213  if (sc!=StatusCode::SUCCESS)
214  {ATH_MSG_ERROR( "addItem 'RMS1' failed" );
215  return StatusCode::FAILURE;
216  }
217  sc=m_nt->addItem("RMS2",DACIndex,RMS2);
218  if (sc!=StatusCode::SUCCESS)
219  {ATH_MSG_ERROR( "addItem 'RMS2' failed" );
220  return StatusCode::FAILURE;
221  }
222  sc=m_nt->addItem("RMS3",DACIndex,RMS3);
223  if (sc!=StatusCode::SUCCESS)
224  {ATH_MSG_ERROR( "addItem 'RMS3' failed" );
225  return StatusCode::FAILURE;
226  }
227  sc=m_nt->addItem("RMS4",DACIndex,RMS4);
228  if (sc!=StatusCode::SUCCESS)
229  {ATH_MSG_ERROR( "addItem 'RMS4' failed" );
230  return StatusCode::FAILURE;
231  }
232  sc=m_nt->addItem("RMS5",DACIndex,RMS5);
233  if (sc!=StatusCode::SUCCESS)
234  {ATH_MSG_ERROR( "addItem 'RMS5' failed" );
235  return StatusCode::FAILURE;
236  }
237  sc=m_nt->addItem("RMS6",DACIndex,RMS6);
238  if (sc!=StatusCode::SUCCESS)
239  {ATH_MSG_ERROR( "addItem 'RMS6' failed" );
240  return StatusCode::FAILURE;
241  }
242  }// end-if Save all samples
243  }//end if rawRampContainer
244 
245  if (ramp) {
246  sc=m_nt->addItem("Xi",coeffIndex,0,7);
247  if (sc!=StatusCode::SUCCESS)
248  {ATH_MSG_ERROR( "addItem 'coeffIndex' failed" );
249  return StatusCode::FAILURE;
250  }
251 
252  sc=m_nt->addItem("X",coeffIndex,coeffs);
253  if (sc!=StatusCode::SUCCESS)
254  {ATH_MSG_ERROR( "addItem 'coeff' failed" );
255  return StatusCode::FAILURE;
256  }
257 
258  if (hasRawRampContainer) { //== RampComplete && RawRamp
259  sc=m_nt->addItem("RampRMS",RampRMS,-1000,1000);
260  if (sc!=StatusCode::SUCCESS)
261  {ATH_MSG_ERROR( "addItem 'RampRMS' failed" );
262  return StatusCode::FAILURE;
263  }
264  }
265 
266  if (m_applyCorr) {
267  const LArRampComplete* rampComplete=dynamic_cast<const LArRampComplete*>(ramp);
268  if (!rampComplete) {
269  ATH_MSG_WARNING("Failed to dyn-cast to ILArRamp to LArRampComplete. Cannot apply corrections");
270  m_applyCorr=false;
271  }
272  if (rampComplete and !rampComplete->correctionsApplied()) {
273  rampComplete_nc=const_cast<LArRampComplete*>(rampComplete);
274  sc=rampComplete_nc->applyCorrections();
275  if (sc.isFailure()) {
276  ATH_MSG_ERROR( "Failed to apply corrections to LArRampComplete!" );
277  }
278  else
279  ATH_MSG_INFO( "Applied corrections to LArRampComplete" );
280  }
281  else {
282  ATH_MSG_WARNING( "Corrections already applied. Can't apply twice!" );
283  }
284  }// end if applyCorr
285  }//end-if ramp
286 
287  const LArOnOffIdMapping *cabling=nullptr;
288  if(m_isSC) {
289  ATH_MSG_DEBUG( "LArRamps2Ntuple: using SC cabling" );
291  cabling=*cablingHdl;
292  }else{
294  cabling=*cablingHdl;
295  }
296 
297 
298  if(!cabling) {
299  ATH_MSG_WARNING( "Do not have cabling object LArOnOffIdMapping" );
300  return StatusCode::FAILURE;
301  }
302 
303  unsigned cellCounter=0;
304  std::set<std::pair<HWIdentifier,unsigned> > cellDone;
305  if (hasRawRampContainer) { //Loop over raw ramp container and fill ntuple
306 
307  //Retrieve Raw Ramp Container
308  for (const std::string& key : m_contKey) {
309  LArRawRampContainer* rawRampContainer=nullptr;
310  sc=m_detStore->retrieve(rawRampContainer,key);
311  if (sc!=StatusCode::SUCCESS || !rawRampContainer) {
312  ATH_MSG_WARNING( "Unable to retrieve LArRawRampContainer with key " << key );
313  continue;
314  }
315  for (const LArRawRamp* rawramp : *rawRampContainer) {
316  const std::vector<LArRawRamp::RAMPPOINT_t>& singleRamp=rawramp->theRamp();
317 
318  for (DACIndex=0;DACIndex<singleRamp.size();DACIndex++) {
319  SampleMax[DACIndex] = singleRamp[DACIndex].iMaxSample;
320  TimeMax[DACIndex] = singleRamp[DACIndex].TimeMax;
321  ADC[DACIndex] = singleRamp[DACIndex].ADC;
322  NTriggers[DACIndex] = singleRamp[DACIndex].NTriggers;
323  DAC[DACIndex] = singleRamp[DACIndex].DAC;
324 
325  if(m_saveAllSamples){
326 
327  if ( singleRamp[DACIndex].Samples.empty() || singleRamp[DACIndex].RMS.empty() ) {
328  ATH_MSG_WARNING( "Cannot save all samples, vector empty" );
329  } else {
330 
331  Sample0[DACIndex]=singleRamp[DACIndex].Samples[0];
332  Sample1[DACIndex]=singleRamp[DACIndex].Samples[1];
333  Sample2[DACIndex]=singleRamp[DACIndex].Samples[2];
334  Sample3[DACIndex]=singleRamp[DACIndex].Samples[3];
335  Sample4[DACIndex]=singleRamp[DACIndex].Samples[4];
336  if(singleRamp[DACIndex].Samples.size()>5) Sample5[DACIndex]=singleRamp[DACIndex].Samples[5];
337  if(singleRamp[DACIndex].Samples.size()>6) Sample6[DACIndex]=singleRamp[DACIndex].Samples[6];
338 
339  RMS0[DACIndex]=singleRamp[DACIndex].RMS[0];
340  RMS1[DACIndex]=singleRamp[DACIndex].RMS[1];
341  RMS2[DACIndex]=singleRamp[DACIndex].RMS[2];
342  RMS3[DACIndex]=singleRamp[DACIndex].RMS[3];
343  RMS4[DACIndex]=singleRamp[DACIndex].RMS[4];
344  if(singleRamp[DACIndex].RMS.size()>5) RMS5[DACIndex]=singleRamp[DACIndex].RMS[5];
345  if(singleRamp[DACIndex].RMS.size()>6) RMS6[DACIndex]=singleRamp[DACIndex].RMS[6];
346  }
347  }
348 
349  }
350 
351  HWIdentifier chid=rawramp->channelID();
352  unsigned igain = (unsigned)rawramp->gain();
353  gain = igain;
354  if (m_addCorrUndo) corrUndo=0;
355  if (ramp && cabling->isOnlineConnected(chid)) {
356 
357  //FT move to here
358  fillFromIdentifier(chid);
359  cellDone.insert(std::make_pair(chid, igain));
360 
361  unsigned nDAC=0;
362  unsigned nCoeff=0;
363  const ILArRamp::RampRef_t rampcoeff = ramp->ADC2DAC(chid,igain);
364  if (rampcoeff.size()==0) {
365  ATH_MSG_WARNING( "Can't get fitted Ramp slot=" << static_cast<long>(m_slot) <<
366  " channel=" << static_cast<long>(m_channel) << " gain=" << igain );
367  }
368  for (coeffIndex=0;coeffIndex<rampcoeff.size();coeffIndex++) coeffs[coeffIndex]=rampcoeff[coeffIndex];
369  nDAC = singleRamp.size();
370  nCoeff = rampcoeff.size();
371 
372  if (nDAC>1 && nCoeff>0) {
373 
374  double rampDev=0;
375  for (unsigned iDAC=1;iDAC<nDAC;iDAC++) {
376  double fittedResult=0;
377  for (unsigned icoeff=0;icoeff<nCoeff;icoeff++)
378  fittedResult+=coeffs[icoeff]*pow(ADC[iDAC],icoeff);
379  rampDev+=(fittedResult-DAC[iDAC])*(fittedResult-DAC[iDAC]);
380  }//end loop over DAC values
381  RampRMS=1./(nDAC-1)*sqrt(rampDev);
382  }//end if nDAC>0 && nCoeff>0
383  else
384  RampRMS=-999;
385 
386  sc=ntupleSvc()->writeRecord(m_nt);
387  if (sc!=StatusCode::SUCCESS) {
388  ATH_MSG_ERROR( "writeRecord failed" );
389  return StatusCode::FAILURE;
390  }
391 
392  }//end if rampComplete or rampMC
393 
394  cellCounter++;
395 
396  }//end loop over container
397  } // loop over gains
398  }
399 
400  //Iterate over gains and cells
401  // check if cell was already filled in rawRamp loop
402  unsigned nGain = m_isSC ? 1 : CaloGain::LARNGAIN;
403  for ( unsigned igain=CaloGain::LARHIGHGAIN; igain<nGain ; ++igain )
404  {
405  for (HWIdentifier chid : m_onlineId->channel_range()) {
406  if (cabling->isOnlineConnected(chid)) {
407  gain = (long)igain;
408  if ( !cellDone.empty() && cellDone.contains(std::make_pair(chid,gain)) ) continue;
409  if (m_addCorrUndo) corrUndo = 0;
410  const ILArRamp::RampRef_t rampcoeff=ramp->ADC2DAC(chid, gain);
411  if (rampcoeff.size()==0) continue; // No ramp for this cell
412  cellIndex = cellCounter;
413  fillFromIdentifier(chid);
414  for (coeffIndex=0;coeffIndex<rampcoeff.size();coeffIndex++) coeffs[coeffIndex]=rampcoeff[coeffIndex];
415 
416  sc=ntupleSvc()->writeRecord(m_nt);
417 
418  if (sc!=StatusCode::SUCCESS) {
419  ATH_MSG_ERROR( "writeRecord failed" );
420  return StatusCode::FAILURE;
421  }
422  }// end if isConnected
423  cellCounter++;
424  }//end loop over cells
425  }//end loop over gains
426 
427 
428  if (ramp && m_addCorrUndo) {
429  //Now loop over undoCorrections:
430  for ( unsigned igain=CaloGain::LARHIGHGAIN;
432  LArRampComplete::ConstCorrectionIt itUndo,itUndo_e;
433  itUndo_e = itUndo;
434  const LArRampComplete *rampComplete=dynamic_cast<const LArRampComplete *>(ramp);
435  if(rampComplete) {
436  itUndo = rampComplete->undoCorrBegin(igain);
437  itUndo_e=rampComplete->undoCorrEnd(igain);
438 
439  for(;itUndo!=itUndo_e;itUndo++) {
440  const HWIdentifier chid(itUndo->first);
441  gain = (long)igain;
442  corrUndo = 1;
443  const std::vector<float>& rampcoeff=itUndo->second.m_vRamp;
444  if (rampcoeff.empty())
445  continue; // No ramp for this cell
446 
447  cellIndex = cellCounter;
448  fillFromIdentifier(chid);
449 
450  for (coeffIndex=0;coeffIndex<rampcoeff.size();coeffIndex++) coeffs[coeffIndex]=rampcoeff[coeffIndex];
451 
452  sc=ntupleSvc()->writeRecord(m_nt);
453 
454  if (sc!=StatusCode::SUCCESS) {
455  ATH_MSG_ERROR( "writeRecord failed" );
456  return StatusCode::FAILURE;
457  }
458  }//end loop over cells
459  }
460  }//end loop over gains
461  }//end if add corrections
462 
463  if (rampComplete_nc) {
464  ATH_CHECK(rampComplete_nc->undoCorrections());
465  ATH_MSG_INFO("Reverted corrections of LArRampComplete container");
466  }
467 
468  ATH_MSG_INFO( "LArRamps2Ntuple has finished." );
469  return StatusCode::SUCCESS;
470 
471 } // end finalize-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  {
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_addCorrUndo

bool LArRamps2Ntuple::m_addCorrUndo
private

Definition at line 43 of file LArRamps2Ntuple.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_applyCorr

bool LArRamps2Ntuple::m_applyCorr
private

Definition at line 42 of file LArRamps2Ntuple.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_contKey

std::vector<std::string> LArRamps2Ntuple::m_contKey
private

Definition at line 44 of file LArRamps2Ntuple.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_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_layer

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

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_nt

NTuple::Tuple* LArCond2NtupleBase::m_nt
protectedinherited

Definition at line 68 of file LArCond2NtupleBase.h.

◆ m_ntName

std::string LArRamps2Ntuple::m_ntName
private

Definition at line 46 of file LArRamps2Ntuple.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_rampKey

SG::ReadCondHandleKey<ILArRamp> LArRamps2Ntuple::m_rampKey
private

Definition at line 45 of file LArRamps2Ntuple.h.

◆ m_rawRamp

bool LArRamps2Ntuple::m_rawRamp
private

Definition at line 40 of file LArRamps2Ntuple.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_saveAllSamples

bool LArRamps2Ntuple::m_saveAllSamples
private

Definition at line 41 of file LArRamps2Ntuple.h.

◆ m_slot

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

Definition at line 72 of file LArCond2NtupleBase.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:
LArRamps2Ntuple::m_ntName
std::string m_ntName
Definition: LArRamps2Ntuple.h:46
LArEM_Base_ID::phi
int phi(const Identifier id) const
return phi according to :
python.TileHitInfoD3PDObject.TimeMax
TimeMax
Definition: TileHitInfoD3PDObject.py:14
LArConditionsContainer::applyCorrections
StatusCode applyCorrections()
apply correction set
LArOnlineID_Base::channel_Hash
IdentifierHash channel_Hash(HWIdentifier channelId) const
Create channel_hash from channel_Id.
Definition: LArOnlineID_Base.cxx:1632
LArCond2NtupleBase::m_layer
NTuple::Item< long > m_layer
Definition: LArCond2NtupleBase.h:71
LArCond2NtupleBase::m_isConnected
NTuple::Item< long > m_isConnected
Definition: LArCond2NtupleBase.h:74
MonDataType::ADC
@ ADC
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
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
LArCond2NtupleBase::m_addFEBTemp
Gaudi::Property< bool > m_addFEBTemp
Definition: LArCond2NtupleBase.h:54
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LArRampComplete
Definition: LArRampComplete.h:50
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:839
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
LArCond2NtupleBase::m_onlChanId
NTuple::Item< long > m_onlChanId
Definition: LArCond2NtupleBase.h:71
LArConditionsContainer::undoCorrections
StatusCode undoCorrections()
undo corrections that have been already applied
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
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
LArCalibLineMapping
Definition: LArCalibLineMapping.h:17
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
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
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:1957
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]
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 :
CaloDetDescrManager_Base
Definition: CaloDetDescrManager.h:147
LArConditionsContainer::undoCorrEnd
ConstCorrectionIt undoCorrEnd(unsigned int gain) const
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
HWIdentifier
Definition: HWIdentifier.h:13
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:1938
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.
LArCond2NtupleBase::NOT_VALID
@ NOT_VALID
Definition: LArCond2NtupleBase.h:63
xAOD::unsigned
unsigned
Definition: RingSetConf_v1.cxx:662
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
CaloDetDescrElement::eta_raw
float eta_raw() const
cell eta_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:350
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
LArCond2NtupleBase::m_addHash
Gaudi::Property< bool > m_addHash
Definition: LArCond2NtupleBase.h:58
StoreGateSvc::retrieve
StatusCode retrieve(const T *&ptr) const
Retrieve the default object into a const T*.
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
LArCond2NtupleBase::m_febHash
NTuple::Item< long > m_febHash
Definition: LArCond2NtupleBase.h:75
perfmonmt-refit.coeffs
coeffs
Definition: perfmonmt-refit.py:105
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
LArConditionsContainer< LArRampP1 >::ConstCorrectionIt
Subset::ConstCorrectionVecIt ConstCorrectionIt
Definition: LArConditionsContainer.h:78
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:1963
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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:1932
LArCond2NtupleBase::m_badChanWord
NTuple::Item< long > m_badChanWord
Definition: LArCond2NtupleBase.h:73
LArCond2NtupleBase::m_phi
NTuple::Item< long > m_phi
Definition: LArCond2NtupleBase.h:71
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
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
ILArRamp
Definition: ILArRamp.h:12
LArCond2NtupleBase::m_caloSuperCellMgrKey
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSuperCellMgrKey
Definition: LArCond2NtupleBase.h:97
LArCond2NtupleBase::m_ntpath
std::string m_ntpath
Definition: LArCond2NtupleBase.h:65
LArRamps2Ntuple::m_addCorrUndo
bool m_addCorrUndo
Definition: LArRamps2Ntuple.h:43
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::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:1950
LArRamps2Ntuple::m_contKey
std::vector< std::string > m_contKey
Definition: LArRamps2Ntuple.h:44
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AtlasDetectorID::is_lar_hec
bool is_lar_hec(Identifier id) const
Definition: AtlasDetectorID.h:829
WriteCellNoiseToCool.igain
igain
Definition: WriteCellNoiseToCool.py:338
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
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:1479
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
ILArRamp::ADC2DAC
virtual RampRef_t ADC2DAC(const HWIdentifier &id, int gain) const =0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
LArCond2NtupleBase::m_eta
NTuple::Item< long > m_eta
Definition: LArCond2NtupleBase.h:71
LArCond2NtupleBase::LArCond2NtupleBase
LArCond2NtupleBase(const std::string &name, ISvcLocator *pSvcLocator)
Definition: LArCond2NtupleBase.cxx:15
DiTauMassTools::HistInfo::RMS
@ RMS
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:35
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
LArCond2NtupleBase::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: LArCond2NtupleBase.h:96
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
LArCond2NtupleBase::m_ntTitle
std::string m_ntTitle
Definition: LArCond2NtupleBase.h:65
LArRawRamp
This class stores a unfittet ramp (=a vector a ADC and DAC values)
Definition: LArRawRamp.h:25
LArEM_Base_ID::barrel_ec
int barrel_ec(const Identifier id) const
return barrel_ec according to :
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArConditionsContainer::undoCorrBegin
ConstCorrectionIt undoCorrBegin(unsigned int gain) const
get iterator over the Undo-Vector for a certain gain
LArCond2NtupleBase::m_onlineId
const LArOnlineID_Base * m_onlineId
Definition: LArCond2NtupleBase.h:85
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
LArCond2NtupleBase::m_oflChanId
NTuple::Item< long > m_oflChanId
Definition: LArCond2NtupleBase.h:71
LArRamps2Ntuple::m_rawRamp
bool m_rawRamp
Definition: LArRamps2Ntuple.h:40
LArCond2NtupleBase::m_realgeom
Gaudi::Property< bool > m_realgeom
Definition: LArCond2NtupleBase.h:60
LArCond2NtupleBase::fillFromIdentifier
bool fillFromIdentifier(const HWIdentifier &id)
Definition: LArCond2NtupleBase.cxx:288
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
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:1944
a
TList * a
Definition: liststreamerinfos.cxx:10
h
LArCond2NtupleBase::m_FEBTemp2
NTuple::Item< float > m_FEBTemp2
Definition: LArCond2NtupleBase.h:78
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LArCond2NtupleBase::m_reta
NTuple::Item< float > m_reta
Definition: LArCond2NtupleBase.h:77
LArRawRampContainer
Definition: LArRawRampContainer.h:20
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
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
LArCond2NtupleBase::m_detStore
StoreGateSvc * m_detStore
Definition: LArCond2NtupleBase.h:81
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
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
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
LArRamps2Ntuple::m_rampKey
SG::ReadCondHandleKey< ILArRamp > m_rampKey
Definition: LArRamps2Ntuple.h:45
LArHEC_Base_ID::region
int region(const Identifier id) const
return region [0,1]
AtlasDetectorID::is_lar_em
bool is_lar_em(Identifier id) const
Definition: AtlasDetectorID.h:818
LArCond2NtupleBase::m_FT
NTuple::Item< long > m_FT
Definition: LArCond2NtupleBase.h:72
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LArRamps2Ntuple::m_saveAllSamples
bool m_saveAllSamples
Definition: LArRamps2Ntuple.h:41
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:1512
LArCond2NtupleBase::m_caloId
const CaloCell_Base_ID * m_caloId
Definition: LArCond2NtupleBase.h:86
LArRamps2Ntuple::m_applyCorr
bool m_applyCorr
Definition: LArRamps2Ntuple.h:42
LArCond2NtupleBase::m_OffId
Gaudi::Property< bool > m_OffId
Definition: LArCond2NtupleBase.h:57
fitman.k
k
Definition: fitman.py:528
LArVectorProxy
Proxy for accessing a range of float values like a vector.
Definition: LArVectorProxy.h:38
CaloDetDescrElement::phi_raw
float phi_raw() const
cell phi_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:352
LArConditionsContainer::correctionsApplied
bool correctionsApplied() const
Have corrections been applied?
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
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
LArCond2NtupleBase::m_emId
const LArEM_Base_ID * m_emId
Definition: LArCond2NtupleBase.h:82
Identifier
Definition: IdentifierFieldParser.cxx:14