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

#include <LArSC2Ntuple.h>

Inheritance diagram for LArSC2Ntuple:
Collaboration diagram for LArSC2Ntuple:

Public Member Functions

 LArSC2Ntuple (const std::string &name, ISvcLocator *pSvcLocator)
 
virtual ~LArSC2Ntuple ()=default
 
virtual StatusCode initialize () override
 
virtual StatusCode execute () override
 
bool fillFromIdentifier (const HWIdentifier &id)
 
const SG::ReadCondHandleKey< LArOnOffIdMapping > & cablingKey () const
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Types

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

Protected Member Functions

void fillRODEnergy (HWIdentifier SCId, rawChanMap_t &rawChanMap, const LArOnOffIdMapping *cabling, const LArOnOffIdMapping *cablingROD)
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

int m_ipass
 
long m_event
 
Gaudi::Property< unsigned int > m_Nsamples {this, "NSamples", 32, "number of samples to store"}
 
Gaudi::Property< std::vector< unsigned int > > m_FTlist {this, "FTlist", {}, "which FT to dump"}
 
Gaudi::Property< std::vector< unsigned int > > m_Slotlist {this, "Slotlist", {}, "which Slot to dump"}
 
Gaudi::Property< bool > m_fillEMB {this, "FillEMB", true, "if to fill EMB"}
 
Gaudi::Property< bool > m_fillEndcap {this, "FillEndcap", true, "if to fill Eendcap"}
 
Gaudi::Property< bool > m_fillBCID {this, "FillBCID", false, "if to fill BCID"}
 
Gaudi::Property< bool > m_fillLB {this, "FillLB", false, "if to fill LB in Evnt tree"}
 
NTuple::Item< long > m_ntNsamples
 
NTuple::Item< short > m_gain
 
NTuple::Item< short > m_bcid
 
NTuple::Item< unsigned long > m_ELVL1Id
 
NTuple::Item< unsigned long long > m_IEvent
 
NTuple::Array< short > m_samples
 
NTuple::Tuple * m_evt_nt = nullptr
 
NTuple::Item< unsigned long long > m_IEventEvt
 
NTuple::Item< short > m_LB
 
SG::ReadHandleKey< LArDigitContainer > m_contKey {this, "ContainerKey", "FREE", "key for LArDigitContainer"}
 
SG::ReadHandleKey< LArFebHeaderContainer > m_LArFebHeaderContainerKey { this, "LArFebHeaderKey", "LArFebHeader" }
 
Gaudi::Property< bool > m_addBC {this, "AddBadChannelInfo", true, "dump BadChan info ?"}
 
Gaudi::Property< bool > m_addFEBTemp {this, "AddFEBTempInfo", false, "dump FEB temperature info ?"}
 
Gaudi::Property< bool > m_isSC {this, "isSC", false, "are we working with SC?"}
 
Gaudi::Property< bool > m_isFlat {this, "isFlat", false, "are we working with Flat conditions ?"}
 
Gaudi::Property< bool > m_OffId {this, "OffId", false, "dump also offline ID ?"}
 
Gaudi::Property< bool > m_addHash {this, "AddHash", false, "add also ID hash info ?"}
 
Gaudi::Property< bool > m_addCalib {this, "AddCalib", false, "add also calib line info info ?"}
 
Gaudi::Property< bool > m_realgeom {this, "RealGeometry", false, "add real geometry values ?"}
 
Gaudi::Property< bool > m_expandId {this,"ExpandId", true ,"add online Id decoded fields ?"}
 
std::string m_ntpath
 
std::string m_ntTitle
 
NTuple::Tuple * m_nt
 
NTuple::Item< long > m_detector
 
NTuple::Item< long > m_region
 
NTuple::Item< long > m_layer
 
NTuple::Item< long > m_eta
 
NTuple::Item< long > m_phi
 
NTuple::Item< long > m_onlChanId
 
NTuple::Item< long > m_oflChanId
 
NTuple::Item< long > m_pos_neg
 
NTuple::Item< long > m_barrel_ec
 
NTuple::Item< long > m_FT
 
NTuple::Item< long > m_slot
 
NTuple::Item< long > m_channel
 
NTuple::Item< long > m_calibLine
 
NTuple::Item< long > m_badChanWord
 
NTuple::Item< long > m_isConnected
 
