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, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Types

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, bool &acceptMain)
 
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< std::vector< unsigned int > > m_Sidelist {this, "Sidelist", {}, "which side to dump"}
 
Gaudi::Property< std::vector< unsigned int > > m_BElist {this, "BElist", {}, "which B or E 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", "", "key for LArDigitContainer"}
 
SG::ReadHandleKey< LArAccumulatedCalibDigitContainer > m_accCalibContKey {this, "AccCalibContainerKey", "", "key for LArAccumulatedCalibDigitDigitContainer"}
 
SG::ReadHandleKey< LArAccumulatedDigitContainer > m_accContKey {this, "AccContainerKey", "", "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, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

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"}
 
Gaudi::Property< float > m_ETThresh {this, "ETThreshold", -1., "Threshold for ET to fill info"}
 
Gaudi::Property< float > m_ETThreshMain {this, "ETThresholdMain", -1., "Threshold for ET from Main to fill info"}
 
Gaudi::Property< float > m_ADCThresh {this, "ADCThreshold", -1., "Threshold for ADCmax-ADC(0) to fill info"}
 
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", m_eventInfoKey, "larFlags"}
 
SG::ReadHandleKey< LArLATOMEHeaderContainer > m_LArLatomeHeaderContainerKey { this, "LArLatomeHeaderKey", "SC_LATOME_HEADER" }
 
Gaudi::Property< std::string > m_triggerTowerKey {this, "TriggerTowerKey", "TriggerTowers", "Trigger Tower container"}
 
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSCMgrKey
 
const CaloSuperCellDetDescrManager * m_caloMgrSC
 
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 15 of file LArSC2Ntuple.cxx.

15  :
16  LArDigits2Ntuple(name, pSvcLocator), m_caloMgrSC(nullptr) {
17  m_ntTitle = "SCDigits";
18  m_ntpath = "/NTUPLES/FILE1/SCDIGITS";
19  }

◆ ~LArSC2Ntuple()

virtual LArSC2Ntuple::~LArSC2Ntuple ( )
virtualdefault

Member Function Documentation

◆ cablingKey()

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

Definition at line 456 of file LArCond2NtupleBase.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode 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 201 of file LArSC2Ntuple.cxx.

202 {
203 
204  StatusCode sc;
205 
206  const EventContext& ctx = Gaudi::Hive::currentContext();
207 
208  SG::ReadHandle<xAOD::EventInfo>evt (m_eventInfoKey, ctx);
209  ATH_CHECK(evt.isValid());
210 
211  unsigned long long thisevent = evt->eventNumber();
212  unsigned short thislb = evt->lumiBlock();
213 
214  // This should be used for main readout later, once TDAQ fill event headers also in calib. runs properly
215  unsigned long thisbcid = evt->bcid();
216  unsigned long thisELVL1Id = 0;
217  unsigned long thisttype = evt->level1TriggerType();
218  //
220  bool hasDigitContainer=true;
221  const LArDigitContainer *DigitContainer = nullptr;
222  if(!m_contKey.key().empty()) {
223  SG::ReadHandle<LArDigitContainer> hdlDigit(m_contKey, ctx);
224  if(!hdlDigit.isValid()) {
225  ATH_MSG_WARNING( "Unable to retrieve LArDigitContainer with key " << m_contKey << " from DetectorStore. " );
226  hasDigitContainer=false;
227  } else {
228  ATH_MSG_DEBUG( "Got LArDigitContainer with key " << m_contKey.key() );
229  DigitContainer = hdlDigit.cptr();
230  }
231  } else hasDigitContainer=false;
232 
233  bool hasAccCalibDigitContainer=true;
234  const LArAccumulatedCalibDigitContainer *AccCalibDigitContainer = nullptr;
235  if(!m_accCalibContKey.key().empty()) {
236  SG::ReadHandle<LArAccumulatedCalibDigitContainer> hdlAccDigit(m_accCalibContKey, ctx);
237  if(!hdlAccDigit.isValid()) {
238  ATH_MSG_WARNING( "Unable to retrieve LArAccumulatedCalibDigitContainer with key " << m_accCalibContKey << " from DetectorStore. " );
239  hasAccCalibDigitContainer=false;
240  } else {
241  ATH_MSG_DEBUG( "Got LArAccumulatedCalibDigitContainer with key " << m_accCalibContKey.key() );
242  AccCalibDigitContainer = hdlAccDigit.cptr();
243  }
244  } else hasAccCalibDigitContainer=false;
245 
246  bool hasAccDigitContainer=true;
247  const LArAccumulatedDigitContainer *AccDigitContainer = nullptr;
248  if(!m_accContKey.key().empty()) {
249  SG::ReadHandle<LArAccumulatedDigitContainer> hdlAccDigit(m_accContKey, ctx);
250  if(!hdlAccDigit.isValid()) {
251  ATH_MSG_WARNING( "Unable to retrieve LArAccumulatedDigitContainer with key " << m_accContKey << " from DetectorStore. " );
252  hasAccDigitContainer=false;
253  } else {
254  ATH_MSG_DEBUG( "Got LArAccumulatedDigitContainer with key " << m_accContKey.key() );
255  AccDigitContainer = hdlAccDigit.cptr();
256  }
257  } else hasAccDigitContainer=false;
258 
259  const LArDigitContainer* DigitContainer_next = nullptr;
260  const LArRawSCContainer* etcontainer = nullptr;
261  const LArRawSCContainer* etcontainer_next = nullptr;
262  const LArRawChannelContainer* RawChannelContainer = nullptr;
263  const LArLATOMEHeaderContainer*headcontainer = nullptr;
264  std::map<unsigned int, const LArLATOMEHeader*> LATOMEHeadMap;
265  rawChanMap_t rawChannelMap;
266 
267  if ((std::find(m_contKeys.begin(), m_contKeys.end(), "LArRawChannels") != m_contKeys.end()) ){
268  sc = evtStore()->retrieve(RawChannelContainer,"LArRawChannels");
269  if (sc.isFailure()) {
270  ATH_MSG_WARNING( "Unable to retrieve LArRawChannelContainer with key LArRawChannels from DetectorStore. " );
271  }
272  else
273  ATH_MSG_DEBUG( "Got LArRawChannelContainer with key LArRawChannels" );
274  }
275 
276  if(m_ETThreshMain > 0. && !RawChannelContainer) {
277  ATH_MSG_WARNING( "Asked for ETThresholdMain, but no LArRawChannelContainer, will not apply ! " );
278  m_ETThreshMain = -1.;
279  }
280 
281  if ((std::find(m_contKeys.begin(), m_contKeys.end(), "SC_ADC_BAS") != m_contKeys.end()) ){
282  sc = evtStore()->retrieve(DigitContainer_next,"SC_ADC_BAS");
283  if (sc.isFailure()) {
284  ATH_MSG_WARNING( "Unable to retrieve LArDigitContainer with key SC_ADC_BAS from DetectorStore. " );
285  }
286  else
287  ATH_MSG_DEBUG( "Got additional LArDigitContainer with key SC_ADC_BAS " );
288  }
289 
290  if ((std::find(m_contKeys.begin(), m_contKeys.end(), "SC_ET") != m_contKeys.end()) ){
291  sc = evtStore()->retrieve(etcontainer,"SC_ET");
292  if (sc.isFailure()) {
293  ATH_MSG_WARNING( "Unable to retrieve LArRawSCContainer with key SC_ET from DetectorStore. " );
294  }
295  else
296  ATH_MSG_DEBUG( "Got LArRawSCContainer with key SC_ET " );
297  }
298 
299  if ((std::find(m_contKeys.begin(), m_contKeys.end(), "SC_ET_ID") != m_contKeys.end()) ){
300  sc = evtStore()->retrieve(etcontainer_next,"SC_ET_ID");
301  if (sc.isFailure()) {
302  ATH_MSG_WARNING( "Unable to retrieve LArRawSCContainer with key SC_ET_ID from DetectorStore. " );
303  }
304  else
305  ATH_MSG_DEBUG( "Got LArRawSCContainer with key SC_ET_ID" );
306  }
307 
308  SG::ReadHandle<LArLATOMEHeaderContainer> hdrCont(m_LArLatomeHeaderContainerKey);
309  if (! hdrCont.isValid()) {
310  ATH_MSG_WARNING( "No LArLATOME container found in TDS" );
311  } else {
312  ATH_MSG_DEBUG( "LArLATOME container found");
313  headcontainer=&*hdrCont;
314  if(headcontainer != nullptr && *hdrCont->begin()) thisELVL1Id = (*hdrCont->begin())->L1Id();
315  ATH_MSG_DEBUG( " ELVL1I FROM LATOME HEADER " << thisELVL1Id );
316  }
317 
318  if (headcontainer){// loop through header container and fill map
319  for (const LArLATOMEHeader* hit : *headcontainer) {
320  LATOMEHeadMap.try_emplace ( hit->SourceId(), hit );
321  }
322  }
323  if(m_fillRawChan && RawChannelContainer){
324  for (const LArRawChannel& raw : *RawChannelContainer) {
325  rawChannelMap.try_emplace( raw.channelID(), &raw );
326  }
327  }
328  const LArOnOffIdMapping* cabling=nullptr;
329  const LArOnOffIdMapping* cablingROD=nullptr;
330  if(m_fillRawChan){
331  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdl{cablingKey()};
332  cabling=*cablingHdl;
333  if(!cabling) {
334  ATH_MSG_ERROR( "Do not have cabling for SC!" );
335  return StatusCode::FAILURE;
336  }
337  SG::ReadCondHandle<LArOnOffIdMapping> cablingHdlROD{m_cablingKeyAdditional};
338  cablingROD=*cablingHdlROD;
339  if(!cablingROD) {
340  ATH_MSG_ERROR( "Do not have cabling for ROD!" );
341  return StatusCode::FAILURE;
342  }
343  }
344 
346  if( DigitContainer_next && DigitContainer_next->empty() ) DigitContainer_next = nullptr;
347 
348  if( etcontainer && etcontainer->empty() ) etcontainer = nullptr;
349 
350  if( etcontainer_next && etcontainer_next->empty() ) etcontainer_next = nullptr;
351 
352  int cellsno = 0;
353  if (hasDigitContainer) {
354  if( !DigitContainer->empty() ) cellsno = DigitContainer->size();
355  else {
356  ATH_MSG_WARNING("DigitContainer has zero size, but asked, will be not filled... ");
357  return StatusCode::SUCCESS;
358  }
359  }
360  ATH_MSG_DEBUG("DigitContainer has size: "<<cellsno<<" hasDigitContainer: "<<hasDigitContainer);
361 
362  if(m_ETThresh > 0. && !etcontainer && !etcontainer_next) {
363  ATH_MSG_WARNING( "Asked for ETThreshold, but no SC_ET* container, will not apply ! " );
364  m_ETThresh = -1.;
365  }
366 
367  if(m_ETThresh > 0. || m_ETThreshMain > 0.) {
368  SG::ReadCondHandle<CaloSuperCellDetDescrManager> caloMgrHandle{m_caloSCMgrKey};
369  ATH_CHECK(caloMgrHandle.isValid());
370  m_caloMgrSC = *caloMgrHandle;
371  }
372 
373  if(m_ADCThresh > 0. && ! DigitContainer&& !DigitContainer_next) {
374  ATH_MSG_WARNING( "Asked for ADCThreshold, but no digits container, will not apply ! " );
375  m_ADCThresh = -1.;
376  }
377 
378  if (hasAccCalibDigitContainer) {
379  if( !AccCalibDigitContainer->empty() ) {
380  cellsno = AccCalibDigitContainer->size();
381  ATH_MSG_DEBUG("AccCalibDigitContainer has size: "<<cellsno<<" hasAccCalibDigitContainer: "<<hasAccCalibDigitContainer);
382  } else {
383  ATH_MSG_WARNING("AccCalibDigitContainer has zero size, but asked, will be not filled... ");
384  return StatusCode::SUCCESS;
385  }
386  }
387  if (hasAccDigitContainer) {
388  if( !AccDigitContainer->empty() ) {
389  cellsno = AccDigitContainer->size();
390  ATH_MSG_DEBUG("AccDigitContainer has size: "<<cellsno<<" hasAccDigitContainer: "<<hasAccDigitContainer);
391  } else {
392  ATH_MSG_WARNING("AccDigitContainer has zero size, but asked, will be not filled... ");
393  return StatusCode::SUCCESS;
394  }
395  }
396 
397  if (DigitContainer_next){
398  if ( cellsno == 0 ){
399  cellsno = DigitContainer_next->size();
400  }else if(DigitContainer_next->size() != (unsigned)cellsno ){ ATH_MSG_ERROR(" NOOOOOOO! Different number of entries in DigitContainer_next"<< cellsno << " " << DigitContainer_next->size() );
401  }
402  }
403  if (etcontainer){
404  if ( cellsno == 0 ){
405  cellsno = etcontainer->size();
406  }else if(etcontainer->size() != (unsigned)cellsno ){ ATH_MSG_ERROR(" NOOOOOOO! Different number of entries in etcontainer"<< cellsno << " " << etcontainer->size() );
407  }
408  }
409  if (etcontainer_next){
410  if ( cellsno == 0 ){
411  cellsno = etcontainer_next->size();
412  }else if(etcontainer_next->size() != (unsigned)cellsno ){ ATH_MSG_ERROR(" NOOOOOOO! Different number of entries in etcontainer_next"<< cellsno << " " << etcontainer_next->size() );
413  }
414  }
415  unsigned cellCounter = 0;
416  ATH_MSG_DEBUG("cellsno size: "<<cellsno);
417 
418  for( int c = 0;c<cellsno;++c ){
419  if(m_fillBCID) m_bcid = thisbcid;
420 
421  m_ELVL1Id = thisELVL1Id;
422  m_IEvent = thisevent;
423  if(m_overwriteEventNumber) m_IEvent = ctx.evt();
424 
425  bool acceptETMain = true;
426 
427  if( hasAccDigitContainer ){
428 
429  const LArAccumulatedDigit* digi = AccDigitContainer->at(c);
430  // ======================
431 
432 
433  unsigned int trueMaxSample = digi->nsample();
434 
435  if(trueMaxSample>m_Nsamples){
436  if(!m_ipass){
437  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 " );
438  m_ipass = 1;
439  }
440  trueMaxSample = m_Nsamples;
441  }
442  m_ntNsamples = trueMaxSample;
443 
444  fillFromIdentifier(digi->hardwareID());
445 
446  float adcmax=-1.;
447  for(unsigned i = 0; i<trueMaxSample;++i) {
448  m_mean[i] = digi->mean(i);
449  m_RMS[i] = digi->RMS(i);
450  if(m_ADCThresh > 0 && m_mean[i]>adcmax) adcmax=m_mean[i];
451  }
452  if(m_ADCThresh > 0 && adcmax-m_mean[0] <= m_ADCThresh) continue;
453 
454  }//hasAccDigitContainer
455 
456  if( hasAccCalibDigitContainer ){
457 
458  const LArAccumulatedCalibDigit* digi = AccCalibDigitContainer->at(c);
459  // ======================
460 
461 
462  unsigned int trueMaxSample = digi->nsamples();
463 
464  if(trueMaxSample>m_Nsamples){
465  if(!m_ipass){
466  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 " );
467  m_ipass = 1;
468  }
469  trueMaxSample = m_Nsamples;
470  }
471  m_ntNsamples = trueMaxSample;
472 
473  fillFromIdentifier(digi->hardwareID());
474 
475  float adcmax=-1.;
476  for(unsigned i = 0; i<trueMaxSample;++i) {
477  m_mean[i] = digi->mean(i);
478  m_RMS[i] = digi->RMS(i);
479  if(m_ADCThresh > 0 && m_mean[i]>adcmax) adcmax=m_mean[i];
480  }
481  if(m_ADCThresh > 0 && adcmax-m_mean[0] <= m_ADCThresh) continue;
482  m_dac = digi->DAC();
483  m_delay = digi->delay();
484  m_pulsed = digi->getIsPulsedInt();
485 
486  }//hasAccCalibDigitContainer
487 
488  if( hasDigitContainer ){
489 
490  const LArDigit* digi = DigitContainer->at(c);
491  // ======================
492 
493  unsigned int trueMaxSample = digi->nsamples();
494 
495  if(trueMaxSample>m_Nsamples){
496  if(!m_ipass){
497  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 " );
498  m_ipass = 1;
499  }
500  trueMaxSample = m_Nsamples;
501  }
502  m_ntNsamples = trueMaxSample;
503 
504  fillFromIdentifier(digi->hardwareID());
505 
506  if(m_FTlist.size() > 0) { // should do a selection
507  if(std::find(std::begin(m_FTlist), std::end(m_FTlist), m_FT) == std::end(m_FTlist)) { // is our FT in list ?
508  continue;
509  }
510  }
511 
512  if( m_fillRawChan && RawChannelContainer ){
513  fillRODEnergy(digi->hardwareID(), rawChannelMap, cabling, cablingROD, acceptETMain);
514  if(!acceptETMain) continue; // do not pass the ETThreshMain cut
515  }
516 
517  short adcmax=0;
518  for(unsigned i = 0; i<trueMaxSample;++i) {
519  m_samples[i] = digi->samples().at(i);
520  if(m_ADCThresh > 0 && m_samples[i]>adcmax) adcmax=m_samples[i];
521  }
522  if(m_ADCThresh > 0 && adcmax-m_samples[0] <= m_ADCThresh) continue;
523 
524  const LArSCDigit* scdigi = dynamic_cast<const LArSCDigit*>(digi);
525  if(!scdigi){
526  ATH_MSG_DEBUG(" Can't cast digi to LArSCDigit*");
527  }else{
528  if (headcontainer){
529  ATH_MSG_DEBUG(" Accessing LATOME header ");
530  const LArLATOMEHeader*headmap = LATOMEHeadMap[scdigi->SourceId()];
531  if(headmap){
532  m_bcidLATOMEHEAD = headmap->BCId();
533  m_ELVL1Id = headmap->L1Id();
534  }
535  }
536  m_latomeChannel = scdigi->Channel();
537  unsigned int trueMaxBcid = trueMaxSample;
538  if(trueMaxBcid > scdigi->BCId().size()) trueMaxBcid=scdigi->BCId().size();
539  for( unsigned i = 0; i<trueMaxBcid; ++i){
540  m_bcidVec[i] = scdigi->BCId().at(i);
541  }
542  m_latomeSourceId = scdigi->SourceId();
543  }
544 
545 
546  }//hasDigitContainer
547  ATH_MSG_DEBUG("After hasDigitContainer ");
548 
549 
550  // DigitContainer 1 -> SC_ADC_BAS
551  if( DigitContainer_next ){
552 
553  const LArDigit* digi = DigitContainer_next->at(c);
554 
555  unsigned int trueMaxSample = digi->nsamples();
556 
557  if(trueMaxSample>m_Nsamples){
558  if(!m_ipass){
559  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 " );
560  m_ipass=1;
561  }
562  trueMaxSample = m_Nsamples;
563  }
564  m_ntNsamples = trueMaxSample;
565 
566  if( !hasDigitContainer){
567  fillFromIdentifier(digi->hardwareID());
568  if( m_fillRawChan && RawChannelContainer ){
569  fillRODEnergy(digi->hardwareID(), rawChannelMap, cabling, cablingROD, acceptETMain);
570  if(!acceptETMain) continue; // do not pass the ETThreshMain cut
571  }
572  }
573 
574  short adcmax=0;
575  for(unsigned i = 0; i<trueMaxSample;++i) {
576  m_samples_ADC_BAS[i] = digi->samples().at(i);
577  if(m_ADCThresh > 0 && m_samples_ADC_BAS[i]>adcmax) adcmax=m_samples_ADC_BAS[i];
578  }
579  if(m_ADCThresh > 0 && adcmax-m_samples_ADC_BAS[0] <= m_ADCThresh) continue;
580 
581  const LArSCDigit* scdigi = dynamic_cast<const LArSCDigit*>(digi);
582  if(!scdigi){ ATH_MSG_DEBUG(" Can't cast digi to LArSCDigit*");
583  }else{
584  if (headcontainer){
585  const LArLATOMEHeader*headmap = LATOMEHeadMap[scdigi->SourceId()];
586  if(headmap){
587  m_bcidLATOMEHEAD = headmap->BCId();
588  m_ELVL1Id = headmap->L1Id();
589  }
590  }
591  m_latomeChannel = scdigi->Channel();
592  for( unsigned i = 0; i<trueMaxSample;++i){
593  m_bcidVec[i] = scdigi->BCId().at(i);
594  }
595  m_latomeSourceId = scdigi->SourceId();
596  }
597 
598  }
599  ATH_MSG_DEBUG("After DigitContainer_next ");
600 
601 
602 
603  // etcontainer -> SC_ET
604  if( etcontainer ){
605  const LArRawSC*rawSC = etcontainer->at(c);
606 
607  if ( !hasDigitContainer && !DigitContainer_next ){
608  fillFromIdentifier(rawSC->hardwareID());
609  m_latomeChannel = rawSC->chan();
610  if (headcontainer){
611  const LArLATOMEHeader*headmap = LATOMEHeadMap[rawSC->SourceId()];
612  if(headmap){
613  m_bcidLATOMEHEAD = headmap->BCId();
614  m_ELVL1Id = headmap->L1Id();
615  }
616  }
617  if( m_fillRawChan && RawChannelContainer ){
618  fillRODEnergy(rawSC->hardwareID(), rawChannelMap, cabling, cablingROD, acceptETMain);
619  if(!acceptETMain) continue; // do not pass the ETThreshMain cut
620  }
621  }
622  unsigned int truenet = m_Net;
623  if(truenet > rawSC->bcids().size()) truenet=rawSC->bcids().size();
624  for( unsigned i=0; i<truenet;++i){ // just use the vector directly?
625  m_bcidVec_ET[i] = rawSC->bcids().at(i);
626  }
627  if(truenet > rawSC->energies().size()) truenet=rawSC->energies().size();
628  unsigned i;
629  for( i=0; i<truenet;++i){ // just use the vector directly?
630  m_energyVec_ET[i] = rawSC->energies().at(i);
631  if(rawSC->bcids().size()) {
632  if(m_ETThresh > 0. && m_bcidVec_ET[i] == thisbcid) { // our ET
633  if(m_energyVec_ET[i] < m_ETThresh) break;
634  }
635  } else {
636  if(m_ETThresh > 0. ) { // our ET
637  if(m_energyVec_ET[i] < m_ETThresh) break;
638  }
639  }
640  }
641  if(i<truenet) continue; // energy cut
642 
643  if(truenet > rawSC->satur().size()) truenet=rawSC->satur().size();
644  for( unsigned i = 0; i<truenet;++i){ // just use the vector directly?
645  m_saturVec_ET[i] = rawSC->satur().at(i);
646  }
647  m_Net=truenet;
648  m_ntNet=truenet;
649 
650  }
651  ATH_MSG_DEBUG("After etcontainer");
652  // etcontainer_next -> SC_ET_ID
653  if( etcontainer_next ){
654  const LArRawSC*rawSC = etcontainer_next->at(c);
655 
656  if ( !hasDigitContainer && !DigitContainer_next && !etcontainer ){
657  fillFromIdentifier(rawSC->hardwareID());
658  m_latomeChannel = rawSC->chan();
659  if (headcontainer){
660  const LArLATOMEHeader*headmap = LATOMEHeadMap[rawSC->SourceId()];
661  if(headmap){
662  m_bcidLATOMEHEAD = headmap->BCId();
663  m_ELVL1Id = headmap->L1Id();
664  }
665  }
666  if( m_fillRawChan && RawChannelContainer ){
667  fillRODEnergy(rawSC->hardwareID(), rawChannelMap, cabling, cablingROD, acceptETMain);
668  if(!acceptETMain) continue; // do not pass the ETThreshMain cut
669  }
670  }
671  ATH_MSG_DEBUG("Mid etcontainer_next "<<c);
672  for( unsigned i=0; i<rawSC->bcids().size();++i){ // just use the vector directly?
673  m_bcidVec_ET_ID[i] = rawSC->bcids()[i];
674  }
675  unsigned i;
676  for( i=0; i<rawSC->energies().size();++i){ // just use the vector directly?
677  m_energyVec_ET_ID[i] = rawSC->energies()[i];
678  if(rawSC->bcids().size()) {
679  if(m_ETThresh > 0. && m_bcidVec_ET_ID[i] == thisbcid) { // our ET
680  if(m_energyVec_ET_ID[i] < m_ETThresh) break;
681  }
682  } else {
683  if(m_ETThresh > 0.) { // our ET
684  if(m_energyVec_ET_ID[i] < m_ETThresh) break;
685  }
686  }
687  }
688  if(i<rawSC->energies().size()) {
689  continue; // energy cut
690  }
691 
692  for( unsigned i = 0; i<rawSC->satur().size();++i){ // just use the vector directly?
693  m_saturVec_ET_ID[i] = rawSC->satur()[i];
694  }
695  }
696  ATH_MSG_DEBUG("After etcontainer_next");
697 
698  sc = ntupleSvc()->writeRecord(m_nt);
699  if (sc != StatusCode::SUCCESS) {
700  ATH_MSG_ERROR( "writeRecord failed" );
701  return sc;
702  }
703  cellCounter++;
704  }// over cells
705 
706  if(m_fillTType) {
707  m_TType = thisttype;
708  m_IEventEvt = thisevent;
709  if(m_overwriteEventNumber) m_IEventEvt = m_event;
710  m_LB = thislb;
711 
712  for (auto const & x : m_trigNames) {
713  if( ! m_trigDec->getListOfTriggers(x).empty() ){
714  m_trigNameMap[x] = m_trigDec->isPassedBits( x );
715  }
716  }
717  m_LArEventBits = evt->eventFlags(xAOD::EventInfo::LAr);
718  m_LArInError = 0;
719  if(evt->errorState(xAOD::EventInfo::LAr)==xAOD::EventInfo::Error) m_LArInError = m_LArInError | 0x1;
720  if(evt->errorState(xAOD::EventInfo::LAr)==xAOD::EventInfo::Warning) m_LArInError = m_LArInError | 0x2;
721 
722  }
723 
724  if(m_fillCaloTT){
725  const DataVector<LVL1::TriggerTower>* TTVector = nullptr;
726  if ( evtStore()->retrieve(TTVector,m_triggerTowerKey).isFailure() ) {
727  ATH_MSG_WARNING("Could not get the Calo TTs, will not fill...");
728  } else {
729  unsigned count=0;
730  ATH_MSG_INFO("Got TT vector of the sixe " << TTVector->size());
731  DataVector<LVL1::TriggerTower>::const_iterator x;
732  for ( x = TTVector->begin(); x < TTVector->end(); ++x ){
733  m_TTeta[count]=(*x)->eta();
734  m_TTphi[count]=(*x)->phi();
735  m_TTEem[count]=(*x)->emEnergy();
736  m_TTEhad[count]=(*x)->hadEnergy();
737  ++count;
738  if(count==20000) break;
739  }
740  m_ntNTT=count;
741  }
742  }
743 
744  if(m_fillTType || m_fillCaloTT){
745  sc = ntupleSvc()->writeRecord(m_evt_nt);
746  if (sc != StatusCode::SUCCESS) {
747  ATH_MSG_ERROR( "writeRecord failed" );
748  return sc;
749  }
750  }
751 
752  ATH_MSG_DEBUG( "LArSC2Ntuple has finished, filled " << cellCounter << " cells");
753  return StatusCode::SUCCESS;
754 }// end execute-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()) {
351  if(m_isSC) {
352  //FIXME - that is hacky, but do not have legacy helper in case of SC
353  m_calibLine = ((hwid.get_identifier32().get_compact())>>8)&0x7F;
354  } else {
355  m_calibLine = m_onlineId->channel(calibLineV[0]);
356  }
357  }
358  }
359 
360 
361  if ( m_OffId ) {
362  m_detector=NOT_VALID;
363  m_region=NOT_VALID;
364  m_eta=NOT_VALID;
365  m_phi=NOT_VALID;
366 
367  if(m_realgeom){
368  m_reta=NOT_VALID;
369  m_rphi=NOT_VALID;
370  }
371  m_layer=NOT_VALID;
372  m_oflChanId=NOT_VALID;
373  if (m_addHash) m_oflHash=NOT_VALID;
374  }
375 
376  if (m_addBC) m_badChanWord=0;
377  bool connected=false;
378 
379  const CaloDetDescrManager_Base* dd_man = nullptr;
380  if (m_realgeom) {
381  if(m_isSC) {
382  SG::ReadCondHandle<CaloSuperCellDetDescrManager> caloSuperCellMgrHandle{m_caloSuperCellMgrKey};
383  dd_man = *caloSuperCellMgrHandle;
384  }
385  else {
386  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
387  dd_man = *caloMgrHandle;
388  }
389  }
390 
391  try {
392  if (cabling->isOnlineConnected(hwid)) {
393  Identifier id=cabling->cnvToIdentifier(hwid);
394  if ( m_OffId ) {
395  m_oflChanId = id.get_identifier32().get_compact();
396  if (m_addHash) m_oflHash=m_caloId->calo_cell_hash(id);
397 
398  if (dd_man) {
399  const CaloDetDescrElement *elem = dd_man->get_element(id);
400  if(!elem) {
401  ATH_MSG_WARNING("Do not have CDDE for "<<id.getString());
402  } else {
403  m_reta = elem->eta_raw();
404  m_rphi = elem->phi_raw();
405  }
406  }
407 
408  if (m_emId->is_lar_em(id)) {
409  m_eta = m_emId->eta(id);
410  m_phi = m_emId->phi(id);
411  m_layer = m_emId->sampling(id);
412  m_region = m_emId->region(id);
413  m_detector = std::abs(m_emId->barrel_ec(id)) - 1; //0-barrel, 1-EMEC-OW, 2-EMEC-IW
414  }
415  else if (m_hecId->is_lar_hec(id)) {
416  m_eta = m_hecId->eta(id);
417  m_phi = m_hecId->phi(id);
418  m_layer = m_hecId->sampling(id);
419  m_region = m_hecId->region(id);
420  m_detector = 3;
421  }
422  else if (m_fcalId->is_lar_fcal(id)) {
423  m_eta = m_fcalId->eta(id);
424  m_phi = m_fcalId->phi(id);
425  m_layer = m_fcalId->module(id);
426  m_region = 0;
427  m_detector = 4;
428  }
429  } // m_OffId
430  connected=true;
431  }//end if is connected
432  }catch (LArID_Exception & except) {}
433 
434  //bad-channel word
435  if (m_addBC) m_badChanWord=bcCont->status(hwid).packedData();
436  // FEB temperatures
437  if (m_addFEBTemp) {
438  FEBTemp tv = m_FEBTempTool->getFebTemp(hwid);
439  if( !tv.empty() ) {
440  FEBTemp::const_iterator itb = tv.begin();
441  FEBTemp::const_iterator ite = tv.end();
442  for(;itb!=ite;++itb) {
443  m_FEBTemp1 = (*itb).first;
444  m_FEBTemp2 = (*itb).second;
445  }
446  }
447  }
448 
449  if(m_addCalib) m_isConnected = (long)connected;
450 
451  return connected;
452 }

