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

#include <LArSC2Ntuple.h>

Inheritance diagram for LArSC2Ntuple:
Collaboration diagram for LArSC2Ntuple:

Public Member Functions

 LArSC2Ntuple (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~LArSC2Ntuple ()=default
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
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

typedef std::map< HWIdentifier, const LArRawChannel * > rawChanMap_t
 
enum  { NOT_VALID = -999 }
 

Protected Member Functions

void fillRODEnergy (HWIdentifier SCId, rawChanMap_t &rawChanMap, const LArOnOffIdMapping *cabling, const LArOnOffIdMapping *cablingROD)
 
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

int m_ipass
 
long m_event
 
Gaudi::Property< unsigned int > m_Nsamples {this, "NSamples", 32, "number of samples to store"}
 
Gaudi::Property< std::vector< unsigned int > > m_FTlist {this, "FTlist", {}, "which FT to dump"}
 
Gaudi::Property< std::vector< unsigned int > > m_Slotlist {this, "Slotlist", {}, "which Slot to dump"}
 
Gaudi::Property< bool > m_fillEMB {this, "FillEMB", true, "if to fill EMB"}
 
Gaudi::Property< bool > m_fillEndcap {this, "FillEndcap", true, "if to fill Eendcap"}
 
Gaudi::Property< bool > m_fillBCID {this, "FillBCID", false, "if to fill BCID"}
 
Gaudi::Property< bool > m_fillLB {this, "FillLB", false, "if to fill LB in Evnt tree"}
 
NTuple::Item< long > m_ntNsamples
 
NTuple::Item< short > m_gain
 
NTuple::Item< short > m_bcid
 
NTuple::Item< unsigned long > m_ELVL1Id
 
NTuple::Item< unsigned long long > m_IEvent
 
NTuple::Array< short > m_samples
 
NTuple::Array< float > m_mean
 
NTuple::Array< float > m_RMS
 
NTuple::Item< unsigned int > m_dac
 
NTuple::Item< unsigned int > m_delay
 
NTuple::Item< unsigned int > m_pulsed
 
NTuple::Tuple * m_evt_nt = nullptr
 
NTuple::Item< unsigned long long > m_IEventEvt
 
NTuple::Item< short > m_LB
 
SG::ReadHandleKey< LArDigitContainer > m_contKey {this, "ContainerKey", "FREE", "key for LArDigitContainer"}
 
SG::ReadHandleKey< LArAccumulatedCalibDigitContainer > m_accCalibContKey {this, "AccCalibContainerKey", "HIGH", "key for LArAccumulatedCalibDigitDigitContainer"}
 
SG::ReadHandleKey< LArAccumulatedDigitContainer > m_accContKey {this, "AccContainerKey", "HIGH", "key for LArAccumulatedDigitDigitContainer"}
 
SG::ReadHandleKey< LArFebHeaderContainer > m_LArFebHeaderContainerKey { this, "LArFebHeaderKey", "LArFebHeader" }
 
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

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

Private Attributes

Gaudi::Property< std::vector< std::string > > m_contKeys { this, "SCContainerKeys", {},"which containers to dump"}
 
Gaudi::Property< bool > m_overwriteEventNumber {this, "OverwriteEventNumber", false, "overwrite the event number from EventInfo ?"}
 
Gaudi::Property< unsigned int > m_Net {this, "Net", 5, "number of energies to store"}
 
Gaudi::Property< bool > m_fillRawChan {this, "FillRODEnergy", false, "Trying to fill corresponding cells energies"}
 
Gaudi::Property< bool > m_fillTType {this, "FillTriggerType", false, "Trying to fill trigger type word"}
 
Gaudi::Property< std::vector< std::string > > m_trigNames { this, "TrigNames", {"L1_EM3","L1_EM7","L1_EM15"},"which triggers to dump"}
 
Gaudi::Property< bool > m_fillCaloTT {this, "FillTriggerTowers", false, "Trying to fill also TriggerTowers from ByteStream"}
 
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKeyAdditional {this,"CablingKeyAdditional","LArOnOffIdMap","SG Key of LArOnOffIdMapping object for standard cells"}
 
ToolHandle< ICaloSuperCellIDTool > m_scidtool {this, "CaloSuperCellIDTool", "CaloSuperCellIDTool", "Offline / SuperCell ID mapping tool"}
 
ToolHandle< Trig::TrigDecisionTool > m_trigDec {this, "TrigDecisionTool", "", "Handle to the TrigDecisionTool"}
 
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey {this, "LArStatusFlag", "EventInfo", "Key for EventInfo object"}
 
SG::ReadDecorHandleKey< xAOD::EventInfo > m_eventInfoDecorKey {this, "EventInfoDecorKey", "EventInfo.larFlags"}
 
SG::ReadHandleKey< LArLATOMEHeaderContainer > m_LArLatomeHeaderContainerKey { this, "LArLatomeHeaderKey", "SC_LATOME_HEADER" }
 
Gaudi::Property< std::string > m_triggerTowerKey {this, "TriggerTowerKey", "TriggerTowers", "Trigger Tower container"}
 
NTuple::Item< short > m_latomeChannel
 
NTuple::Array< float > m_ROD_energy
 
NTuple::Array< float > m_ROD_time
 
NTuple::Array< float > m_ROD_id
 
NTuple::Item< unsigned int > m_TType
 
NTuple::Item< uint16_t > m_bcidLATOMEHEAD
 
NTuple::Item< uint32_t > m_ntNet
 
NTuple::Array< unsigned short > m_bcidVec
 
NTuple::Item< uint32_t > m_latomeSourceId
 
NTuple::Array< short > m_samples_ADC_BAS
 
NTuple::Array< unsigned short > m_bcidVec_ADC_BAS
 
NTuple::Array< int > m_energyVec_ET
 
NTuple::Array< unsigned short > m_bcidVec_ET
 
NTuple::Array< bool > m_saturVec_ET
 
NTuple::Array< int > m_energyVec_ET_ID
 
NTuple::Array< unsigned short > m_bcidVec_ET_ID
 
NTuple::Array< bool > m_saturVec_ET_ID
 
std::map< std::string, NTuple::Item< unsigned int > > m_trigNameMap
 
NTuple::Item< uint32_t > m_LArEventBits
 
NTuple::Item< short > m_LArInError
 
NTuple::Item< uint32_t > m_ntNTT
 
NTuple::Array< int > m_TTEem
 
NTuple::Array< int > m_TTEhad
 
NTuple::Array< double > m_TTeta
 
NTuple::Array< double > m_TTphi
 
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

Definition at line 17 of file LArSC2Ntuple.h.

Member Typedef Documentation

◆ rawChanMap_t

typedef std::map<HWIdentifier, const LArRawChannel*> LArSC2Ntuple::rawChanMap_t
protected

Definition at line 28 of file LArSC2Ntuple.h.

◆ 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

◆ LArSC2Ntuple()

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

Definition at line 13 of file LArSC2Ntuple.cxx.

13  :
14  LArDigits2Ntuple(name, pSvcLocator) {
15  m_ntTitle = "SCDigits";
16  m_ntpath = "/NTUPLES/FILE1/SCDIGITS";
17  }

◆ ~LArSC2Ntuple()

virtual LArSC2Ntuple::~LArSC2Ntuple ( )
virtualdefault

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;
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 LArSC2Ntuple::execute ( )
overridevirtual

set it here once and no need to set at each SC/cell

set container pointers to nullptr if size is 0 (avoid checking again the size in many places)

Reimplemented from LArDigits2Ntuple.

Definition at line 197 of file LArSC2Ntuple.cxx.

198 {
199 
200  StatusCode sc;
201 
202  const EventContext& ctx = Gaudi::Hive::currentContext();
203 
204  SG::ReadHandle<xAOD::EventInfo>evt (m_eventInfoKey, ctx);
205  ATH_CHECK(evt.isValid());
206 
207  unsigned long long thisevent = evt->eventNumber();
208  unsigned short thislb = evt->lumiBlock();
209 
210  // This should be used for main readout later, once TDAQ fill event headers also in calib. runs properly
211  unsigned long thisbcid = evt->bcid();
212  unsigned long thisELVL1Id = 0;
213  unsigned long thisttype = evt->level1TriggerType();
214  //
216  bool hasDigitContainer=true;
217  const LArDigitContainer *DigitContainer = nullptr;
218  if(!m_contKey.key().empty()) {
219  SG::ReadHandle<LArDigitContainer> hdlDigit(m_contKey, ctx);
220  if(!hdlDigit.isValid()) {
221  ATH_MSG_WARNING( "Unable to retrieve LArDigitContainer with key " << m_contKey << " from DetectorStore. " );
222  hasDigitContainer=false;
223  } else {
224  ATH_MSG_DEBUG( "Got LArDigitContainer with key " << m_contKey.key() );
225  DigitContainer = hdlDigit.cptr();
226  }
227  } else hasDigitContainer=false;
228 
229  bool hasAccCalibDigitContainer=true;
230  const LArAccumulatedCalibDigitContainer *AccCalibDigitContainer = nullptr;
231  if(!m_accCalibContKey.key().empty()) {
232  SG::ReadHandle<LArAccumulatedCalibDigitContainer> hdlAccDigit(m_accCalibContKey, ctx);
233  if(!hdlAccDigit.isValid()) {
234  ATH_MSG_WARNING( "Unable to retrieve LArAccumulatedCalibDigitContainer with key " << m_accCalibContKey << " from DetectorStore. " );
235  hasAccCalibDigitContainer=false;
236  } else {
237  ATH_MSG_DEBUG( "Got LArAccumulatedCalibDigitContainer with key " << m_accCalibContKey.key() );
238  AccCalibDigitContainer = hdlAccDigit.cptr();
239  }
240  } else hasAccCalibDigitContainer=false;
241 
242  bool hasAccDigitContainer=true;
243  const LArAccumulatedDigitContainer *AccDigitContainer = nullptr;
244  if(!m_accContKey.key().empty()) {
245  SG::ReadHandle<LArAccumulatedDigitContainer> hdlAccDigit(m_accContKey, ctx);
246  if(!hdlAccDigit.isValid()) {
247  ATH_MSG_WARNING( "Unable to retrieve LArAccumulatedDigitContainer with key " << m_accContKey << " from DetectorStore. " );
248  hasAccDigitContainer=false;
249  } else {
250  ATH_MSG_DEBUG( "Got LArAccumulatedDigitContainer with key " << m_accContKey.key() );
251  AccDigitContainer = hdlAccDigit.cptr();
252  }
253  } else hasAccDigitContainer=false;
254 
255  const LArDigitContainer* DigitContainer_next = nullptr;
256  const LArRawSCContainer* etcontainer = nullptr;
257  const LArRawSCContainer* etcontainer_next = nullptr;
258  const LArRawChannelContainer* RawChannelContainer = nullptr;
259  const LArLATOMEHeaderContainer*headcontainer = nullptr;
260  std::map<unsigned int, const LArLATOMEHeader*> LATOMEHeadMap;
261  rawChanMap_t rawChannelMap;
262 
263  if ((std::find(m_contKeys.begin(), m_contKeys.end(), "LArRawChannels") != m_contKeys.end()) ){
264  sc = evtStore()->retrieve(RawChannelContainer,"LArRawChannels");
265  if (sc.isFailure()) {
266  ATH_MSG_WARNING( "Unable to retrieve LArRawChannelContainer with key LArRawChannels from DetectorStore. " );
267  }
268  else
269  ATH_MSG_DEBUG( "Got LArRawChannelContainer with key LArRawChannels" );
270  }
271 
272  if ((std::find(m_contKeys.begin(), m_contKeys.end(), "SC_ADC_BAS") != m_contKeys.end()) ){
273  sc = evtStore()->retrieve(DigitContainer_next,"SC_ADC_BAS");
274  if (sc.isFailure()) {
275  ATH_MSG_WARNING( "Unable to retrieve LArDigitContainer with key SC_ADC_BAS from DetectorStore. " );
276  }
277  else
278  ATH_MSG_DEBUG( "Got additional LArDigitContainer with key SC_ADC_BAS " );
279  }
280 
281  if ((std::find(m_contKeys.begin(), m_contKeys.end(), "SC_ET") != m_contKeys.end()) ){
282  sc = evtStore()->retrieve(etcontainer,"SC_ET");
283  if (sc.isFailure()) {
284  ATH_MSG_WARNING( "Unable to retrieve LArRawSCContainer with key SC_ET from DetectorStore. " );
285  }
286  else
287  ATH_MSG_DEBUG( "Got LArRawSCContainer with key SC_ET " );
288  }
289 
290  if ((std::find(m_contKeys.begin(), m_contKeys.end(), "SC_ET_ID") != m_contKeys.end()) ){
291  sc = evtStore()->retrieve(etcontainer_next,"SC_ET_ID");
292  if (sc.isFailure()) {
293  ATH_MSG_WARNING( "Unable to retrieve LArRawSCContainer with key SC_ET_ID from DetectorStore. " );
294  }
295  else
296  ATH_MSG_DEBUG( "Got LArRawSCContainer with key SC_ET_ID" );
297  }
298 
299  SG::ReadHandle<LArLATOMEHeaderContainer> hdrCont(m_LArLatomeHeaderContainerKey);
300  if (! hdrCont.isValid()) {
301  ATH_MSG_WARNING( "No LArLATOME container found in TDS" );
302  } else {
303  ATH_MSG_DEBUG( "LArLATOME container found");
304  headcontainer=&*hdrCont;
305  thisELVL1Id = (*hdrCont->begin())->L1Id();
306  ATH_MSG_DEBUG( " ELVL1I FROM LATOME HEADER " << thisELVL1Id );
307  }
308 
309  if (headcontainer){// loop through header container and fill map
310  for (const LArLATOMEHeader* hit : *headcontainer) {
311  LATOMEHeadMap.try_emplace ( hit->SourceId(), hit );
312  }
313  }
314  if(m_fillRawChan && RawChannelContainer){
315  for (const LArRawChannel& raw : *RawChannelContainer) {
316  rawChannelMap.try_emplace( raw.channelID(), &raw );
317  }
318  }
319  const LArOnOffIdMapping* cabling=nullptr;
320  const LArOnOffIdMapping* cablingROD=nullptr;
321  if(m_fillRawChan){
322  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{cablingKey()};
323  cabling=*cablingHdl;
324  if(!cabling) {
325  ATH_MSG_ERROR( "Do not have cabling for SC!" );
326  return StatusCode::FAILURE;
327  }
328  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdlROD{m_cablingKeyAdditional};
329  cablingROD=*cablingHdlROD;
330  if(!cablingROD) {
331  ATH_MSG_ERROR( "Do not have cabling for ROD!" );
332  return StatusCode::FAILURE;
333  }
334  }
335 
337  if( DigitContainer_next && DigitContainer_next->empty() ) DigitContainer_next = nullptr;
338 
339  if( etcontainer && etcontainer->empty() ) etcontainer = nullptr;
340 
341  if( etcontainer_next && etcontainer_next->empty() ) etcontainer_next = nullptr;
342 
343  int cellsno = 0;
344  if (hasDigitContainer) {
345  if( !DigitContainer->empty() ) cellsno = DigitContainer->size();
346  else {
347  ATH_MSG_WARNING("DigitContainer has zero size, but asked, will be not filled... ");
348  return StatusCode::SUCCESS;
349  }
350  }
351  ATH_MSG_DEBUG("DigitContainer has size: "<<cellsno<<" hasDigitContainer: "<<hasDigitContainer);
352 
353  if (hasAccCalibDigitContainer) {
354  if( !AccCalibDigitContainer->empty() ) {
355  cellsno = AccCalibDigitContainer->size();
356  ATH_MSG_DEBUG("AccCalibDigitContainer has size: "<<cellsno<<" hasAccCalibDigitContainer: "<<hasAccCalibDigitContainer);
357  } else {
358  ATH_MSG_WARNING("AccCalibDigitContainer has zero size, but asked, will be not filled... ");
359  return StatusCode::SUCCESS;
360  }
361  }
362  if (hasAccDigitContainer) {
363  if( !AccDigitContainer->empty() ) {
364  cellsno = AccDigitContainer->size();
365  ATH_MSG_DEBUG("AccDigitContainer has size: "<<cellsno<<" hasAccDigitContainer: "<<hasAccDigitContainer);
366  } else {
367  ATH_MSG_WARNING("AccDigitContainer has zero size, but asked, will be not filled... ");
368  return StatusCode::SUCCESS;
369  }
370  }
371 
372  if (DigitContainer_next){
373  if ( cellsno == 0 ){
374  cellsno = DigitContainer_next->size();
375  }else if(DigitContainer_next->size() != (unsigned)cellsno ){ ATH_MSG_ERROR(" NOOOOOOO! Different number of entries in DigitContainer_next"<< cellsno << " " << DigitContainer_next->size() );
376  }
377  }
378  if (etcontainer){
379  if ( cellsno == 0 ){
380  cellsno = etcontainer->size();
381  }else if(etcontainer->size() != (unsigned)cellsno ){ ATH_MSG_ERROR(" NOOOOOOO! Different number of entries in etcontainer"<< cellsno << " " << etcontainer->size() );
382  }
383  }
384  if (etcontainer_next){
385  if ( cellsno == 0 ){
386  cellsno = etcontainer_next->size();
387  }else if(etcontainer_next->size() != (unsigned)cellsno ){ ATH_MSG_ERROR(" NOOOOOOO! Different number of entries in etcontainer_next"<< cellsno << " " << etcontainer_next->size() );
388  }
389  }
390  unsigned cellCounter = 0;
391  ATH_MSG_DEBUG("cellsno size: "<<cellsno);
392 
393  for( int c = 0;c<cellsno;++c ){
394  if(m_fillBCID) m_bcid = thisbcid;
395 
396  m_ELVL1Id = thisELVL1Id;
397  m_IEvent = thisevent;
398  if(m_overwriteEventNumber) m_IEvent = ctx.evt();
399 
400  if( hasAccDigitContainer ){
401 
402  const LArAccumulatedDigit* digi = AccDigitContainer->at(c);
403  // ======================
404 
405 
406  unsigned int trueMaxSample = digi->nsample();
407 
408  if(trueMaxSample>m_Nsamples){
409  if(!m_ipass){
410  ATH_MSG_DEBUG( "The number of samples in data is larger than the one specified by JO: " << trueMaxSample << " > " << m_Nsamples << " --> only " << m_Nsamples << " will be available in the ntuple " );
411  m_ipass = 1;
412  }
413  trueMaxSample = m_Nsamples;
414  }
415  m_ntNsamples = trueMaxSample;
416 
417  fillFromIdentifier(digi->hardwareID());
418 
419  for(unsigned i = 0; i<trueMaxSample;++i) {
420  m_mean[i] = digi->mean(i);
421  m_RMS[i] = digi->RMS(i);
422  }
423 
424  }//hasAccDigitContainer
425 
426  if( hasAccCalibDigitContainer ){
427 
428  const LArAccumulatedCalibDigit* digi = AccCalibDigitContainer->at(c);
429  // ======================
430 
431 
432  unsigned int trueMaxSample = digi->nsamples();
433 
434  if(trueMaxSample>m_Nsamples){
435  if(!m_ipass){
436  ATH_MSG_DEBUG( "The number of samples in data is larger than the one specified by JO: " << trueMaxSample << " > " << m_Nsamples << " --> only " << m_Nsamples << " will be available in the ntuple " );
437  m_ipass = 1;
438  }
439  trueMaxSample = m_Nsamples;
440  }
441  m_ntNsamples = trueMaxSample;
442 
443  fillFromIdentifier(digi->hardwareID());
444 
445  for(unsigned i = 0; i<trueMaxSample;++i) {
446  m_mean[i] = digi->mean(i);
447  m_RMS[i] = digi->RMS(i);
448  }
449  m_dac = digi->DAC();
450  m_delay = digi->delay();
451  m_pulsed = digi->getIsPulsedInt();
452 
453  }//hasAccCalibDigitContainer
454 
455  if( hasDigitContainer ){
456 
457  const LArDigit* digi = DigitContainer->at(c);
458  // ======================
459 
460  unsigned int trueMaxSample = digi->nsamples();
461 
462  if(trueMaxSample>m_Nsamples){
463  if(!m_ipass){
464  ATH_MSG_DEBUG( "The number of samples in data is larger than the one specified by JO: " << trueMaxSample << " > " << m_Nsamples << " --> only " << m_Nsamples << " will be available in the ntuple " );
465  m_ipass = 1;
466  }
467  trueMaxSample = m_Nsamples;
468  }
469  m_ntNsamples = trueMaxSample;
470 
471  fillFromIdentifier(digi->hardwareID());
472 
473  if(m_FTlist.size() > 0) { // should do a selection
474  if(std::find(std::begin(m_FTlist), std::end(m_FTlist), m_FT) == std::end(m_FTlist)) { // is our FT in list ?
475  continue;
476  }
477  }
478 
479 
480  for(unsigned i = 0; i<trueMaxSample;++i) m_samples[i] = digi->samples().at(i);
481 
482  const LArSCDigit* scdigi = dynamic_cast<const LArSCDigit*>(digi);
483  if(!scdigi){
484  ATH_MSG_DEBUG(" Can't cast digi to LArSCDigit*");
485  }else{
486  if (headcontainer){
487  ATH_MSG_DEBUG(" Accessing LATOME header ");
488  const LArLATOMEHeader*headmap = LATOMEHeadMap[scdigi->SourceId()];
489  if(headmap){
490  m_bcidLATOMEHEAD = headmap->BCId();
491  m_ELVL1Id = headmap->L1Id();
492  }
493  }
494  m_latomeChannel = scdigi->Channel();
495  unsigned int trueMaxBcid = trueMaxSample;
496  if(trueMaxBcid > scdigi->BCId().size()) trueMaxBcid=scdigi->BCId().size();
497  for( unsigned i = 0; i<trueMaxBcid; ++i){
498  m_bcidVec[i] = scdigi->BCId().at(i);
499  }
500  m_latomeSourceId = scdigi->SourceId();
501  }
502 
503 
504  if( m_fillRawChan && RawChannelContainer ){
505  fillRODEnergy(digi->hardwareID(), rawChannelMap, cabling, cablingROD);
506  }
507  }//hasDigitContainer
508  ATH_MSG_DEBUG("After hasDigitContainer ");
509 
510 
511  // DigitContainer 1 -> SC_ADC_BAS
512  if( DigitContainer_next ){
513 
514  const LArDigit* digi = DigitContainer_next->at(c);
515 
516  unsigned int trueMaxSample = digi->nsamples();
517 
518  if(trueMaxSample>m_Nsamples){
519  if(!m_ipass){
520  ATH_MSG_DEBUG( "The number of samples in data is larger than the one specified by JO: " << trueMaxSample << " > " << m_Nsamples << " --> only " << m_Nsamples << " will be available in the ntuple " );
521  m_ipass=1;
522  }
523  trueMaxSample = m_Nsamples;
524  }
525  m_ntNsamples = trueMaxSample;
526 
527  if( !hasDigitContainer){
528  fillFromIdentifier(digi->hardwareID());
529  if( m_fillRawChan && RawChannelContainer ){
530  fillRODEnergy(digi->hardwareID(), rawChannelMap, cabling, cablingROD);
531  }
532  }
533 
534  for(unsigned i = 0; i<trueMaxSample;++i) m_samples_ADC_BAS[i] = digi->samples().at(i);
535 
536  const LArSCDigit* scdigi = dynamic_cast<const LArSCDigit*>(digi);
537  if(!scdigi){ ATH_MSG_DEBUG(" Can't cast digi to LArSCDigit*");
538  }else{
539  if (headcontainer){
540  const LArLATOMEHeader*headmap = LATOMEHeadMap[scdigi->SourceId()];
541  if(headmap){
542  m_bcidLATOMEHEAD = headmap->BCId();
543  m_ELVL1Id = headmap->L1Id();
544  }
545  }
546  m_latomeChannel = scdigi->Channel();
547  for( unsigned i = 0; i<trueMaxSample;++i){
548  m_bcidVec[i] = scdigi->BCId().at(i);
549  }
550  m_latomeSourceId = scdigi->SourceId();
551  }
552 
553  if( !hasDigitContainer && m_fillRawChan && RawChannelContainer ){
554  fillRODEnergy(digi->hardwareID(), rawChannelMap, cabling, cablingROD);
555  }
556  }
557  ATH_MSG_DEBUG("After DigitContainer_next ");
558 
559 
560 
561  // etcontainer -> SC_ET
562  if( etcontainer ){
563  const LArRawSC*rawSC = etcontainer->at(c);
564 
565  if ( !hasDigitContainer && !DigitContainer_next ){
566  fillFromIdentifier(rawSC->hardwareID());
567  m_latomeChannel = rawSC->chan();
568  if (headcontainer){
569  const LArLATOMEHeader*headmap = LATOMEHeadMap[rawSC->SourceId()];
570  if(headmap){
571  m_bcidLATOMEHEAD = headmap->BCId();
572  m_ELVL1Id = headmap->L1Id();
573  }
574  }
575  if( m_fillRawChan && RawChannelContainer ){
576  fillRODEnergy(rawSC->hardwareID(), rawChannelMap, cabling, cablingROD);
577  }
578  }
579  unsigned int truenet = m_Net;
580  if(truenet > rawSC->bcids().size()) truenet=rawSC->bcids().size();
581  for( unsigned i=0; i<truenet;++i){ // just use the vector directly?
582  m_bcidVec_ET[i] = rawSC->bcids().at(i);
583  }
584  if(truenet > rawSC->energies().size()) truenet=rawSC->energies().size();
585  for( unsigned i=0; i<truenet;++i){ // just use the vector directly?
586  m_energyVec_ET[i] = rawSC->energies().at(i);
587  }
588  if(truenet > rawSC->satur().size()) truenet=rawSC->satur().size();
589  for( unsigned i = 0; i<truenet;++i){ // just use the vector directly?
590  m_saturVec_ET[i] = rawSC->satur().at(i);
591  }
592  m_Net=truenet;
593  m_ntNet=truenet;
594 
595  }
596  // etcontainer_next -> SC_ET_ID
597  if( etcontainer_next ){
598  const LArRawSC*rawSC = etcontainer_next->at(c);
599 
600  if ( !hasDigitContainer && !DigitContainer_next && !etcontainer ){
601  fillFromIdentifier(rawSC->hardwareID());
602  m_latomeChannel = rawSC->chan();
603  if (headcontainer){
604  const LArLATOMEHeader*headmap = LATOMEHeadMap[rawSC->SourceId()];
605  if(headmap){
606  m_bcidLATOMEHEAD = headmap->BCId();
607  m_ELVL1Id = headmap->L1Id();
608  }
609  }
610  if( m_fillRawChan && RawChannelContainer ){
611  fillRODEnergy(rawSC->hardwareID(), rawChannelMap, cabling, cablingROD);
612  }
613  }
614  for( unsigned i=0; i<rawSC->bcids().size();++i){ // just use the vector directly?
615  m_bcidVec_ET_ID[i] = rawSC->bcids()[i];
616  }
617  for( unsigned i=0; i<rawSC->energies().size();++i){ // just use the vector directly?
618  m_energyVec_ET_ID[i] = rawSC->energies()[i];
619  }
620  for( unsigned i = 0; i<rawSC->satur().size();++i){ // just use the vector directly?
621  m_saturVec_ET_ID[i] = rawSC->satur()[i];
622  }
623  }
624 
625  sc = ntupleSvc()->writeRecord(m_nt);
626  if (sc != StatusCode::SUCCESS) {
627  ATH_MSG_ERROR( "writeRecord failed" );
628  return sc;
629  }
630  cellCounter++;
631  }// over cells
632  if(m_fillTType) {
633  m_TType = thisttype;
634  m_IEventEvt = thisevent;
635  if(m_overwriteEventNumber) m_IEventEvt = m_event;
636  m_LB = thislb;
637 
638  for (auto const & x : m_trigNames) {
639  if( ! m_trigDec->getListOfTriggers(x).empty() ){
640  m_trigNameMap[x] = m_trigDec->isPassedBits( x );
641  }
642  }
643  m_LArEventBits = evt->eventFlags(xAOD::EventInfo::LAr);
644  m_LArInError = 0;
645  if(evt->errorState(xAOD::EventInfo::LAr)==xAOD::EventInfo::Error) m_LArInError = m_LArInError | 0x1;
646  if(evt->errorState(xAOD::EventInfo::LAr)==xAOD::EventInfo::Warning) m_LArInError = m_LArInError | 0x2;
647 
648  }
649  if(m_fillCaloTT){
650  const DataVector<LVL1::TriggerTower>* TTVector = nullptr;
651  if ( evtStore()->retrieve(TTVector,m_triggerTowerKey).isFailure() ) {
652  ATH_MSG_WARNING("Could not get the Calo TTs, will not fill...");
653  } else {
654  unsigned count=0;
655  ATH_MSG_INFO("Got TT vector of the sixe " << TTVector->size());
656  DataVector<LVL1::TriggerTower>::const_iterator x;
657  for ( x = TTVector->begin(); x < TTVector->end(); ++x ){
658  m_TTeta[count]=(*x)->eta();
659  m_TTphi[count]=(*x)->phi();
660  m_TTEem[count]=(*x)->emEnergy();
661  m_TTEhad[count]=(*x)->hadEnergy();
662  ++count;
663  if(count==20000) break;
664  }
665  m_ntNTT=count;
666  }
667  }
668 
669  if(m_fillTType || m_fillCaloTT){
670  sc = ntupleSvc()->writeRecord(m_evt_nt);
671  if (sc != StatusCode::SUCCESS) {
672  ATH_MSG_ERROR( "writeRecord failed" );
673  return sc;
674  }
675  }
676 
677  ATH_MSG_DEBUG( "LArSC2Ntuple has finished, filled " << cellCounter << " cells");
678  return StatusCode::SUCCESS;
679 }// end finalize-method.

◆ 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()) m_calibLine = m_onlineId->channel(calibLineV[0]);
351  }
352 
353 
354  if ( m_OffId ) {
355  m_detector=NOT_VALID;
356  m_region=NOT_VALID;
357  m_eta=NOT_VALID;
358  m_phi=NOT_VALID;
359 
360  if(m_realgeom){
361  m_reta=NOT_VALID;
362  m_rphi=NOT_VALID;
363  }
364  m_layer=NOT_VALID;
365  m_oflChanId=NOT_VALID;
366  if (m_addHash) m_oflHash=NOT_VALID;
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) {
375  SG::ReadCondHandle<CaloSuperCellDetDescrManager> caloSuperCellMgrHandle{m_caloSuperCellMgrKey};
376  dd_man = *caloSuperCellMgrHandle;
377  }
378  else {
379  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
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();
389  if (m_addHash) m_oflHash=m_caloId->calo_cell_hash(id);
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 }