NTuple::Item< long > m_chanHash
 
NTuple::Item< long > m_febHash
 
NTuple::Item< long > m_oflHash
 
NTuple::Item< float > m_reta
 
NTuple::Item< float > m_rphi
 
NTuple::Item< float > m_FEBTemp1
 
NTuple::Item< float > m_FEBTemp2
 
StoreGateSvc * m_detStore
 
const LArEM_Base_ID * m_emId
 
const LArHEC_Base_ID * m_hecId
 
const LArFCAL_Base_ID * m_fcalId
 
const LArOnlineID_Base * m_onlineId
 
const CaloCell_Base_ID * m_caloId
 
ToolHandle< ILArFEBTempTool > m_FEBTempTool
 
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
 
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingSCKey {this,"CablingSCKey","LArOnOffIdMapSC","SG Key of LArOnOffIdMapping object"}
 
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey {this, "BadChanKey", "LArBadChannel", "SG bad channels key"}
 
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapKey {this,"CalibMapKey","LArCalibLineMap","SG Key of calib line mapping object"}
 
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapSCKey {this,"CalibMapSCKey","LArCalibIdMapSC","SG Key of calib line mapping object"}
 
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey {this, "CaloDetDescrManager", "CaloDetDescrManager", "SG Key for CaloDetDescrManager in the Condition Store"}
 
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSuperCellMgrKey {this, "CaloSuperCellDetDescrManager", "CaloSuperCellDetDescrManager", "SG key of the resulting CaloSuperCellDetDescrManager" }
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

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

Private Attributes

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

Detailed Description

Definition at line 17 of file LArSC2Ntuple.h.

Member Typedef Documentation

◆ rawChanMap_t

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

Definition at line 28 of file LArSC2Ntuple.h.

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
protectedinherited
Enumerator
NOT_VALID 

Definition at line 63 of file LArCond2NtupleBase.h.

63 {NOT_VALID = -999};

Constructor & Destructor Documentation

◆ LArSC2Ntuple()

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

Definition at line 13 of file LArSC2Ntuple.cxx.

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

◆ ~LArSC2Ntuple()

virtual LArSC2Ntuple::~LArSC2Ntuple ( )
virtualdefault

Member Function Documentation

◆ cablingKey()

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

Definition at line 449 of file LArCond2NtupleBase.cxx.

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

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode LArSC2Ntuple::execute ( )
overridevirtual

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

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

Reimplemented from LArDigits2Ntuple.

Definition at line 197 of file LArSC2Ntuple.cxx.

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

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

◆ fillFromIdentifier()

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

Definition at line 288 of file LArCond2NtupleBase.cxx.

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

◆ fillRODEnergy()

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

Definition at line 626 of file LArSC2Ntuple.cxx.

627 {
628  const Identifier offId = cabling->cnvToIdentifier(SCId);
629  const std::vector<Identifier> cellIds = m_scidtool->superCellToOfflineID(offId);
630  std::fill(m_ROD_energy.begin(), m_ROD_energy.end(), 0.);
631  std::fill(m_ROD_time.begin(), m_ROD_time.end(), 0.);
632  std::fill(m_ROD_id.begin(), m_ROD_id.end(), 0.);
633  for(unsigned i=0; i<cellIds.size(); ++i ) {
634  const HWIdentifier hwcell=cablingROD->createSignalChannelID(cellIds[i]);
635  if (hwcell.is_valid() && (rawChanMap.count(hwcell) != 0) ) {
636  m_ROD_energy[i] = rawChanMap[hwcell]->energy();
637  m_ROD_time[i] = rawChanMap[hwcell]->time();
638  m_ROD_id[i] = rawChanMap[hwcell]->hardwareID().get_identifier32().get_compact();
639  } else {
640  ATH_MSG_DEBUG(i<<"-th cell invalid Id");
641  }
642  }
643 
644 }

◆ initialize()

StatusCode LArSC2Ntuple::initialize ( )
overridevirtual

Reimplemented from LArDigits2Ntuple.

Definition at line 19 of file LArSC2Ntuple.cxx.

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

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

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

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_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 39 of file LArDigits2Ntuple.h.

◆ m_bcidLATOMEHEAD

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

Definition at line 62 of file LArSC2Ntuple.h.

◆ m_bcidVec

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