◆ fillRODEnergy()

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

Definition at line 756 of file LArSC2Ntuple.cxx.

757 {
758  const Identifier offId = cabling->cnvToIdentifier(SCId);
759  const std::vector<Identifier> cellIds = m_scidtool->superCellToOfflineID(offId);
760  std::fill(m_ROD_energy.begin(), m_ROD_energy.end(), 0.);
761  std::fill(m_ROD_time.begin(), m_ROD_time.end(), 0.);
762  std::fill(m_ROD_id.begin(), m_ROD_id.end(), 0.);
763  for(unsigned i=0; i<cellIds.size(); ++i ) {
764  const HWIdentifier hwcell=cablingROD->createSignalChannelID(cellIds[i]);
765  if (hwcell.is_valid() && (rawChanMap.count(hwcell) != 0) ) {
766  m_ROD_energy[i] = rawChanMap[hwcell]->energy();
767  m_ROD_time[i] = rawChanMap[hwcell]->time();
768  m_ROD_id[i] = rawChanMap[hwcell]->hardwareID().get_identifier32().get_compact();
769  } else {
770  ATH_MSG_DEBUG(i<<"-th cell invalid Id");
771  }
772  }
773  if(acceptETMain && m_ETThreshMain > 0. && m_caloMgrSC) { // check if cell is above threshold
774  auto result = std::reduce(m_ROD_energy.begin(), m_ROD_energy.end());
775  auto dde = m_caloMgrSC->get_element(offId);
776  if(dde && result / cosh(dde->eta()) < m_ETThreshMain) acceptETMain = false;
777  }
778 }