◆ fillRODEnergy()

void LArSC2Ntuple::fillRODEnergy ( HWIdentifier  SCId,
rawChanMap_t &  rawChanMap,
const LArOnOffIdMapping *  cabling,
const LArOnOffIdMapping *  cablingROD 
)
protected

Definition at line 681 of file LArSC2Ntuple.cxx.

682 {
683  const Identifier offId = cabling->cnvToIdentifier(SCId);
684  const std::vector<Identifier> cellIds = m_scidtool->superCellToOfflineID(offId);
685  std::fill(m_ROD_energy.begin(), m_ROD_energy.end(), 0.);
686  std::fill(m_ROD_time.begin(), m_ROD_time.end(), 0.);
687  std::fill(m_ROD_id.begin(), m_ROD_id.end(), 0.);
688  for(unsigned i=0; i<cellIds.size(); ++i ) {
689  const HWIdentifier hwcell=cablingROD->createSignalChannelID(cellIds[i]);
690  if (hwcell.is_valid() && (rawChanMap.count(hwcell) != 0) ) {
691  m_ROD_energy[i] = rawChanMap[hwcell]->energy();
692  m_ROD_time[i] = rawChanMap[hwcell]->time();
693  m_ROD_id[i] = rawChanMap[hwcell]->hardwareID().get_identifier32().get_compact();
694  } else {
695  ATH_MSG_DEBUG(i<<"-th cell invalid Id");
696  }
697  }
698 
699 }