Definition at line 67 of file LArSC2Ntuple.h.

◆ m_bcidVec_ADC_BAS

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

Definition at line 70 of file LArSC2Ntuple.h.

◆ m_bcidVec_ET

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

Definition at line 73 of file LArSC2Ntuple.h.

◆ m_bcidVec_ET_ID

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

Definition at line 77 of file LArSC2Ntuple.h.

◆ m_BCKey

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

Definition at line 92 of file LArCond2NtupleBase.h.

◆ m_cablingKey

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

Definition at line 89 of file LArCond2NtupleBase.h.

◆ m_cablingKeyAdditional

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

Definition at line 42 of file LArSC2Ntuple.h.

◆ m_cablingSCKey

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

Definition at line 90 of file LArCond2NtupleBase.h.

◆ m_calibLine

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

Definition at line 73 of file LArCond2NtupleBase.h.

◆ m_calibMapKey

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

Definition at line 93 of file LArCond2NtupleBase.h.

◆ m_calibMapSCKey

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

Definition at line 94 of file LArCond2NtupleBase.h.

◆ m_caloId

const CaloCell_Base_ID* LArCond2NtupleBase::m_caloId
protectedinherited

Definition at line 86 of file LArCond2NtupleBase.h.

◆ m_caloMgrKey

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

Definition at line 96 of file LArCond2NtupleBase.h.

◆ m_caloSuperCellMgrKey

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

Definition at line 97 of file LArCond2NtupleBase.h.

◆ m_chanHash

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

Definition at line 75 of file LArCond2NtupleBase.h.

◆ m_channel

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

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_contKey

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

Definition at line 50 of file LArDigits2Ntuple.h.

◆ m_contKeys

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

Definition at line 34 of file LArSC2Ntuple.h.

◆ m_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 40 of file LArDigits2Ntuple.h.

◆ m_emId

const LArEM_Base_ID* LArCond2NtupleBase::m_emId
protectedinherited

Definition at line 82 of file LArCond2NtupleBase.h.

◆ m_energyVec_ET

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

Definition at line 72 of file LArSC2Ntuple.h.

◆ m_energyVec_ET_ID

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

Definition at line 76 of file LArSC2Ntuple.h.

◆ m_eta

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

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_event

long LArDigits2Ntuple::m_event
protectedinherited

Definition at line 27 of file LArDigits2Ntuple.h.

◆ m_eventInfoDecorKey

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

Definition at line 47 of file LArSC2Ntuple.h.

◆ m_eventInfoKey

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

Definition at line 46 of file LArSC2Ntuple.h.

◆ m_evt_nt

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

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

◆ m_fillCaloTT

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

Definition at line 40 of file LArSC2Ntuple.h.

◆ m_fillEMB

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

Definition at line 32 of file LArDigits2Ntuple.h.

◆ m_fillEndcap

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

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

◆ m_fillRawChan

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

Definition at line 37 of file LArSC2Ntuple.h.

◆ m_fillTType

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

Definition at line 38 of file LArSC2Ntuple.h.

◆ m_FT

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

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_FTlist

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

Definition at line 30 of file LArDigits2Ntuple.h.

◆ m_gain

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

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

◆ m_IEventEvt

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

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

◆ m_isConnected

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

Definition at line 74 of file LArCond2NtupleBase.h.

◆ m_isFlat

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

Definition at line 56 of file LArCond2NtupleBase.h.

◆ m_isSC

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

Definition at line 55 of file LArCond2NtupleBase.h.

◆ m_LArEventBits

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

Definition at line 81 of file LArSC2Ntuple.h.

◆ m_LArFebHeaderContainerKey

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

Definition at line 51 of file LArDigits2Ntuple.h.

◆ m_LArInError

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

Definition at line 82 of file LArSC2Ntuple.h.

◆ m_LArLatomeHeaderContainerKey

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

Definition at line 49 of file LArSC2Ntuple.h.

◆ m_latomeChannel

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

Definition at line 52 of file LArSC2Ntuple.h.

◆ m_latomeSourceId

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

Definition at line 68 of file LArSC2Ntuple.h.

◆ m_layer

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

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_LB

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

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

◆ m_Nsamples

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

Definition at line 29 of file LArDigits2Ntuple.h.

◆ m_nt

NTuple::Tuple* LArCond2NtupleBase::m_nt
protectedinherited