◆ initialize()

StatusCode LArSC2Ntuple::initialize ( )
overridevirtual

Reimplemented from LArDigits2Ntuple.

Definition at line 21 of file LArSC2Ntuple.cxx.

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

◆ 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", "", "key for LArAccumulatedCalibDigitDigitContainer"}
protectedinherited

Definition at line 62 of file LArDigits2Ntuple.h.

◆ m_accContKey

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

Definition at line 63 of file LArDigits2Ntuple.h.

◆ m_ADCThresh

Gaudi::Property< float > LArSC2Ntuple::m_ADCThresh {this, "ADCThreshold", -1., "Threshold for ADCmax-ADC(0) to fill info"}
private

Definition at line 44 of file LArSC2Ntuple.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 43 of file LArDigits2Ntuple.h.

◆ m_bcidLATOMEHEAD

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

Definition at line 70 of file LArSC2Ntuple.h.

◆ m_bcidVec

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

Definition at line 75 of file LArSC2Ntuple.h.

◆ m_bcidVec_ADC_BAS

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

Definition at line 78 of file LArSC2Ntuple.h.

◆ m_bcidVec_ET

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

Definition at line 81 of file LArSC2Ntuple.h.

◆ m_bcidVec_ET_ID

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

Definition at line 85 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_BElist