◆ initialize()

StatusCode LArSC2Ntuple::initialize ( )
overridevirtual

Reimplemented from LArDigits2Ntuple.

Definition at line 19 of file LArSC2Ntuple.cxx.

19  {
20 
21  ATH_MSG_DEBUG( "LArSC2Ntuple in initialize" );
22 
23  m_isSC = true;
24  if(m_fillTType && (! m_fillLB)) m_fillLB = true;
25  if(m_fillCaloTT && (! m_fillLB)) m_fillLB = true;
26 
27  ATH_CHECK( LArDigits2Ntuple::initialize() );
28  ATH_CHECK( m_scidtool.retrieve() );
29 
30  ATH_CHECK( m_cablingKeyAdditional.initialize(m_fillRawChan));
31  ATH_CHECK( m_eventInfoKey.initialize() );
32  ATH_CHECK( m_eventInfoDecorKey.initialize() );
33 
34  ATH_CHECK(m_LArLatomeHeaderContainerKey.initialize() );
35 
36  StatusCode sc=m_nt->addItem("latomeChannel",m_latomeChannel);
37  if (sc.isFailure()) {
38  ATH_MSG_ERROR( "addItem 'latomeChannel' failed" );
39  return sc;
40  }
41 
42  sc = m_nt->addItem("bcidVec",m_Nsamples, m_bcidVec);//here - > define length?
43  if (sc.isFailure()) {
44  ATH_MSG_ERROR( "addItem 'bcidVec' failed" );
45  return sc;
46  }
47  sc = m_nt->addItem("latomeSourceId",m_latomeSourceId);
48  if (sc.isFailure()) {
49  ATH_MSG_ERROR( "addItem 'latomeSourceId' failed" );
50  return sc;
51  }
52  sc = m_nt->addItem("Net",m_ntNet);
53  if (sc.isFailure()) {
54  ATH_MSG_ERROR( "addItem 'Net' failed" );
55  return sc;
56  }
57 
58  // Loop over container keys
59  for ( const std::string &ck : m_contKeys ){
60  if ( ck.find("SC") == std::string::npos){ // main readout only
61  if ( m_fillRawChan && ck == "LArRawChannels" ){
62  sc = m_nt->addItem("ROD_energy", 16, m_ROD_energy);
63  if (sc.isFailure()) {
64  ATH_MSG_ERROR( "addItem 'ROD_energy' failed" );
65  return sc;
66  }
67  sc = m_nt->addItem("ROD_time", 16, m_ROD_time);
68  if (sc.isFailure()) {
69  ATH_MSG_ERROR( "addItem 'ROD_time' failed" );
70  return sc;
71  }
72  sc = m_nt->addItem("ROD_id", 16, m_ROD_id);
73  if (sc.isFailure()) {
74  ATH_MSG_ERROR( "addItem 'ROD_id' failed" );
75  return sc;
76  }
77  }
78 
79  }else if ( ck == "SC_ADC_BAS" ){ // SC_ADC_BAS DigitContainer
80  sc = m_nt->addItem("samples_ADC_BAS",m_Nsamples,m_samples_ADC_BAS);
81  if (sc.isFailure()) {
82  ATH_MSG_ERROR( "addItem 'samples_ADC_BAS' failed" );
83  return sc;
84  }
85 
86  sc = m_nt->addItem("bcidVec_ADC_BAS",m_Nsamples, m_bcidVec_ADC_BAS);//here - > define length?
87  if (sc.isFailure()) {
88  ATH_MSG_ERROR( "addItem 'bcidVec_ADC_BAS' failed" );
89  return sc;
90  }
91 
92  }else if ( ck == "SC_ET" ){ // SC_ET RawSCContainer
93  sc = m_nt->addItem("energyVec_ET", m_Net, m_energyVec_ET);
94  if (sc.isFailure()) {
95  ATH_MSG_ERROR( "addItem 'energyVec_ET' failed" );
96  return sc;
97  }
98  sc = m_nt->addItem("bcidVec_ET", m_Net, m_bcidVec_ET);
99  if (sc.isFailure()) {
100  ATH_MSG_ERROR( "addItem 'bcidVec_ET' failed" );
101  return sc;
102  }
103  sc = m_nt->addItem("saturVec_ET", m_Net, m_saturVec_ET);
104  if (sc.isFailure()) {
105  ATH_MSG_ERROR( "addItem 'saturVec_ET' failed" );
106  return sc;
107  }
108 
109  }else if ( ck == "SC_ET_ID" ){ // SC_ET_ID RawSCContainer
110 
111  sc = m_nt->addItem("energyVec_ET_ID", m_Net, m_energyVec_ET_ID);
112  if (sc.isFailure()) {
113  ATH_MSG_ERROR( "addItem 'energyVec_ET_ID' failed" );
114  return sc;
115  }
116  sc = m_nt->addItem("bcidVec_ET_ID", m_Net, m_bcidVec_ET_ID);
117  if (sc.isFailure()) {
118  ATH_MSG_ERROR( "addItem 'bcidVec_ET_ID' failed" );
119  return sc;
120  }
121  sc = m_nt->addItem("saturVec_ET_ID", m_Net, m_saturVec_ET_ID);
122  if (sc.isFailure()) {
123  ATH_MSG_ERROR( "addItem 'saturVec_ET_ID' failed" );
124  return sc;
125  }
126  }
127 
128  }// end container key loop
129 
130  sc = m_nt->addItem("bcidLATOMEHEAD",m_bcidLATOMEHEAD);
131  if (sc.isFailure()) {
132  ATH_MSG_ERROR( "addItem 'bcidLATOMEHEAD' failed" );
133  return sc;
134  }
135 
136  if(m_fillTType) {
137  sc = m_evt_nt->addItem("TType", m_TType);
138  if (sc.isFailure()) {
139  ATH_MSG_ERROR( "addItem 'TType' failed" );
140  return sc;
141  }
142 
143  sc = m_evt_nt->addItem("LArEventBits", m_LArEventBits);
144  if (sc.isFailure()) {
145  ATH_MSG_ERROR( "addItem 'LArEventBits' failed" );
146  return sc;
147  }
148  sc = m_evt_nt->addItem("LArError", m_LArInError);
149  if (sc.isFailure()) {
150  ATH_MSG_ERROR( "addItem 'LArError' failed" );
151  return sc;
152  }
153  //Adding trigger decision bit branches
154  CHECK( m_trigDec.retrieve() );
155  for ( const std::string &tn : m_trigNames ){
156  sc = m_evt_nt->addItem(tn,m_trigNameMap[tn]);
157  if (sc.isFailure()) {
158  ATH_MSG_ERROR( "addItem '"+tn+"' failed" );
159  return sc;
160  }
161  }
162 
163  }//m_fillTType
164 
165  if(m_fillCaloTT) {
166  sc = m_evt_nt->addItem("NTT",m_ntNTT,0,20000);
167  if (sc.isFailure()) {
168  ATH_MSG_ERROR( "addItem 'Net' failed" );
169  return sc;
170  }
171  sc = m_evt_nt->addItem("TTeta", m_ntNTT, m_TTeta);
172  if (sc.isFailure()) {
173  ATH_MSG_ERROR( "addItem 'TTeta' failed" );
174  return sc;
175  }
176  sc = m_evt_nt->addItem("TTphi", m_ntNTT, m_TTphi);
177  if (sc.isFailure()) {
178  ATH_MSG_ERROR( "addItem 'TTphi' failed" );
179  return sc;
180  }
181  sc = m_evt_nt->addItem("TTEem", m_ntNTT, m_TTEem);
182  if (sc.isFailure()) {
183  ATH_MSG_ERROR( "addItem 'TTEem' failed" );
184  return sc;
185  }
186  sc = m_evt_nt->addItem("TTEhad", m_ntNTT, m_TTEhad);
187  if (sc.isFailure()) {
188  ATH_MSG_ERROR( "addItem 'TTEhad' failed" );
189  return sc;
190  }
191  } // end m_fillCaloTT
192 
193  return StatusCode::SUCCESS;
194 
195 }

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

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