Definition at line 68 of file LArCond2NtupleBase.h.

◆ m_ntNet

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

Definition at line 64 of file LArSC2Ntuple.h.

◆ m_ntNsamples

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

Definition at line 37 of file LArDigits2Ntuple.h.

◆ m_ntNTT

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

Definition at line 84 of file LArSC2Ntuple.h.

◆ m_ntpath

std::string LArCond2NtupleBase::m_ntpath
protectedinherited

Definition at line 65 of file LArCond2NtupleBase.h.

◆ m_ntTitle

std::string LArCond2NtupleBase::m_ntTitle
protectedinherited

Definition at line 65 of file LArCond2NtupleBase.h.

◆ m_OffId

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

Definition at line 57 of file LArCond2NtupleBase.h.

◆ m_oflChanId

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

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_oflHash

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

Definition at line 75 of file LArCond2NtupleBase.h.

◆ m_onlChanId

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

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_onlineId

const LArOnlineID_Base* LArCond2NtupleBase::m_onlineId
protectedinherited

Definition at line 85 of file LArCond2NtupleBase.h.

◆ m_overwriteEventNumber

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

Definition at line 35 of file LArSC2Ntuple.h.

◆ m_phi

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

Definition at line 71 of file LArCond2NtupleBase.h.

◆ m_pos_neg

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

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_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_ROD_energy

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

Definition at line 54 of file LArSC2Ntuple.h.

◆ m_ROD_id

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

Definition at line 56 of file LArSC2Ntuple.h.

◆ m_ROD_time

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

Definition at line 55 of file LArSC2Ntuple.h.

◆ m_rphi

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

Definition at line 77 of file LArCond2NtupleBase.h.

◆ m_samples

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

Definition at line 42 of file LArDigits2Ntuple.h.

◆ m_samples_ADC_BAS

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

Definition at line 69 of file LArSC2Ntuple.h.

◆ m_saturVec_ET

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

Definition at line 74 of file LArSC2Ntuple.h.

◆ m_saturVec_ET_ID

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

Definition at line 78 of file LArSC2Ntuple.h.

◆ m_scidtool

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

Definition at line 43 of file LArSC2Ntuple.h.

◆ m_slot

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

Definition at line 72 of file LArCond2NtupleBase.h.

◆ m_Slotlist

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

Definition at line 31 of file LArDigits2Ntuple.h.

◆ m_trigDec

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

Definition at line 44 of file LArSC2Ntuple.h.

◆ m_triggerTowerKey

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

Definition at line 50 of file LArSC2Ntuple.h.

◆ m_trigNameMap

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

Definition at line 80 of file LArSC2Ntuple.h.

◆ m_trigNames

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

Definition at line 39 of file LArSC2Ntuple.h.

◆ m_TTEem

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

Definition at line 85 of file LArSC2Ntuple.h.

◆ m_TTEhad

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

Definition at line 86 of file LArSC2Ntuple.h.

◆ m_TTeta

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

Definition at line 87 of file LArSC2Ntuple.h.

◆ m_TTphi

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

Definition at line 88 of file LArSC2Ntuple.h.

◆ m_TType

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