Gaudi::Property< std::vector<unsigned int> > LArDigits2Ntuple::m_BElist {this, "BElist", {}, "which B or E to dump"}
protectedinherited

Definition at line 35 of file LArDigits2Ntuple.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 46 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_caloMgrSC

const CaloSuperCellDetDescrManager* LArSC2Ntuple::m_caloMgrSC
private

Definition at line 58 of file LArSC2Ntuple.h.

◆ m_caloSCMgrKey

SG::ReadCondHandleKey<CaloSuperCellDetDescrManager> LArSC2Ntuple::m_caloSCMgrKey
private
Initial value:
{this, "CaloSCDetDescrManager", "CaloSuperCellDetDescrManager",
"SG key of the resulting CaloSuperCellDetDescrManager" }

Definition at line 56 of file LArSC2Ntuple.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", "", "key for LArDigitContainer"}
protectedinherited

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

◆ m_dac

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

Definition at line 50 of file LArDigits2Ntuple.h.

◆ m_delay

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

Definition at line 51 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 44 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 80 of file LArSC2Ntuple.h.

◆ m_energyVec_ET_ID

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

Definition at line 84 of file LArSC2Ntuple.h.

◆ m_eta

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

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_ETThresh

Gaudi::Property< float > LArSC2Ntuple::m_ETThresh {this, "ETThreshold", -1., "Threshold for ET to fill info"}
private