SG::ReadHandleKey<LArAccumulatedCalibDigitContainer> LArDigits2Ntuple::m_accCalibContKey {this, "AccCalibContainerKey", "HIGH", "key for LArAccumulatedCalibDigitDigitContainer"}
protectedinherited

Definition at line 60 of file LArDigits2Ntuple.h.

◆ m_accContKey

SG::ReadHandleKey<LArAccumulatedDigitContainer> LArDigits2Ntuple::m_accContKey {this, "AccContainerKey", "HIGH", "key for LArAccumulatedDigitDigitContainer"}
protectedinherited

Definition at line 61 of file LArDigits2Ntuple.h.

◆ 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_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_bcid

NTuple::Item<short> LArDigits2Ntuple::m_bcid
protectedinherited

Definition at line 41 of file LArDigits2Ntuple.h.

◆ m_bcidLATOMEHEAD

NTuple::Item<uint16_t> LArSC2Ntuple::m_bcidLATOMEHEAD
private

Definition at line 62 of file LArSC2Ntuple.h.

◆ m_bcidVec

NTuple::Array<unsigned short> LArSC2Ntuple::m_bcidVec
private

Definition at line 67 of file LArSC2Ntuple.h.

◆ m_bcidVec_ADC_BAS

NTuple::Array<unsigned short> LArSC2Ntuple::m_bcidVec_ADC_BAS
private