Definition at line 58 of file LArSC2Ntuple.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
LArDigits2Ntuple::m_evt_nt
NTuple::Tuple * m_evt_nt
Definition: LArDigits2Ntuple.h:45
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 :
LArSC2Ntuple::m_ROD_time
NTuple::Array< float > m_ROD_time
Definition: LArSC2Ntuple.h:55
LArSC2Ntuple::m_TTphi
NTuple::Array< double > m_TTphi
Definition: LArSC2Ntuple.h:88
LArSC2Ntuple::m_cablingKeyAdditional
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKeyAdditional
Definition: LArSC2Ntuple.h:42
LArOnlineID_Base::channel_Hash
IdentifierHash channel_Hash(HWIdentifier channelId) const
Create channel_hash from channel_Id.
Definition: LArOnlineID_Base.cxx: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:39
LArCond2NtupleBase::m_isConnected
NTuple::Item< long > m_isConnected
Definition: LArCond2NtupleBase.h:74
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
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
LArHEC_Base_ID::eta
int eta(const Identifier id) const
return eta [0,9] outer part [0,3] inner part
LArCond2NtupleBase::m_fcalId
const LArFCAL_Base_ID * m_fcalId
Definition: LArCond2NtupleBase.h:84
LArCond2NtupleBase::m_addFEBTemp
Gaudi::Property< bool > m_addFEBTemp
Definition: LArCond2NtupleBase.h:54
LArSC2Ntuple::m_LArLatomeHeaderContainerKey
SG::ReadHandleKey< LArLATOMEHeaderContainer > m_LArLatomeHeaderContainerKey
Definition: LArSC2Ntuple.h:49
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LArDigits2Ntuple::m_IEventEvt
NTuple::Item< unsigned long long > m_IEventEvt
Definition: LArDigits2Ntuple.h:47
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
LArCond2NtupleBase::m_slot
NTuple::Item< long > m_slot
Definition: LArCond2NtupleBase.h:72
AtlasDetectorID::is_lar_fcal
bool is_lar_fcal(Identifier id) const
Definition: AtlasDetectorID.h:839
LArCond2NtupleBase::m_addCalib
Gaudi::Property< bool > m_addCalib
Definition: LArCond2NtupleBase.h:59
LArCond2NtupleBase::m_pos_neg
NTuple::Item< long > m_pos_neg
Definition: LArCond2NtupleBase.h:72
LArSC2Ntuple::m_samples_ADC_BAS
NTuple::Array< short > m_samples_ADC_BAS
Definition: LArSC2Ntuple.h:69
LArDigits2Ntuple::LArDigits2Ntuple
LArDigits2Ntuple(const std::string &name, ISvcLocator *pSvcLocator)
Definition: LArDigits2Ntuple.cxx:10
LArCond2NtupleBase::m_onlChanId
NTuple::Item< long > m_onlChanId
Definition: LArCond2NtupleBase.h:71
LArDigits2Ntuple::m_Nsamples
Gaudi::Property< unsigned int > m_Nsamples
Definition: LArDigits2Ntuple.h:29
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LArRawSC::SourceId
unsigned int SourceId() const
Definition: LArRawSC.h:95
LArSC2Ntuple::m_bcidLATOMEHEAD
NTuple::Item< uint16_t > m_bcidLATOMEHEAD
Definition: LArSC2Ntuple.h:62
LArDigits2Ntuple::m_fillBCID
Gaudi::Property< bool > m_fillBCID
Definition: LArDigits2Ntuple.h:34
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:35
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
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
PlotCalibFromCool.begin
begin
Definition: PlotCalibFromCool.py:94
LArDigit::samples
const std::vector< short > & samples() const
Definition: LArDigit.h:78
LArDigit::hardwareID
const HWIdentifier & hardwareID() const
Definition: LArDigit.h:66
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx: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]
LArEM_Base_ID::region
int region(const Identifier id) const
return region according to :
LArCond2NtupleBase::m_oflHash
NTuple::Item< long > m_oflHash
Definition: LArCond2NtupleBase.h:75
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
CaloDetDescrManager_Base
Definition: CaloDetDescrManager.h:147
LArSC2Ntuple::m_energyVec_ET_ID
NTuple::Array< int > m_energyVec_ET_ID
Definition: LArSC2Ntuple.h:76
LArDigits2Ntuple::m_IEvent
NTuple::Item< unsigned long long > m_IEvent
Definition: LArDigits2Ntuple.h:41
LArG4FSStartPointFilter.evt
evt
Definition: LArG4FSStartPointFilter.py:42
LArSC2Ntuple::m_bcidVec
NTuple::Array< unsigned short > m_bcidVec
Definition: LArSC2Ntuple.h:67
LArLATOMEHeaderContainer
Container class for LArLATOMEHeader.
Definition: LArLATOMEHeaderContainer.h:19
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
LArSC2Ntuple::rawChanMap_t
std::map< HWIdentifier, const LArRawChannel * > rawChanMap_t
Definition: LArSC2Ntuple.h:28
HWIdentifier
Definition: HWIdentifier.h:13
LArOnlineID_Base::barrel_ec
int barrel_ec(const HWIdentifier id) const
Return the position barrel or endcap of a hardware cell identifier: barrel_ec = [0,...
Definition: LArOnlineID_Base.cxx: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:64
LArSCDigit::SourceId
unsigned int SourceId() const
Definition: LArSCDigit.h:45
x
#define x
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition: EventInfo_v1.h:335
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:37
LArDigits2Ntuple::m_ELVL1Id
NTuple::Item< unsigned long > m_ELVL1Id
Definition: LArDigits2Ntuple.h:40
LArRawSC::satur
const std::vector< bool > & satur() const
Definition: LArRawSC.h:107
LArCond2NtupleBase::cablingKey
const SG::ReadCondHandleKey< LArOnOffIdMapping > & cablingKey() const
Definition: LArCond2NtupleBase.cxx:449
XMLtoHeader.count
count
Definition: XMLtoHeader.py:85
LArEM_Base_ID::eta
int eta(const Identifier id) const
return eta according to :
FEBTemp
std::vector< std::pair< float, float > > FEBTemp
Definition: ILArFEBTempTool.h:27
LArCond2NtupleBase::m_FEBTempTool
ToolHandle< ILArFEBTempTool > m_FEBTempTool
Definition: LArCond2NtupleBase.h:87
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
LArCond2NtupleBase::m_barrel_ec
NTuple::Item< long > m_barrel_ec
Definition: LArCond2NtupleBase.h:72
LArFCAL_Base_ID::eta
int eta(const Identifier id) const
eta [0,63] module 1 ; [0,31] module 2 ; [0,15] module 3
CaloDetDescrElement::eta_raw
float eta_raw() const
cell eta_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:350
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:93
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
LArCond2NtupleBase::m_addHash
Gaudi::Property< bool > m_addHash
Definition: LArCond2NtupleBase.h:58
xAOD::EventInfo_v1::Error
@ Error
The sub-detector issued an error.
Definition: EventInfo_v1.h:349
LArLATOMEHeader::L1Id
uint32_t L1Id() const
get the L1 Id
Definition: LArLATOMEHeader.h:44
LArSC2Ntuple::m_saturVec_ET
NTuple::Array< bool > m_saturVec_ET
Definition: LArSC2Ntuple.h:74
LArCond2NtupleBase::m_febHash
NTuple::Item< long > m_febHash
Definition: LArCond2NtupleBase.h:75
LArSC2Ntuple::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: LArSC2Ntuple.h:46
LArDigits2Ntuple::m_event
long m_event
Definition: LArDigits2Ntuple.h:27
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
LArSC2Ntuple::m_saturVec_ET_ID
NTuple::Array< bool > m_saturVec_ET_ID
Definition: LArSC2Ntuple.h:78
LArFCAL_Base_ID::phi
int phi(const Identifier id) const
phi [0,15]
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
LArDigits2Ntuple::m_FTlist
Gaudi::Property< std::vector< unsigned int > > m_FTlist
Definition: LArDigits2Ntuple.h:30
LArCond2NtupleBase::NOT_VALID
@ NOT_VALID
Definition: LArCond2NtupleBase.h:63
LArCond2NtupleBase::m_region
NTuple::Item< long > m_region
Definition: LArCond2NtupleBase.h:71
LArSC2Ntuple::m_TTEhad
NTuple::Array< int > m_TTEhad
Definition: LArSC2Ntuple.h:86
LArDigits2Ntuple::m_bcid
NTuple::Item< short > m_bcid
Definition: LArDigits2Ntuple.h:39
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
LArSC2Ntuple::m_TTEem
NTuple::Array< int > m_TTEem
Definition: LArSC2Ntuple.h:85
AthCommonDataStore
Definition: AthCommonDataStore.h:52
LArCond2NtupleBase::m_addBC
Gaudi::Property< bool > m_addBC
Definition: LArCond2NtupleBase.h:53
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
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.
LArSC2Ntuple::m_bcidVec_ET_ID
NTuple::Array< unsigned short > m_bcidVec_ET_ID
Definition: LArSC2Ntuple.h:77
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
lumiFormat.i
int i
Definition: lumiFormat.py:92
LArSC2Ntuple::m_latomeSourceId
NTuple::Item< uint32_t > m_latomeSourceId
Definition: LArSC2Ntuple.h:68
LArRawChannel
Liquid Argon ROD output object base class.
Definition: LArRawChannel.h:40
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
LArCond2NtupleBase::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArCond2NtupleBase.h:89
LArSC2Ntuple::m_LArEventBits
NTuple::Item< uint32_t > m_LArEventBits
Definition: LArSC2Ntuple.h:81
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArCond2NtupleBase::m_FEBTemp1
NTuple::Item< float > m_FEBTemp1
Definition: LArCond2NtupleBase.h:78
LArCond2NtupleBase::m_caloSuperCellMgrKey
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager > m_caloSuperCellMgrKey
Definition: LArCond2NtupleBase.h:97
LArCond2NtupleBase::m_ntpath
std::string m_ntpath
Definition: LArCond2NtupleBase.h:65
LArSC2Ntuple::m_fillRawChan
Gaudi::Property< bool > m_fillRawChan
Definition: LArSC2Ntuple.h:37
LArCond2NtupleBase::m_calibMapKey
SG::ReadCondHandleKey< LArCalibLineMapping > m_calibMapKey
Definition: LArCond2NtupleBase.h:93
LArSC2Ntuple::m_fillTType
Gaudi::Property< bool > m_fillTType
Definition: LArSC2Ntuple.h:38
LArCond2NtupleBase::m_BCKey
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey
Definition: LArCond2NtupleBase.h:92
LArCond2NtupleBase::m_nt
NTuple::Tuple * m_nt
Definition: LArCond2NtupleBase.h:68
LArRawSC::chan
short chan() const
Definition: LArRawSC.h:92
LArOnlineID_Base::pos_neg
int pos_neg(const HWIdentifier id) const
Return the side of a hardware cell identifier pos_neg = [0,1] positive-side or negative-side Barrel...
Definition: LArOnlineID_Base.cxx: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:47
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
AtlasDetectorID::is_lar_hec
bool is_lar_hec(Identifier id) const
Definition: AtlasDetectorID.h:829
LArSC2Ntuple::m_trigDec
ToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: LArSC2Ntuple.h:44
LArCond2NtupleBase::m_expandId
Gaudi::Property< bool > m_expandId
Definition: LArCond2NtupleBase.h:61
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
LArSC2Ntuple::m_latomeChannel
NTuple::Item< short > m_latomeChannel
Definition: LArSC2Ntuple.h:52
LArSCDigit::Channel
short Channel() const
Definition: LArSCDigit.h:42
LArSC2Ntuple::m_energyVec_ET
NTuple::Array< int > m_energyVec_ET
Definition: LArSC2Ntuple.h:72
LArSC2Ntuple::m_overwriteEventNumber
Gaudi::Property< bool > m_overwriteEventNumber
Definition: LArSC2Ntuple.h:35
LArSC2Ntuple::m_TType
NTuple::Item< unsigned int > m_TType
Definition: LArSC2Ntuple.h:58
DataVector< LVL1::TriggerTower >
LArSC2Ntuple::m_bcidVec_ET
NTuple::Array< unsigned short > m_bcidVec_ET
Definition: LArSC2Ntuple.h:73
LArSC2Ntuple::fillRODEnergy
void fillRODEnergy(HWIdentifier SCId, rawChanMap_t &rawChanMap, const LArOnOffIdMapping *cabling, const LArOnOffIdMapping *cablingROD)
Definition: LArSC2Ntuple.cxx:626
LArDigits2Ntuple::m_ipass
int m_ipass
Definition: LArDigits2Ntuple.h:26
LArOnOffIdMapping::createSignalChannelID
HWIdentifier createSignalChannelID(const Identifier &id) const
create a HWIdentifier from an Identifier (not inline)
Definition: LArOnOffIdMapping.h:126
LArSC2Ntuple::m_contKeys
Gaudi::Property< std::vector< std::string > > m_contKeys
Definition: LArSC2Ntuple.h:34
LArSCDigit
Base class for LArDigits taken by LATOME.
Definition: LArSCDigit.h:19
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:56
LArSC2Ntuple::m_triggerTowerKey
Gaudi::Property< std::string > m_triggerTowerKey
Definition: LArSC2Ntuple.h:50
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
LArSC2Ntuple::m_ntNTT
NTuple::Item< uint32_t > m_ntNTT
Definition: LArSC2Ntuple.h:84
LArCond2NtupleBase::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: LArCond2NtupleBase.h:96
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
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:50
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArSC2Ntuple::m_ROD_energy
NTuple::Array< float > m_ROD_energy
Definition: LArSC2Ntuple.h:54
LArCond2NtupleBase::m_onlineId
const LArOnlineID_Base * m_onlineId
Definition: LArCond2NtupleBase.h:85
LArCond2NtupleBase::m_oflChanId
NTuple::Item< long > m_oflChanId
Definition: LArCond2NtupleBase.h:71
LArCond2NtupleBase::m_realgeom
Gaudi::Property< bool > m_realgeom
Definition: LArCond2NtupleBase.h:60
LArRawSC::bcids
const std::vector< unsigned short > & bcids() const
Definition: LArRawSC.h:104
LArSC2Ntuple::m_scidtool
ToolHandle< ICaloSuperCellIDTool > m_scidtool
Definition: LArSC2Ntuple.h:43
LArCond2NtupleBase::fillFromIdentifier
bool fillFromIdentifier(const HWIdentifier &id)
Definition: LArCond2NtupleBase.cxx:288
xAOD::EventInfo_v1::Warning
@ Warning
The sub-detector issued a warning.
Definition: EventInfo_v1.h:348
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
LArLATOMEHeader
Holds information from the LATOME Header.
Definition: LArLATOMEHeader.h:19
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx: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:111
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LArCond2NtupleBase::m_reta
NTuple::Item< float > m_reta
Definition: LArCond2NtupleBase.h:77
LArHEC_Base_ID::sampling
int sampling(const Identifier id) const
return sampling [0,3] (only 0 for supercells)
LArCond2NtupleBase::m_isSC
Gaudi::Property< bool > m_isSC
Definition: LArCond2NtupleBase.h:55
LArDigits2Ntuple::m_samples
NTuple::Array< short > m_samples
Definition: LArDigits2Ntuple.h:42
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
LArSC2Ntuple::m_Net
Gaudi::Property< unsigned int > m_Net
Definition: LArSC2Ntuple.h:36
LArSC2Ntuple::m_bcidVec_ADC_BAS
NTuple::Array< unsigned short > m_bcidVec_ADC_BAS
Definition: LArSC2Ntuple.h:70
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
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
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
LArHEC_Base_ID::region
int region(const Identifier id) const
return region [0,1]
python.compressB64.c
def c
Definition: compressB64.py:93
LArSCDigit::BCId
const std::vector< unsigned short > & BCId() const
Definition: LArSCDigit.h:48
AtlasDetectorID::is_lar_em
bool is_lar_em(Identifier id) const
Definition: AtlasDetectorID.h:818
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
LArSC2Ntuple::m_LArInError
NTuple::Item< short > m_LArInError
Definition: LArSC2Ntuple.h:82
LArCond2NtupleBase::m_FT
NTuple::Item< long > m_FT
Definition: LArCond2NtupleBase.h:72
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LArDigits2Ntuple::m_LB
NTuple::Item< short > m_LB
Definition: LArDigits2Ntuple.h:48
LArSC2Ntuple::m_TTeta
NTuple::Array< double > m_TTeta
Definition: LArSC2Ntuple.h:87
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
LArOnlineID_Base::feb_Hash
IdentifierHash feb_Hash(HWIdentifier febId) const
Create feb hash identifiers from feb identifiers.
Definition: LArOnlineID_Base.cxx: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:80
LArSC2Ntuple::m_fillCaloTT
Gaudi::Property< bool > m_fillCaloTT
Definition: LArSC2Ntuple.h:40
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
fitman.k
k
Definition: fitman.py:528
LArRawChannelContainer
Container for LArRawChannel (IDC using LArRawChannelCollection)
Definition: LArRawChannelContainer.h:26
CaloDetDescrElement::phi_raw
float phi_raw() const
cell phi_raw
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:352
LArHEC_Base_ID::phi
int phi(const Identifier id) const
return phi[0,63] outer part [0,31] inner part
ServiceHandle< ICondSvc >
LArOnOffIdMapping
Definition: LArOnOffIdMapping.h:20
LArCond2NtupleBase::m_channel
NTuple::Item< long > m_channel
Definition: LArCond2NtupleBase.h:72
LArRawSC::energies
const std::vector< int > & energies() const
Definition: LArRawSC.h:101
LArCond2NtupleBase::m_emId
const LArEM_Base_ID * m_emId
Definition: LArCond2NtupleBase.h:82
Generated on Tue Jul 2 2024 21:51:39 for ATLAS Offline Software by   doxygen 1.8.18