Definition at line 42 of file LArSC2Ntuple.h.

◆ m_ETThreshMain

Gaudi::Property< float > LArSC2Ntuple::m_ETThreshMain {this, "ETThresholdMain", -1., "Threshold for ET from Main to fill info"}
private

Definition at line 43 of file LArSC2Ntuple.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", m_eventInfoKey, "larFlags"}
private

Definition at line 51 of file LArSC2Ntuple.h.

◆ m_eventInfoKey

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

Definition at line 50 of file LArSC2Ntuple.h.

◆ m_evt_nt

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

Definition at line 56 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 38 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 41 of file LArSC2Ntuple.h.

◆ m_fillEMB

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

Definition at line 36 of file LArDigits2Ntuple.h.

◆ m_fillEndcap

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

Definition at line 37 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 39 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 38 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 39 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 42 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 45 of file LArDigits2Ntuple.h.

◆ m_IEventEvt

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

Definition at line 58 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 89 of file LArSC2Ntuple.h.

◆ m_LArFebHeaderContainerKey

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

Definition at line 64 of file LArDigits2Ntuple.h.

◆ m_LArInError

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

Definition at line 90 of file LArSC2Ntuple.h.

◆ m_LArLatomeHeaderContainerKey

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

Definition at line 53 of file LArSC2Ntuple.h.