Definition at line 70 of file LArSC2Ntuple.h.

◆ m_bcidVec_ET

NTuple::Array<unsigned short> LArSC2Ntuple::m_bcidVec_ET
private

Definition at line 73 of file LArSC2Ntuple.h.

◆ m_bcidVec_ET_ID

NTuple::Array<unsigned short> LArSC2Ntuple::m_bcidVec_ET_ID
private

Definition at line 77 of file LArSC2Ntuple.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_cablingKeyAdditional

SG::ReadCondHandleKey<LArOnOffIdMapping> LArSC2Ntuple::m_cablingKeyAdditional {this,"CablingKeyAdditional","LArOnOffIdMap","SG Key of LArOnOffIdMapping object for standard cells"}
private

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

SG::ReadHandleKey<LArDigitContainer> LArDigits2Ntuple::m_contKey {this, "ContainerKey", "FREE", "key for LArDigitContainer"}
protectedinherited

Definition at line 59 of file LArDigits2Ntuple.h.

◆ m_contKeys

Gaudi::Property< std::vector<std::string> > LArSC2Ntuple::m_contKeys { this, "SCContainerKeys", {},"which containers to dump"}
private

Definition at line 34 of file LArSC2Ntuple.h.

◆ m_dac

NTuple::Item<unsigned int> LArDigits2Ntuple::m_dac
protectedinherited

Definition at line 48 of file LArDigits2Ntuple.h.

◆ m_delay

NTuple::Item<unsigned int> LArDigits2Ntuple::m_delay
protectedinherited

Definition at line 49 of file LArDigits2Ntuple.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_ELVL1Id

NTuple::Item<unsigned long> LArDigits2Ntuple::m_ELVL1Id
protectedinherited

Definition at line 42 of file LArDigits2Ntuple.h.

◆ m_emId

const LArEM_Base_ID* LArCond2NtupleBase::m_emId
protectedinherited

Definition at line 82 of file LArCond2NtupleBase.h.

◆ m_energyVec_ET

NTuple::Array<int> LArSC2Ntuple::m_energyVec_ET
private

Definition at line 72 of file LArSC2Ntuple.h.

◆ m_energyVec_ET_ID

NTuple::Array<int> LArSC2Ntuple::m_energyVec_ET_ID
private

Definition at line 76 of file LArSC2Ntuple.h.

◆ m_eta

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

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_event

long LArDigits2Ntuple::m_event
protectedinherited

Definition at line 29 of file LArDigits2Ntuple.h.

◆ m_eventInfoDecorKey

SG::ReadDecorHandleKey<xAOD::EventInfo> LArSC2Ntuple::m_eventInfoDecorKey {this, "EventInfoDecorKey", "EventInfo.larFlags"}
private

Definition at line 47 of file LArSC2Ntuple.h.

◆ m_eventInfoKey

SG::ReadHandleKey<xAOD::EventInfo> LArSC2Ntuple::m_eventInfoKey {this, "LArStatusFlag", "EventInfo", "Key for EventInfo object"}
private

Definition at line 46 of file LArSC2Ntuple.h.

◆ m_evt_nt

NTuple::Tuple* LArDigits2Ntuple::m_evt_nt = nullptr
protectedinherited

Definition at line 54 of file LArDigits2Ntuple.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_fillBCID

Gaudi::Property< bool > LArDigits2Ntuple::m_fillBCID {this, "FillBCID", false, "if to fill BCID"}
protectedinherited

Definition at line 36 of file LArDigits2Ntuple.h.

◆ m_fillCaloTT

Gaudi::Property< bool > LArSC2Ntuple::m_fillCaloTT {this, "FillTriggerTowers", false, "Trying to fill also TriggerTowers from ByteStream"}
private

Definition at line 40 of file LArSC2Ntuple.h.

◆ m_fillEMB

Gaudi::Property< bool > LArDigits2Ntuple::m_fillEMB {this, "FillEMB", true, "if to fill EMB"}
protectedinherited

Definition at line 34 of file LArDigits2Ntuple.h.

◆ m_fillEndcap

Gaudi::Property< bool > LArDigits2Ntuple::m_fillEndcap {this, "FillEndcap", true, "if to fill Eendcap"}
protectedinherited

Definition at line 35 of file LArDigits2Ntuple.h.

◆ m_fillLB

Gaudi::Property< bool > LArDigits2Ntuple::m_fillLB {this, "FillLB", false, "if to fill LB in Evnt tree"}
protectedinherited

Definition at line 37 of file LArDigits2Ntuple.h.

◆ m_fillRawChan

Gaudi::Property< bool > LArSC2Ntuple::m_fillRawChan {this, "FillRODEnergy", false, "Trying to fill corresponding cells energies"}
private

Definition at line 37 of file LArSC2Ntuple.h.

◆ m_fillTType

Gaudi::Property< bool > LArSC2Ntuple::m_fillTType {this, "FillTriggerType", false, "Trying to fill trigger type word"}
private

Definition at line 38 of file LArSC2Ntuple.h.

◆ m_FT

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

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_FTlist

Gaudi::Property< std::vector<unsigned int> > LArDigits2Ntuple::m_FTlist {this, "FTlist", {}, "which FT to dump"}
protectedinherited

Definition at line 32 of file LArDigits2Ntuple.h.

◆ m_gain

NTuple::Item<short> LArDigits2Ntuple::m_gain
protectedinherited

Definition at line 40 of file LArDigits2Ntuple.h.

◆ m_hecId

const LArHEC_Base_ID* LArCond2NtupleBase::m_hecId
protectedinherited

Definition at line 83 of file LArCond2NtupleBase.h.

◆ m_IEvent

NTuple::Item<unsigned long long> LArDigits2Ntuple::m_IEvent
protectedinherited

Definition at line 43 of file LArDigits2Ntuple.h.

◆ m_IEventEvt

NTuple::Item<unsigned long long> LArDigits2Ntuple::m_IEventEvt
protectedinherited

Definition at line 56 of file LArDigits2Ntuple.h.

◆ m_initialized

bool LArCond2NtupleBase::m_initialized
privateinherited

Definition at line 50 of file LArCond2NtupleBase.h.

◆ m_ipass

int LArDigits2Ntuple::m_ipass
protectedinherited

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

NTuple::Item<uint32_t> LArSC2Ntuple::m_LArEventBits
private

Definition at line 81 of file LArSC2Ntuple.h.

◆ m_LArFebHeaderContainerKey

SG::ReadHandleKey<LArFebHeaderContainer> LArDigits2Ntuple::m_LArFebHeaderContainerKey { this, "LArFebHeaderKey", "LArFebHeader" }
protectedinherited

Definition at line 62 of file LArDigits2Ntuple.h.

◆ m_LArInError

NTuple::Item<short> LArSC2Ntuple::m_LArInError
private

Definition at line 82 of file LArSC2Ntuple.h.

◆ m_LArLatomeHeaderContainerKey

SG::ReadHandleKey<LArLATOMEHeaderContainer> LArSC2Ntuple::m_LArLatomeHeaderContainerKey { this, "LArLatomeHeaderKey", "SC_LATOME_HEADER" }
private

Definition at line 49 of file LArSC2Ntuple.h.

◆ m_latomeChannel

NTuple::Item<short> LArSC2Ntuple::m_latomeChannel
private

Definition at line 52 of file LArSC2Ntuple.h.

◆ m_latomeSourceId

NTuple::Item<uint32_t> LArSC2Ntuple::m_latomeSourceId
private

Definition at line 68 of file LArSC2Ntuple.h.

◆ m_layer

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

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_LB

NTuple::Item<short> LArDigits2Ntuple::m_LB
protectedinherited

Definition at line 57 of file LArDigits2Ntuple.h.

◆ m_mean

NTuple::Array<float> LArDigits2Ntuple::m_mean
protectedinherited

Definition at line 46 of file LArDigits2Ntuple.h.

◆ m_Net

Gaudi::Property< unsigned int > LArSC2Ntuple::m_Net {this, "Net", 5, "number of energies to store"}
private

Definition at line 36 of file LArSC2Ntuple.h.

◆ m_Nsamples

Gaudi::Property< unsigned int > LArDigits2Ntuple::m_Nsamples {this, "NSamples", 32, "number of samples to store"}
protectedinherited

Definition at line 31 of file LArDigits2Ntuple.h.

◆ m_nt

NTuple::Tuple* LArCond2NtupleBase::m_nt
protectedinherited

Definition at line 68 of file LArCond2NtupleBase.h.

◆ m_ntNet

NTuple::Item<uint32_t> LArSC2Ntuple::m_ntNet
private

Definition at line 64 of file LArSC2Ntuple.h.

◆ m_ntNsamples

NTuple::Item<long> LArDigits2Ntuple::m_ntNsamples
protectedinherited

Definition at line 39 of file LArDigits2Ntuple.h.

◆ m_ntNTT

NTuple::Item<uint32_t> LArSC2Ntuple::m_ntNTT
private

Definition at line 84 of file LArSC2Ntuple.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_overwriteEventNumber

Gaudi::Property< bool > LArSC2Ntuple::m_overwriteEventNumber {this, "OverwriteEventNumber", false, "overwrite the event number from EventInfo ?"}
private

Definition at line 35 of file LArSC2Ntuple.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_pulsed

NTuple::Item<unsigned int> LArDigits2Ntuple::m_pulsed
protectedinherited

Definition at line 50 of file LArDigits2Ntuple.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_RMS

NTuple::Array<float> LArDigits2Ntuple::m_RMS
protectedinherited

Definition at line 47 of file LArDigits2Ntuple.h.

◆ m_ROD_energy

NTuple::Array<float> LArSC2Ntuple::m_ROD_energy
private

Definition at line 54 of file LArSC2Ntuple.h.

◆ m_ROD_id

NTuple::Array<float> LArSC2Ntuple::m_ROD_id
private

Definition at line 56 of file LArSC2Ntuple.h.

◆ m_ROD_time

NTuple::Array<float> LArSC2Ntuple::m_ROD_time
private

Definition at line 55 of file LArSC2Ntuple.h.

◆ m_rphi

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

Definition at line 77 of file LArCond2NtupleBase.h.

◆ m_samples

NTuple::Array<short> LArDigits2Ntuple::m_samples
protectedinherited

Definition at line 44 of file LArDigits2Ntuple.h.

◆ m_samples_ADC_BAS

NTuple::Array<short> LArSC2Ntuple::m_samples_ADC_BAS
private

Definition at line 69 of file LArSC2Ntuple.h.

◆ m_saturVec_ET

NTuple::Array<bool> LArSC2Ntuple::m_saturVec_ET
private

Definition at line 74 of file LArSC2Ntuple.h.

◆ m_saturVec_ET_ID

NTuple::Array<bool> LArSC2Ntuple::m_saturVec_ET_ID
private

Definition at line 78 of file LArSC2Ntuple.h.

◆ m_scidtool

ToolHandle<ICaloSuperCellIDTool> LArSC2Ntuple::m_scidtool {this, "CaloSuperCellIDTool", "CaloSuperCellIDTool", "Offline / SuperCell ID mapping tool"}
private

Definition at line 43 of file LArSC2Ntuple.h.

◆ m_slot

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

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_Slotlist

Gaudi::Property< std::vector<unsigned int> > LArDigits2Ntuple::m_Slotlist {this, "Slotlist", {}, "which Slot to dump"}
protectedinherited

Definition at line 33 of file LArDigits2Ntuple.h.

◆ m_trigDec

ToolHandle< Trig::TrigDecisionTool > LArSC2Ntuple::m_trigDec {this, "TrigDecisionTool", "", "Handle to the TrigDecisionTool"}
private

Definition at line 44 of file LArSC2Ntuple.h.

◆ m_triggerTowerKey

Gaudi::Property< std::string > LArSC2Ntuple::m_triggerTowerKey {this, "TriggerTowerKey", "TriggerTowers", "Trigger Tower container"}
private

Definition at line 50 of file LArSC2Ntuple.h.

◆ m_trigNameMap

std::map<std::string, NTuple::Item<unsigned int> > LArSC2Ntuple::m_trigNameMap
private

Definition at line 80 of file LArSC2Ntuple.h.

◆ m_trigNames

Gaudi::Property< std::vector<std::string> > LArSC2Ntuple::m_trigNames { this, "TrigNames", {"L1_EM3","L1_EM7","L1_EM15"},"which triggers to dump"}
private

Definition at line 39 of file LArSC2Ntuple.h.

◆ m_TTEem

NTuple::Array<int> LArSC2Ntuple::m_TTEem
private

Definition at line 85 of file LArSC2Ntuple.h.

◆ m_TTEhad

NTuple::Array<int> LArSC2Ntuple::m_TTEhad
private

Definition at line 86 of file LArSC2Ntuple.h.

◆ m_TTeta

NTuple::Array<double> LArSC2Ntuple::m_TTeta
private

Definition at line 87 of file LArSC2Ntuple.h.

◆ m_TTphi

NTuple::Array<double> LArSC2Ntuple::m_TTphi
private

Definition at line 88 of file LArSC2Ntuple.h.

◆ m_TType

NTuple::Item<unsigned int> LArSC2Ntuple::m_TType
private