◆ m_latomeChannel

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

Definition at line 60 of file LArSC2Ntuple.h.

◆ m_latomeSourceId

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

Definition at line 76 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 59 of file LArDigits2Ntuple.h.

◆ m_mean

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

Definition at line 48 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 37 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 72 of file LArSC2Ntuple.h.

◆ m_ntNsamples

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

Definition at line 41 of file LArDigits2Ntuple.h.

◆ m_ntNTT

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

Definition at line 92 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 36 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 52 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 49 of file LArDigits2Ntuple.h.

◆ m_ROD_energy

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

Definition at line 62 of file LArSC2Ntuple.h.

◆ m_ROD_id

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

Definition at line 64 of file LArSC2Ntuple.h.

◆ m_ROD_time

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

Definition at line 63 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 46 of file LArDigits2Ntuple.h.

◆ m_samples_ADC_BAS

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

Definition at line 77 of file LArSC2Ntuple.h.

◆ m_saturVec_ET

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

Definition at line 82 of file LArSC2Ntuple.h.

◆ m_saturVec_ET_ID

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

Definition at line 86 of file LArSC2Ntuple.h.

◆ m_scidtool

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

Definition at line 47 of file LArSC2Ntuple.h.

◆ m_Sidelist

Gaudi::Property< std::vector<unsigned int> > LArDigits2Ntuple::m_Sidelist {this, "Sidelist", {}, "which side to dump"}
protectedinherited

Definition at line 34 of file LArDigits2Ntuple.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 48 of file LArSC2Ntuple.h.

◆ m_triggerTowerKey

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

Definition at line 54 of file LArSC2Ntuple.h.

◆ m_trigNameMap

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

Definition at line 88 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 40 of file LArSC2Ntuple.h.

◆ m_TTEem

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

Definition at line 93 of file LArSC2Ntuple.h.

◆ m_TTEhad

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

Definition at line 94 of file LArSC2Ntuple.h.

◆ m_TTeta

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

Definition at line 95 of file LArSC2Ntuple.h.

◆ m_TTphi

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

Definition at line 96 of file LArSC2Ntuple.h.

◆ m_TType

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

Definition at line 66 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:56
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:63
LArSC2Ntuple::m_TTphi
NTuple::Array< double > m_TTphi
Definition: LArSC2Ntuple.h:96
LArSC2Ntuple::m_cablingKeyAdditional
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKeyAdditional
Definition: LArSC2Ntuple.h:46
LArOnlineID_Base::channel_Hash
IdentifierHash channel_Hash(HWIdentifier channelId) const
Create channel_hash from channel_Id.
Definition: LArOnlineID_Base.cxx:1636
LArCond2NtupleBase::m_layer
NTuple::Item< long > m_layer
Definition: LArCond2NtupleBase.h:71
LArSC2Ntuple::m_trigNames
Gaudi::Property< std::vector< std::string > > m_trigNames
Definition: LArSC2Ntuple.h:40
LArCond2NtupleBase::m_isConnected
NTuple::Item< long > m_isConnected
Definition: LArCond2NtupleBase.h:74
LArDigits2Ntuple::m_dac
NTuple::Item< unsigned int > m_dac
Definition: LArDigits2Ntuple.h:50
get_generator_info.result
result
Definition: get_generator_info.py:21
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:53
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LArDigits2Ntuple::m_IEventEvt
NTuple::Item< unsigned long long > m_IEventEvt
Definition: LArDigits2Ntuple.h:58
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:834
LArCond2NtupleBase::m_addCalib
Gaudi::Property< bool > m_addCalib
Definition: LArCond2NtupleBase.h:59
LArCond2NtupleBase::m_pos_neg
NTuple::Item< long > m_pos_neg
Definition: LArCond2NtupleBase.h:72
LArSC2Ntuple::m_samples_ADC_BAS
NTuple::Array< short > m_samples_ADC_BAS
Definition: LArSC2Ntuple.h:77
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:67
LArRawSC::SourceId
unsigned int SourceId() const
Definition: LArRawSC.h:95
LArSC2Ntuple::m_bcidLATOMEHEAD
NTuple::Item< uint16_t > m_bcidLATOMEHEAD
Definition: LArSC2Ntuple.h:70
LArDigits2Ntuple::m_fillBCID
Gaudi::Property< bool > m_fillBCID
Definition: LArDigits2Ntuple.h:38
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:39
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
LArSC2Ntuple::m_caloMgrSC
const CaloSuperCellDetDescrManager * m_caloMgrSC
Definition: LArSC2Ntuple.h:58
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:1961
LArCond2NtupleBase::m_rphi
NTuple::Item< float > m_rphi
Definition: LArCond2NtupleBase.h:77
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
LArFCAL_Base_ID::module
int module(const Identifier id) const
module [1,3]
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
python.getProblemFolderFromLogs.elem
elem
Definition: getProblemFolderFromLogs.py:90
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:84
LArDigits2Ntuple::m_IEvent
NTuple::Item< unsigned long long > m_IEvent
Definition: LArDigits2Ntuple.h:45
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
LArSC2Ntuple::m_bcidVec
NTuple::Array< unsigned short > m_bcidVec
Definition: LArSC2Ntuple.h:75
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:1942
LArCond2NtupleBase::m_cablingSCKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingSCKey
Definition: LArCond2NtupleBase.h:90
LArSC2Ntuple::m_ntNet
NTuple::Item< uint32_t > m_ntNet
Definition: LArSC2Ntuple.h:72
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:41
LArDigits2Ntuple::m_ELVL1Id
NTuple::Item< unsigned long > m_ELVL1Id
Definition: LArDigits2Ntuple.h:44
LArCond2NtupleBase::NOT_VALID
@ NOT_VALID
Definition: LArCond2NtupleBase.h:63
LArRawSC::satur
const std::vector< bool > & satur() const
Definition: LArRawSC.h:107
LArCond2NtupleBase::cablingKey
const SG::ReadCondHandleKey< LArOnOffIdMapping > & cablingKey() const
Definition: LArCond2NtupleBase.cxx:456
XMLtoHeader.count
count
Definition: XMLtoHeader.py:84
reduce
void reduce(HepMC::GenEvent *ge, std::vector< HepMC::GenParticlePtr > toremove)
Remove unwanted particles from the event, collapsing the graph structure consistently.
Definition: FixHepMC.cxx:84
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
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
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:29
LArSC2Ntuple::m_saturVec_ET
NTuple::Array< bool > m_saturVec_ET
Definition: LArSC2Ntuple.h:82
LArCond2NtupleBase::m_febHash
NTuple::Item< long > m_febHash
Definition: LArCond2NtupleBase.h:75
LArSC2Ntuple::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: LArSC2Ntuple.h:50
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:86
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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_ETThreshMain
Gaudi::Property< float > m_ETThreshMain
Definition: LArSC2Ntuple.h:43
LArSC2Ntuple::m_TTEhad
NTuple::Array< int > m_TTEhad
Definition: LArSC2Ntuple.h:94
LArDigits2Ntuple::m_bcid
NTuple::Item< short > m_bcid
Definition: LArDigits2Ntuple.h:43
LArOnlineID_Base::channel
int channel(const HWIdentifier id) const
Return the channel number of a hardware cell identifier channel = [0,127] in all FEB.
Definition: LArOnlineID_Base.cxx:1967
LArAccumulatedDigit
Data class for ADC samples and autocorr preprocessed by the DSP.
Definition: LArAccumulatedDigit.h:32
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
LArSC2Ntuple::m_TTEem
NTuple::Array< int > m_TTEem
Definition: LArSC2Ntuple.h:93
AthCommonDataStore
Definition: AthCommonDataStore.h:52
LArDigits2Ntuple::m_RMS
NTuple::Array< float > m_RMS
Definition: LArDigits2Ntuple.h:49
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:52
LArSC2Ntuple::m_bcidVec_ET_ID
NTuple::Array< unsigned short > m_bcidVec_ET_ID
Definition: LArSC2Ntuple.h:85
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:76
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:89
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
LArCond2NtupleBase::m_ntpath
std::string m_ntpath
Definition: LArCond2NtupleBase.h:65
LArSC2Ntuple::m_fillRawChan
Gaudi::Property< bool > m_fillRawChan
Definition: LArSC2Ntuple.h:38
LArCond2NtupleBase::m_calibMapKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapKey
Definition: LArCond2NtupleBase.h:93
LArSC2Ntuple::m_fillTType
Gaudi::Property< bool > m_fillTType
Definition: LArSC2Ntuple.h:39
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:1954
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:51
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:63
AtlasDetectorID::is_lar_hec
bool is_lar_hec(Identifier id) const
Definition: AtlasDetectorID.h:824
LArSC2Ntuple::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: LArSC2Ntuple.h:48
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:60
LArSCDigit::Channel
short Channel() const
Definition: LArSCDigit.h:42
LArSC2Ntuple::m_energyVec_ET
NTuple::Array< int > m_energyVec_ET
Definition: LArSC2Ntuple.h:80
LArSC2Ntuple::m_overwriteEventNumber
Gaudi::Property< bool > m_overwriteEventNumber
Definition: LArSC2Ntuple.h:36
LArSC2Ntuple::m_TType
NTuple::Item< unsigned int > m_TType
Definition: LArSC2Ntuple.h:66
DataVector< LVL1::TriggerTower >
LArSC2Ntuple::m_bcidVec_ET
NTuple::Array< unsigned short > m_bcidVec_ET
Definition: LArSC2Ntuple.h:81
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:35
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:1483
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
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:64
LArSC2Ntuple::m_triggerTowerKey
Gaudi::Property< std::string > m_triggerTowerKey
Definition: LArSC2Ntuple.h:54
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:92
LArCond2NtupleBase::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: LArCond2NtupleBase.h:96
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
LArSC2Ntuple::fillRODEnergy
void fillRODEnergy(HWIdentifier SCId, rawChanMap_t &rawChanMap, const LArOnOffIdMapping *cabling, const LArOnOffIdMapping *cablingROD, bool &acceptMain)
Definition: LArSC2Ntuple.cxx:756
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:61
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArSC2Ntuple::m_ROD_energy
NTuple::Array< float > m_ROD_energy
Definition: LArSC2Ntuple.h:62
LArSC2Ntuple::m_ADCThresh
Gaudi::Property< float > m_ADCThresh
Definition: LArSC2Ntuple.h:44
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:47
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:1948
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
lumiFormat.fill
fill
Definition: lumiFormat.py:104
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LArSC2Ntuple::m_ETThresh
Gaudi::Property< float > m_ETThresh
Definition: LArSC2Ntuple.h:42
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:51
LArCond2NtupleBase::m_isSC
Gaudi::Property< bool > m_isSC
Definition: LArCond2NtupleBase.h:55
LArDigits2Ntuple::m_mean
NTuple::Array< float > m_mean
Definition: LArDigits2Ntuple.h:48
LArDigits2Ntuple::m_samples
NTuple::Array< short > m_samples
Definition: LArDigits2Ntuple.h:46
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
LArSC2Ntuple::m_Net
Gaudi::Property< unsigned int > m_Net
Definition: LArSC2Ntuple.h:37
LArSC2Ntuple::m_bcidVec_ADC_BAS
NTuple::Array< unsigned short > m_bcidVec_ADC_BAS
Definition: LArSC2Ntuple.h:78
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
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:62
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:813
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:90
LArCond2NtupleBase::m_FT
NTuple::Item< long > m_FT
Definition: LArCond2NtupleBase.h:72
LArDigits2Ntuple::m_LB
NTuple::Item< short > m_LB
Definition: LArDigits2Ntuple.h:59
LArSC2Ntuple::m_TTeta
NTuple::Array< double > m_TTeta
Definition: LArSC2Ntuple.h:95
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
LArOnlineID_Base::feb_Hash
IdentifierHash feb_Hash(HWIdentifier febId) const
Create feb hash identifiers from feb identifiers.
Definition: LArOnlineID_Base.cxx:1516
LArCond2NtupleBase::m_caloId
const CaloCell_Base_ID * m_caloId
Definition: LArCond2NtupleBase.h:86
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:88
LArSC2Ntuple::m_fillCaloTT
Gaudi::Property< bool > m_fillCaloTT
Definition: LArSC2Ntuple.h:41
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
LArSC2Ntuple::m_caloSCMgrKey
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSCMgrKey
Definition: LArSC2Ntuple.h:56
LArRawChannelContainer
Container for LArRawChannel (IDC using LArRawChannelCollection)
Definition: LArRawChannelContainer.h:26
LArHEC_Base_ID::phi
int phi(const Identifier id) const
return phi[0,63] outer part [0,31] inner part
ServiceHandle< ICondSvc >
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
LArCond2NtupleBase::m_channel
NTuple::Item< long > m_channel
Definition: LArCond2NtupleBase.h:72
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 Oct 30 2025 21:36:04 for ATLAS Offline Software by   doxygen 1.8.18