Definition at line 58 of file LArSC2Ntuple.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:
LArDigits2Ntuple::m_evt_nt
NTuple::Tuple * m_evt_nt
Definition: LArDigits2Ntuple.h:54
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArRawSC
Liquid Argon SuperCell raw data.
Definition: LArRawSC.h:19
LArEM_Base_ID::phi
int phi(const Identifier id) const
return phi according to :
LArAccumulatedCalibDigit
Data class for calibration ADC samples preprocessed by the DSP.
Definition: LArAccumulatedCalibDigit.h:42
LArSC2Ntuple::m_ROD_time
NTuple::Array< float > m_ROD_time
Definition: LArSC2Ntuple.h:55
LArSC2Ntuple::m_TTphi
NTuple::Array< double > m_TTphi
Definition: LArSC2Ntuple.h:88
LArSC2Ntuple::m_cablingKeyAdditional
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKeyAdditional
Definition: LArSC2Ntuple.h:42
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
LArSC2Ntuple::m_trigNames
Gaudi::Property< std::vector< std::string > > m_trigNames
Definition: LArSC2Ntuple.h:39
LArCond2NtupleBase::m_isConnected
NTuple::Item< long > m_isConnected
Definition: LArCond2NtupleBase.h:74
LArDigits2Ntuple::m_dac
NTuple::Item< unsigned int > m_dac
Definition: LArDigits2Ntuple.h:48
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
LArSC2Ntuple::m_LArLatomeHeaderContainerKey
SG::ReadHandleKey< LArLATOMEHeaderContainer > m_LArLatomeHeaderContainerKey
Definition: LArSC2Ntuple.h:49
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LArDigits2Ntuple::m_IEventEvt
NTuple::Item< unsigned long long > m_IEventEvt
Definition: LArDigits2Ntuple.h:56
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LArAccumulatedDigitContainer
Container class for LArAccumulatedDigit.
Definition: LArAccumulatedDigitContainer.h:22
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
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
LArSC2Ntuple::m_samples_ADC_BAS
NTuple::Array< short > m_samples_ADC_BAS
Definition: LArSC2Ntuple.h:69
LArDigits2Ntuple::LArDigits2Ntuple
LArDigits2Ntuple(const std::string &name, ISvcLocator *pSvcLocator)
Definition: LArDigits2Ntuple.cxx:10
LArCond2NtupleBase::m_onlChanId
NTuple::Item< long > m_onlChanId
Definition: LArCond2NtupleBase.h:71
LArDigits2Ntuple::m_Nsamples
Gaudi::Property< unsigned int > m_Nsamples
Definition: LArDigits2Ntuple.h:31
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LArRawSC::SourceId
unsigned int SourceId() const
Definition: LArRawSC.h:95
LArSC2Ntuple::m_bcidLATOMEHEAD
NTuple::Item< uint16_t > m_bcidLATOMEHEAD
Definition: LArSC2Ntuple.h:62
LArDigits2Ntuple::m_fillBCID
Gaudi::Property< bool > m_fillBCID
Definition: LArDigits2Ntuple.h:36
LArRawSCContainer
Container class for LArRawSC.
Definition: LArRawSCContainer.h:17
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
LArRawSC::hardwareID
const HWIdentifier & hardwareID() const
Definition: LArRawSC.h:89
LArDigits2Ntuple::m_fillLB
Gaudi::Property< bool > m_fillLB
Definition: LArDigits2Ntuple.h:37
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
LArAccumulatedCalibDigit::nsamples
size_t nsamples() const
return number of samples
Definition: LArAccumulatedCalibDigit.h:120
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
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
LArDigit::samples
const std::vector< short > & samples() const
Definition: LArDigit.h:78
LArDigit::hardwareID
const HWIdentifier & hardwareID() const
Definition: LArDigit.h:66
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]
LArAccumulatedDigit::mean
float mean(int n_min=-1, int n_max=-1) const
Calculates and returns the Mean value of ADC samples.
Definition: LArAccumulatedDigit.cxx:41
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
LArSC2Ntuple::m_energyVec_ET_ID
NTuple::Array< int > m_energyVec_ET_ID
Definition: LArSC2Ntuple.h:76
LArDigits2Ntuple::m_IEvent
NTuple::Item< unsigned long long > m_IEvent
Definition: LArDigits2Ntuple.h:43
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
LArSC2Ntuple::m_bcidVec
NTuple::Array< unsigned short > m_bcidVec
Definition: LArSC2Ntuple.h:67
LArLATOMEHeaderContainer
Container class for LArLATOMEHeader.
Definition: LArLATOMEHeaderContainer.h:19
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
LArSC2Ntuple::rawChanMap_t
std::map< HWIdentifier, const LArRawChannel * > rawChanMap_t
Definition: LArSC2Ntuple.h:28
HWIdentifier
Definition: HWIdentifier.h:13
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
LArSC2Ntuple::m_ntNet
NTuple::Item< uint32_t > m_ntNet
Definition: LArSC2Ntuple.h:64
LArSCDigit::SourceId
unsigned int SourceId() const
Definition: LArSCDigit.h:45
x
#define x
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition: EventInfo_v1.h:335
LArAccumulatedCalibDigit::getIsPulsedInt
uint16_t getIsPulsedInt() const
get the four bit int that tells which lines pulsed
Definition: LArAccumulatedCalibDigit.h:153
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.
Identifier::is_valid
bool is_valid() const
Check if id is in a valid state.
LArDigits2Ntuple::m_ntNsamples
NTuple::Item< long > m_ntNsamples
Definition: LArDigits2Ntuple.h:39
LArDigits2Ntuple::m_ELVL1Id
NTuple::Item< unsigned long > m_ELVL1Id
Definition: LArDigits2Ntuple.h:42
LArRawSC::satur
const std::vector< bool > & satur() const
Definition: LArRawSC.h:107
LArCond2NtupleBase::cablingKey
const SG::ReadCondHandleKey< LArOnOffIdMapping > & cablingKey() const
Definition: LArCond2NtupleBase.cxx:449
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
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
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
LArCond2NtupleBase::m_addHash
Gaudi::Property< bool > m_addHash
Definition: LArCond2NtupleBase.h:58
xAOD::EventInfo_v1::Error
@ Error
The sub-detector issued an error.
Definition: EventInfo_v1.h:349
LArLATOMEHeader::L1Id
uint32_t L1Id() const
get the L1 Id
Definition: LArLATOMEHeader.h:44
LArAccumulatedDigit::hardwareID
const HWIdentifier & hardwareID() const
Return HWIdentifier.
Definition: LArAccumulatedDigit.h:70
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:27
LArSC2Ntuple::m_saturVec_ET
NTuple::Array< bool > m_saturVec_ET
Definition: LArSC2Ntuple.h:74
LArCond2NtupleBase::m_febHash
NTuple::Item< long > m_febHash
Definition: LArCond2NtupleBase.h:75
LArSC2Ntuple::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: LArSC2Ntuple.h:46
LArDigits2Ntuple::m_event
long m_event
Definition: LArDigits2Ntuple.h:29
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
LArSC2Ntuple::m_saturVec_ET_ID
NTuple::Array< bool > m_saturVec_ET_ID
Definition: LArSC2Ntuple.h:78
LArFCAL_Base_ID::phi
int phi(const Identifier id) const
phi [0,15]
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
LArDigits2Ntuple::m_FTlist
Gaudi::Property< std::vector< unsigned int > > m_FTlist
Definition: LArDigits2Ntuple.h:32
LArCond2NtupleBase::m_region
NTuple::Item< long > m_region
Definition: LArCond2NtupleBase.h:71
LArSC2Ntuple::m_TTEhad
NTuple::Array< int > m_TTEhad
Definition: LArSC2Ntuple.h:86
LArDigits2Ntuple::m_bcid
NTuple::Item< short > m_bcid
Definition: LArDigits2Ntuple.h:41
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
LArAccumulatedDigit
Data class for ADC samples and autocorr preprocessed by the DSP.
Definition: LArAccumulatedDigit.h:32
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
LArSC2Ntuple::m_TTEem
NTuple::Array< int > m_TTEem
Definition: LArSC2Ntuple.h:85
AthCommonDataStore
Definition: AthCommonDataStore.h:52
LArDigits2Ntuple::m_RMS
NTuple::Array< float > m_RMS
Definition: LArDigits2Ntuple.h:47
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
LArDigit::nsamples
int nsamples() const
Definition: LArDigit.h:75
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.
LArDigits2Ntuple::m_pulsed
NTuple::Item< unsigned int > m_pulsed
Definition: LArDigits2Ntuple.h:50
LArSC2Ntuple::m_bcidVec_ET_ID
NTuple::Array< unsigned short > m_bcidVec_ET_ID
Definition: LArSC2Ntuple.h:77
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArSC2Ntuple::m_latomeSourceId
NTuple::Item< uint32_t > m_latomeSourceId
Definition: LArSC2Ntuple.h:68
LArRawChannel
Liquid Argon ROD output object base class.
Definition: LArRawChannel.h:40
LArCond2NtupleBase::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArCond2NtupleBase.h:89
LArSC2Ntuple::m_LArEventBits
NTuple::Item< uint32_t > m_LArEventBits
Definition: LArSC2Ntuple.h:81
LArAccumulatedDigit::nsample
int nsample() const
return number of samples
Definition: LArAccumulatedDigit.h:79
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LArAccumulatedCalibDigit::RMS
std::vector< float > RMS() const
Calculates and returns the RMS value of each ADC sample.
Definition: LArAccumulatedCalibDigit.cxx:50
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArCond2NtupleBase::m_FEBTemp1
NTuple::Item< float > m_FEBTemp1
Definition: LArCond2NtupleBase.h:78
LArCond2NtupleBase::m_caloSuperCellMgrKey
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSuperCellMgrKey
Definition: LArCond2NtupleBase.h:97
LArCond2NtupleBase::m_ntpath
std::string m_ntpath
Definition: LArCond2NtupleBase.h:65
LArSC2Ntuple::m_fillRawChan
Gaudi::Property< bool > m_fillRawChan
Definition: LArSC2Ntuple.h:37
LArCond2NtupleBase::NOT_VALID
@ NOT_VALID
Definition: LArCond2NtupleBase.h:63
LArCond2NtupleBase::m_calibMapKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapKey
Definition: LArCond2NtupleBase.h:93
LArSC2Ntuple::m_fillTType
Gaudi::Property< bool > m_fillTType
Definition: LArSC2Ntuple.h:38
LArCond2NtupleBase::m_BCKey
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey
Definition: LArCond2NtupleBase.h:92
LArCond2NtupleBase::m_nt
NTuple::Tuple * m_nt
Definition: LArCond2NtupleBase.h:68
LArRawSC::chan
short chan() const
Definition: LArRawSC.h:92
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
LArLATOMEHeader::BCId
uint16_t BCId() const
get the Bunch Crossing IDs
Definition: LArLATOMEHeader.h:41
LArSC2Ntuple::m_eventInfoDecorKey
SG::ReadDecorHandleKey< xAOD::EventInfo > m_eventInfoDecorKey
Definition: LArSC2Ntuple.h:47
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
LArDigits2Ntuple::m_accContKey
SG::ReadHandleKey< LArAccumulatedDigitContainer > m_accContKey
Definition: LArDigits2Ntuple.h:61
AtlasDetectorID::is_lar_hec
bool is_lar_hec(Identifier id) const
Definition: AtlasDetectorID.h:829
LArSC2Ntuple::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: LArSC2Ntuple.h:44
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
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
LArSC2Ntuple::m_latomeChannel
NTuple::Item< short > m_latomeChannel
Definition: LArSC2Ntuple.h:52
LArSCDigit::Channel
short Channel() const
Definition: LArSCDigit.h:42
LArSC2Ntuple::m_energyVec_ET
NTuple::Array< int > m_energyVec_ET
Definition: LArSC2Ntuple.h:72
LArSC2Ntuple::m_overwriteEventNumber
Gaudi::Property< bool > m_overwriteEventNumber
Definition: LArSC2Ntuple.h:35
LArSC2Ntuple::m_TType
NTuple::Item< unsigned int > m_TType
Definition: LArSC2Ntuple.h:58
DataVector< LVL1::TriggerTower >
LArSC2Ntuple::m_bcidVec_ET
NTuple::Array< unsigned short > m_bcidVec_ET
Definition: LArSC2Ntuple.h:73
LArSC2Ntuple::fillRODEnergy
void fillRODEnergy(HWIdentifier SCId, rawChanMap_t &rawChanMap, const LArOnOffIdMapping *cabling, const LArOnOffIdMapping *cablingROD)
Definition: LArSC2Ntuple.cxx:681
LArAccumulatedCalibDigit::hardwareID
const HWIdentifier & hardwareID() const
Return HWIdentifier.
Definition: LArAccumulatedCalibDigit.h:111
LArDigits2Ntuple::m_ipass
int m_ipass
Definition: LArDigits2Ntuple.h:28
LArOnOffIdMapping::createSignalChannelID
HWIdentifier createSignalChannelID(const Identifier &id) const
create a HWIdentifier from an Identifier (not inline)
Definition: LArOnOffIdMapping.h:126
LArSC2Ntuple::m_contKeys
Gaudi::Property< std::vector< std::string > > m_contKeys
Definition: LArSC2Ntuple.h:34
LArSCDigit
Base class for LArDigits taken by LATOME.
Definition: LArSCDigit.h:19
LArAccumulatedDigit::RMS
float RMS(int n_min=-1, int n_max=-1) const
Calculates and returns the RMS value of ADC samples
Definition: LArAccumulatedDigit.cxx:64
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
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
fill
void fill(H5::Group &out_file, size_t iterations)
Definition: test-hdf5-writer.cxx:95
LArCond2NtupleBase::m_eta
NTuple::Item< long > m_eta
Definition: LArCond2NtupleBase.h:71
LArSC2Ntuple::m_ROD_id
NTuple::Array< float > m_ROD_id
Definition: LArSC2Ntuple.h:56
LArSC2Ntuple::m_triggerTowerKey
Gaudi::Property< std::string > m_triggerTowerKey
Definition: LArSC2Ntuple.h:50
LArAccumulatedCalibDigit::mean
std::vector< float > mean() const
Calculates and returns the Mean value of each ADC sample.
Definition: LArAccumulatedCalibDigit.cxx:36
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
LArSC2Ntuple::m_ntNTT
NTuple::Item< uint32_t > m_ntNTT
Definition: LArSC2Ntuple.h:84
LArCond2NtupleBase::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: LArCond2NtupleBase.h:96
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
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 :
LArDigits2Ntuple::m_contKey
SG::ReadHandleKey< LArDigitContainer > m_contKey
Definition: LArDigits2Ntuple.h:59
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArSC2Ntuple::m_ROD_energy
NTuple::Array< float > m_ROD_energy
Definition: LArSC2Ntuple.h:54
LArCond2NtupleBase::m_onlineId
const LArOnlineID_Base * m_onlineId
Definition: LArCond2NtupleBase.h:85
LArCond2NtupleBase::m_oflChanId
NTuple::Item< long > m_oflChanId
Definition: LArCond2NtupleBase.h:71
LArCond2NtupleBase::m_realgeom
Gaudi::Property< bool > m_realgeom
Definition: LArCond2NtupleBase.h:60
LArAccumulatedCalibDigit::delay
int delay() const
return the setting of the delay
Definition: LArAccumulatedCalibDigit.h:138
LArRawSC::bcids
const std::vector< unsigned short > & bcids() const
Definition: LArRawSC.h:104
LArSC2Ntuple::m_scidtool
ToolHandle< ICaloSuperCellIDTool > m_scidtool
Definition: LArSC2Ntuple.h:43
LArCond2NtupleBase::fillFromIdentifier
bool fillFromIdentifier(const HWIdentifier &id)
Definition: LArCond2NtupleBase.cxx:288
xAOD::EventInfo_v1::Warning
@ Warning
The sub-detector issued a warning.
Definition: EventInfo_v1.h:348
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
LArLATOMEHeader
Holds information from the LATOME Header.
Definition: LArLATOMEHeader.h:19
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
LArDigits2Ntuple::initialize
virtual StatusCode initialize()
Definition: LArDigits2Ntuple.cxx:23
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
LArHEC_Base_ID::sampling
int sampling(const Identifier id) const
return sampling [0,3] (only 0 for supercells)
LArDigits2Ntuple::m_delay
NTuple::Item< unsigned int > m_delay
Definition: LArDigits2Ntuple.h:49
LArCond2NtupleBase::m_isSC
Gaudi::Property< bool > m_isSC
Definition: LArCond2NtupleBase.h:55
LArDigits2Ntuple::m_mean
NTuple::Array< float > m_mean
Definition: LArDigits2Ntuple.h:46
LArDigits2Ntuple::m_samples
NTuple::Array< short > m_samples
Definition: LArDigits2Ntuple.h:44
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
LArSC2Ntuple::m_Net
Gaudi::Property< unsigned int > m_Net
Definition: LArSC2Ntuple.h:36
LArSC2Ntuple::m_bcidVec_ADC_BAS
NTuple::Array< unsigned short > m_bcidVec_ADC_BAS
Definition: LArSC2Ntuple.h:70
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
DataVector::at
const T * at(size_type n) const
Access an element, as an rvalue.
LArCond2NtupleBase::m_chanHash
NTuple::Item< long > m_chanHash
Definition: LArCond2NtupleBase.h:75
LArDigits2Ntuple::m_accCalibContKey
SG::ReadHandleKey< LArAccumulatedCalibDigitContainer > m_accCalibContKey
Definition: LArDigits2Ntuple.h:60
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
LArAccumulatedCalibDigitContainer
Container class for LArAccumulatedCalibDigit.
Definition: LArAccumulatedCalibDigitContainer.h:25
LArHEC_Base_ID::region
int region(const Identifier id) const
return region [0,1]
python.compressB64.c
def c
Definition: compressB64.py:93
LArSCDigit::BCId
const std::vector< unsigned short > & BCId() const
Definition: LArSCDigit.h:48
AtlasDetectorID::is_lar_em
bool is_lar_em(Identifier id) const
Definition: AtlasDetectorID.h:818
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
LArSC2Ntuple::m_LArInError
NTuple::Item< short > m_LArInError
Definition: LArSC2Ntuple.h:82
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
LArDigits2Ntuple::m_LB
NTuple::Item< short > m_LB
Definition: LArDigits2Ntuple.h:57
LArSC2Ntuple::m_TTeta
NTuple::Array< double > m_TTeta
Definition: LArSC2Ntuple.h:87
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
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
LArCond2NtupleBase::m_OffId
Gaudi::Property< bool > m_OffId
Definition: LArCond2NtupleBase.h:57
LArSC2Ntuple::m_trigNameMap
std::map< std::string, NTuple::Item< unsigned int > > m_trigNameMap
Definition: LArSC2Ntuple.h:80
LArSC2Ntuple::m_fillCaloTT
Gaudi::Property< bool > m_fillCaloTT
Definition: LArSC2Ntuple.h:40
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
LArRawChannelContainer
Container for LArRawChannel (IDC using LArRawChannelCollection)
Definition: LArRawChannelContainer.h:26
CaloDetDescrElement::phi_raw
float phi_raw() const
cell phi_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:352
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
LArRawSC::energies
const std::vector< int > & energies() const
Definition: LArRawSC.h:101
LArAccumulatedCalibDigit::DAC
int DAC() const
return the number of samples
Definition: LArAccumulatedCalibDigit.h:135
LArCond2NtupleBase::m_emId
const LArEM_Base_ID * m_emId
Definition: LArCond2NtupleBase.h:82
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 21:50:05 for ATLAS Offline Software by   doxygen 1.8.18