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

#include <CSC_RDOAnalysis.h>

Inheritance diagram for CSC_RDOAnalysis:
Collaboration diagram for CSC_RDOAnalysis:

Public Member Functions

 CSC_RDOAnalysis (const std::string &name, ISvcLocator *pSvcLocator)
 
 ~CSC_RDOAnalysis ()
 
virtual StatusCode initialize () override final
 
virtual StatusCode execute () override final
 
virtual StatusCode finalize () override final
 
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 Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvcStoreGateSvc_t
 

Private Member Functions

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

Private Attributes

SG::ReadHandleKey< CscRawDataContainerm_inputKey
 
SG::ReadHandleKey< CscSimDataCollectionm_inputTruthKey
 
std::vector< uint16_t > * m_collID
 
std::vector< uint16_t > * m_rodID
 
std::vector< uint16_t > * m_subID
 
std::vector< uint16_t > * m_collRpuID
 
std::vector< uint8_t > * m_dataType
 
std::vector< bool > * m_smplPhase
 
std::vector< bool > * m_trigType
 
std::vector< uint8_t > * m_firstBitSum
 
std::vector< uint32_t > * m_eventType
 
std::vector< uint8_t > * m_calAmp
 
std::vector< uint8_t > * m_calLayer
 
std::vector< uint32_t > * m_scaAdd
 
std::vector< uint16_t > * m_numSmpl
 
std::vector< uint16_t > * m_latency
 
std::vector< uint8_t > * m_rate
 
std::vector< bool > * m_sparse
 
std::vector< bool > * m_neutron
 
std::vector< bool > * m_calEn
 
std::vector< uint16_t > * m_spuCt
 
std::vector< uint16_t > * m_cscRpuID
 
std::vector< uint16_t > * m_cscID
 
std::vector< uint16_t > * m_cscTime
 
std::vector< uint16_t > * m_cscWidth
 
std::vector< bool > * m_cscTimeComp
 
std::vector< std::vector< uint16_t > > * m_cscSmpl
 
std::vector< uint32_t > * m_cscAdd
 
std::vector< uint32_t > * m_cscHashID
 
std::vector< unsigned long long > * m_sdoID
 
std::vector< int > * m_sdoWord
 
std::vector< int > * m_barcode
 
std::vector< int > * m_eventIndex
 
std::vector< float > * m_energy
 
std::vector< float > * m_ypos
 
std::vector< float > * m_zpos
 
std::vector< float > * m_charge
 
std::vector< std::vector< int > > * m_barcode_vec
 
std::vector< std::vector< int > > * m_eventIndex_vec
 
std::vector< std::vector< float > > * m_energy_vec
 
std::vector< std::vector< float > > * m_ypos_vec
 
std::vector< std::vector< float > > * m_zpos_vec
 
std::vector< std::vector< float > > * m_charge_vec
 
TH1 * m_h_collID
 
TH1 * m_h_rodID
 
TH1 * m_h_subID
 
TH1 * m_h_collRpuID
 
TH1 * m_h_dataType
 
TH1 * m_h_spuCt
 
TH1 * m_h_cscRpuID
 
TH1 * m_h_cscID
 
TH1 * m_h_cscTime
 
TH1 * m_h_cscWidth
 
TH1 * m_h_cscSmpl
 
TH1 * m_h_cscAdd
 
TH1 * m_h_cscHashID
 
TH1 * m_h_sdoID
 
TH1 * m_h_sdoWord
 
TH1 * m_h_barcode
 
TH1 * m_h_eventIndex
 
TH1 * m_h_energy
 
TH1 * m_h_ypos
 
TH1 * m_h_zpos
 
TH1 * m_h_charge
 
TTree * m_tree
 
std::string m_ntupleFileName
 
std::string m_ntupleDirName
 
std::string m_ntupleTreeName
 
std::string m_path
 
ServiceHandle< ITHistSvc > m_thistSvc
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 24 of file CSC_RDOAnalysis.h.

Member Typedef Documentation

◆ StoreGateSvc_t

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

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CSC_RDOAnalysis()

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

Definition at line 17 of file CSC_RDOAnalysis.cxx.

18  : AthAlgorithm(name, pSvcLocator)
19  , m_inputKey("CSCRDO")
20  , m_inputTruthKey("CSC_SDO")
21  , m_collID(0)
22  , m_rodID(0)
23  , m_subID(0)
24  , m_collRpuID(0)
25  , m_dataType(0)
26  , m_smplPhase(0)
27  , m_trigType(0)
28  , m_firstBitSum(0)
29  , m_eventType(0)
30  , m_calAmp(0)
31  , m_calLayer(0)
32  , m_scaAdd(0)
33  , m_numSmpl(0)
34  , m_latency(0)
35  , m_rate(0)
36  , m_sparse(0)
37  , m_neutron(0)
38  , m_calEn(0)
39  , m_spuCt(0)
40  , m_cscRpuID(0)
41  , m_cscID(0)
42  , m_cscTime(0)
43  , m_cscWidth(0)
44  , m_cscTimeComp(0)
45  , m_cscSmpl(0)
46  , m_cscAdd(0)
47  , m_cscHashID(0)
48  , m_sdoID(0)
49  , m_sdoWord(0)
50  , m_barcode(0)
51  , m_eventIndex(0)
52  , m_energy(0)
53  , m_ypos(0)
54  , m_zpos(0)
55  , m_charge(0)
56  , m_barcode_vec(0)
57  , m_eventIndex_vec(0)
58  , m_energy_vec(0)
59  , m_ypos_vec(0)
60  , m_zpos_vec(0)
61  , m_charge_vec(0)
62 
63  , m_h_collID(0)
64  , m_h_rodID(0)
65  , m_h_subID(0)
66  , m_h_collRpuID(0)
67  , m_h_dataType(0)
68  , m_h_spuCt(0)
69  , m_h_cscRpuID(0)
70  , m_h_cscID(0)
71  , m_h_cscTime(0)
72  , m_h_cscWidth(0)
73  , m_h_cscSmpl(0)
74  , m_h_cscAdd(0)
75  , m_h_cscHashID(0)
76  , m_h_sdoID(0)
77  , m_h_sdoWord(0)
78  , m_h_barcode(0)
79  , m_h_eventIndex(0)
80  , m_h_energy(0)
81  , m_h_ypos(0)
82  , m_h_zpos(0)
83  , m_h_charge(0)
84 
85  , m_tree(0)
86  , m_ntupleFileName("/ntuples/file1")
87  , m_ntupleDirName("/CSC_RDOAnalysis/")
88  , m_ntupleTreeName("CSC_RDOAna")
89  , m_path("/CSC_RDOAnalysis/")
90  , m_thistSvc("THistSvc", name)
91 {
92  declareProperty("InputKey", m_inputKey);
93  declareProperty("InputTruthKey", m_inputTruthKey);
94  declareProperty("NtupleFileName", m_ntupleFileName);
95  declareProperty("NtupleDirectoryName", m_ntupleDirName);
96  declareProperty("NtupleTreeName", m_ntupleTreeName);
97  declareProperty("HistPath", m_path);
98 }

◆ ~CSC_RDOAnalysis()

CSC_RDOAnalysis::~CSC_RDOAnalysis ( )
inline

Definition at line 28 of file CSC_RDOAnalysis.h.

28 {}

Member Function Documentation

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode CSC_RDOAnalysis::execute ( )
finaloverridevirtual

Definition at line 249 of file CSC_RDOAnalysis.cxx.

249  {
250  ATH_MSG_DEBUG( "In CSC_RDOAnalysis::execute()" );
251 
252  m_collID->clear();
253  m_rodID->clear();
254  m_subID->clear();
255  m_collRpuID->clear();
256  m_dataType->clear();
257  m_smplPhase->clear();
258  m_trigType->clear();
259  m_firstBitSum->clear();
260  m_eventType->clear();
261  m_calAmp->clear();
262  m_calLayer->clear();
263  m_scaAdd->clear();
264  m_numSmpl->clear();
265  m_latency->clear();
266  m_rate->clear();
267  m_sparse->clear();
268  m_neutron->clear();
269  m_calEn->clear();
270  m_spuCt->clear();
271  m_cscRpuID->clear();
272  m_cscID->clear();
273  m_cscTime->clear();
274  m_cscWidth->clear();
275  m_cscTimeComp->clear();
276  m_cscSmpl->clear();
277  m_cscAdd->clear();
278  m_cscHashID->clear();
279  m_sdoID->clear();
280  m_sdoWord->clear();
281  m_barcode->clear();
282  m_eventIndex->clear();
283  m_energy->clear();
284  m_ypos->clear();
285  m_zpos->clear();
286  m_charge->clear();
287  m_barcode_vec->clear();
288  m_eventIndex_vec->clear();
289  m_energy_vec->clear();
290  m_ypos_vec->clear();
291  m_zpos_vec->clear();
292  m_charge_vec->clear();
293 
295  if(p_CSCcont.isValid()) {
296  CscRawDataContainer::const_iterator cscCont_itr(p_CSCcont->begin());
297  const CscRawDataContainer::const_iterator cscCont_end(p_CSCcont->end());
298 
299  for ( ; cscCont_itr != cscCont_end; ++cscCont_itr ) {
300 
301  const uint16_t collID((*cscCont_itr)->identify());
302  const uint16_t rodID((*cscCont_itr)->rodId());
303  const uint16_t subID((*cscCont_itr)->subDetectorId());
304  const std::vector<uint16_t>& collRpuID = (*cscCont_itr)->rpuID();
305  const std::vector<uint8_t>& dataType = (*cscCont_itr)->dataType();
306 
307  m_collID->push_back(collID);
308  m_rodID->push_back(rodID);
309  m_subID->push_back(subID);
310 
311  for (std::vector<uint16_t>::size_type i = 0; i != collRpuID.size(); ++i) {
312  m_collRpuID->push_back(collRpuID.at(i));
313  m_h_collRpuID->Fill(collRpuID.at(i));
314  }
315  for (std::vector<uint8_t>::size_type j = 0; j != dataType.size(); ++j) {
316  m_dataType->push_back(dataType.at(j));
317  m_h_dataType->Fill(dataType.at(j));
318  }
319 
320  m_smplPhase->push_back((*cscCont_itr)->samplingPhase());
321  m_trigType->push_back((*cscCont_itr)->triggerType());
322  m_firstBitSum->push_back((*cscCont_itr)->firstBitSummary());
323  m_eventType->push_back((*cscCont_itr)->eventType());
324  m_calAmp->push_back((*cscCont_itr)->calAmplitude());
325  m_calLayer->push_back((*cscCont_itr)->calLayer());
326  m_scaAdd->push_back((*cscCont_itr)->scaAddress());
327  m_numSmpl->push_back((*cscCont_itr)->numSamples());
328  m_latency->push_back((*cscCont_itr)->latency());
329  m_rate->push_back((*cscCont_itr)->rate());
330  m_sparse->push_back((*cscCont_itr)->sparsified());
331  m_neutron->push_back((*cscCont_itr)->neutron());
332  m_calEn->push_back((*cscCont_itr)->calEnabled());
333 
334  for (unsigned int k = 0; k != 10; ++k) {
335  m_spuCt->push_back((*cscCont_itr)->spuCount(k));
336  m_h_spuCt->Fill((*cscCont_itr)->spuCount(k));
337  }
338 
339  m_h_collID->Fill(collID);
340  m_h_rodID->Fill(rodID);
341  m_h_subID->Fill(subID);
342 
343  const CscRawDataCollection* p_CSCcoll(*cscCont_itr);
344  CscRawDataCollection::const_iterator csc_itr(p_CSCcoll->begin());
345  const CscRawDataCollection::const_iterator csc_end(p_CSCcoll->end());
346  for ( ; csc_itr != csc_end; ++csc_itr ) {
347 
348  const uint16_t cscRpuID((*csc_itr)->rpuID());
349  const uint16_t cscID((*csc_itr)->identify());
350  const uint16_t cscTime((*csc_itr)->time());
351  const uint16_t cscWidth((*csc_itr)->width());
352  const bool cscTimeComp((*csc_itr)->isTimeComputed());
353  const std::vector<uint16_t> cscSmpl_vec((*csc_itr)->samples());
354  const uint32_t cscAdd((*csc_itr)->address());
355  const uint32_t cscHashID((*csc_itr)->hashId());
356 
357  m_cscRpuID->push_back(cscRpuID);
358  m_cscID->push_back(cscID);
359  m_cscTime->push_back(cscTime);
360  m_cscWidth->push_back(cscWidth);
361  m_cscTimeComp->push_back(cscTimeComp);
362  m_cscSmpl->push_back(cscSmpl_vec);
363  m_cscAdd->push_back(cscAdd);
364  m_cscHashID->push_back(cscHashID);
365 
366  m_h_cscRpuID->Fill(cscRpuID);
367  m_h_cscID->Fill(cscID);
368  m_h_cscTime->Fill(cscTime);
369  m_h_cscWidth->Fill(cscWidth);
370  for (std::vector<uint16_t>::size_type l = 0; l != cscSmpl_vec.size(); ++l) {
371  m_h_cscSmpl->Fill(cscSmpl_vec.at(l));
372  }
373  m_h_cscAdd->Fill(cscAdd);
374  m_h_cscHashID->Fill(cscHashID);
375  }
376  }
377  }
378 
379  // SimData
381  if(simDataMapCSC.isValid()) {
382  CscSimDataCollection::const_iterator sdo_itr(simDataMapCSC->begin());
383  const CscSimDataCollection::const_iterator sdo_end(simDataMapCSC->end());
384 
385  std::vector<int> barcode_vec;
386  std::vector<int> eventIndex_vec;
387  std::vector<float> energy_vec;
388  std::vector<float> ypos_vec;
389  std::vector<float> zpos_vec;
390  std::vector<float> charge_vec;
391  for ( ; sdo_itr != sdo_end; ++sdo_itr ) {
392  const Identifier sdoID((*sdo_itr).first);
393  const CscSimData& sdo((*sdo_itr).second);
394 
395  const unsigned long long sdoID_int = sdoID.get_compact();
396  const int sdoWord(sdo.word());
397 
398  m_sdoID->push_back(sdoID_int);
399  m_sdoWord->push_back(sdoWord);
400 
401  // loop over deposits
402  const std::vector<CscSimData::Deposit>& deposits = sdo.getdeposits();
403  std::vector<CscSimData::Deposit>::const_iterator dep_itr(deposits.begin());
404  const std::vector<CscSimData::Deposit>::const_iterator dep_end(deposits.end());
405  for ( ; dep_itr != dep_end; ++dep_itr ) {
406  const HepMcParticleLink& particleLink = (*dep_itr).first;
407  const int bar(HepMC::barcode(particleLink)); // FIXME barcode-based
408  const int eventIx(particleLink.eventIndex());
409  const CscMcData& data = (*dep_itr).second;
410  const float sdoEnergy(data.energy());
411  const float sdoYpos(data.ypos());
412  const float sdoZpos(data.zpos());
413  const float sdoCharge(data.charge());
414 
415  m_barcode->push_back(bar);
416  m_eventIndex->push_back(eventIx);
417  m_energy->push_back(sdoEnergy);
418  m_ypos->push_back(sdoYpos);
419  m_zpos->push_back(sdoZpos);
420  m_charge->push_back(sdoCharge);
421 
422  m_h_barcode->Fill(bar);
423  m_h_eventIndex->Fill(eventIx);
424  m_h_energy->Fill(sdoEnergy);
425  m_h_ypos->Fill(sdoYpos);
426  m_h_zpos->Fill(sdoZpos);
427  m_h_charge->Fill(sdoCharge);
428 
429  barcode_vec.push_back(bar);
430  eventIndex_vec.push_back(eventIx);
431  energy_vec.push_back(sdoEnergy);
432  ypos_vec.push_back(sdoYpos);
433  zpos_vec.push_back(sdoZpos);
434  charge_vec.push_back(sdoCharge);
435  }
436  m_barcode_vec->push_back(barcode_vec);
437  m_eventIndex_vec->push_back(eventIndex_vec);
438  m_energy_vec->push_back(energy_vec);
439  m_ypos_vec->push_back(ypos_vec);
440  m_zpos_vec->push_back(zpos_vec);
441  m_charge_vec->push_back(charge_vec);
442  barcode_vec.clear();
443  eventIndex_vec.clear();
444  energy_vec.clear();
445  ypos_vec.clear();
446  zpos_vec.clear();
447  charge_vec.clear();
448  }
449  }
450 
451  if (m_tree) {
452  m_tree->Fill();
453  }
454 
455  return StatusCode::SUCCESS;
456 }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

◆ finalize()

StatusCode CSC_RDOAnalysis::finalize ( )
finaloverridevirtual

Definition at line 458 of file CSC_RDOAnalysis.cxx.

458  {
459  return StatusCode::SUCCESS;
460 }

◆ initialize()

StatusCode CSC_RDOAnalysis::initialize ( )
finaloverridevirtual

Definition at line 100 of file CSC_RDOAnalysis.cxx.

100  {
101  ATH_MSG_DEBUG( "Initializing CSC_RDOAnalysis" );
102 
103  // This will check that the properties were initialized
104  // properly by job configuration.
107 
108  ATH_CHECK(m_thistSvc.retrieve());
109 
110  m_tree = new TTree(TString(m_ntupleTreeName), "CSC_RDOAna");
111  std::string fullNtupleName = m_ntupleFileName + m_ntupleDirName + m_ntupleTreeName;
112  ATH_CHECK(m_thistSvc->regTree(fullNtupleName, m_tree));
113  if (m_tree) {
114  m_tree->Branch("collID", &m_collID);
115  m_tree->Branch("rodID", &m_rodID);
116  m_tree->Branch("subID", &m_subID);
117  m_tree->Branch("collRpuID", &m_collRpuID);
118  m_tree->Branch("dataType", &m_dataType);
119  m_tree->Branch("smplPhase", &m_smplPhase);
120  m_tree->Branch("trigType", &m_trigType);
121  m_tree->Branch("firstBitSum", &m_firstBitSum);
122  m_tree->Branch("eventType", &m_eventType);
123  m_tree->Branch("calAmp", &m_calAmp);
124  m_tree->Branch("calLayer", &m_calLayer);
125  m_tree->Branch("scaAdd", &m_scaAdd);
126  m_tree->Branch("numSmpl", &m_numSmpl);
127  m_tree->Branch("latency", &m_latency);
128  m_tree->Branch("rate", &m_rate);
129  m_tree->Branch("sparse", &m_sparse);
130  m_tree->Branch("neutron", &m_neutron);
131  m_tree->Branch("calEn", &m_calEn);
132  m_tree->Branch("spuCt", &m_spuCt);
133  m_tree->Branch("cscRpuID", &m_cscRpuID);
134  m_tree->Branch("cscID", &m_cscID);
135  m_tree->Branch("cscTime", &m_cscTime);
136  m_tree->Branch("cscWidth", &m_cscWidth);
137  m_tree->Branch("cscTimeComp", &m_cscTimeComp);
138  m_tree->Branch("cscSmpl", &m_cscSmpl);
139  m_tree->Branch("cscAdd", &m_cscAdd);
140  m_tree->Branch("cscHashID", &m_cscHashID);
141  m_tree->Branch("sdoID", &m_sdoID);
142  m_tree->Branch("sdoWord", &m_sdoWord);
143  m_tree->Branch("barcode", &m_barcode);
144  m_tree->Branch("eventIndex", &m_eventIndex);
145  m_tree->Branch("energy", &m_energy);
146  m_tree->Branch("ypos", &m_ypos);
147  m_tree->Branch("zpos", &m_zpos);
148  m_tree->Branch("charge", &m_charge);
149  m_tree->Branch("barcode_vec", &m_barcode_vec);
150  m_tree->Branch("eventIndex_vec", &m_eventIndex_vec);
151  m_tree->Branch("energy_vec", &m_energy_vec);
152  m_tree->Branch("ypos_vec", &m_ypos_vec);
153  m_tree->Branch("zpos_vec", &m_zpos_vec);
154  m_tree->Branch("charge_vec", &m_charge_vec);
155  }
156  else {
157  ATH_MSG_ERROR("No tree found!");
158  }
159 
160  // HISTOGRAMS
161 
162  m_h_collID = new TH1F("h_collID", "Collection ID", 100, 0, 35);
163  m_h_collID->StatOverflows();
164  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_collID->GetName(), m_h_collID));
165 
166  m_h_rodID = new TH1F("h_rodID", "Collection ROD ID", 100, 0, 150);
167  m_h_rodID->StatOverflows();
168  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rodID->GetName(), m_h_rodID));
169 
170  m_h_subID = new TH1F("h_subID", "Collection Sub-Detector ID", 100, 0, 110);
171  m_h_subID->StatOverflows();
172  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_subID->GetName(), m_h_subID));
173 
174  m_h_collRpuID = new TH1F("h_collRpuID", "Collection RPU ID", 100, 0, 15);
175  m_h_collRpuID->StatOverflows();
176  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_collRpuID->GetName(), m_h_collRpuID));
177 
178  m_h_dataType = new TH1F("h_dataType", "Collection data type", 100, 0, 5);
179  m_h_dataType->StatOverflows();
180  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_dataType->GetName(), m_h_dataType));
181 
182  m_h_spuCt = new TH1F("h_spuCt", "Collection SPU count", 100, 0, 20);
183  m_h_spuCt->StatOverflows();
184  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_spuCt->GetName(), m_h_spuCt));
185 
186  m_h_cscRpuID = new TH1F("h_cscRpuID", "SPU ID of strip", 100, 0, 10);
187  m_h_cscRpuID->StatOverflows();
188  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_cscRpuID->GetName(), m_h_cscRpuID));
189 
190  m_h_cscID = new TH1F("h_cscID", "ID of strip collection", 100, 0, 35);
191  m_h_cscID->StatOverflows();
192  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_cscID->GetName(), m_h_cscID));
193 
194  m_h_cscTime = new TH1F("h_cscTime", "Time of first strip", 100, 0, 10);
195  m_h_cscTime->StatOverflows();
196  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_cscTime->GetName(), m_h_cscTime));
197 
198  m_h_cscWidth = new TH1F("h_cscWidth", "Width of strip cluster", 100, 0, 35);
199  m_h_cscWidth->StatOverflows();
200  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_cscWidth->GetName(), m_h_cscWidth));
201 
202  m_h_cscSmpl = new TH1F("h_cscSmpl", "ADC samples", 100, 0, 4500);
203  m_h_cscSmpl->StatOverflows();
204  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_cscSmpl->GetName(), m_h_cscSmpl));
205 
206  m_h_cscAdd = new TH1F("h_cscAdd", "ID of first strip", 100, 0, 1.5e5);
207  m_h_cscAdd->StatOverflows();
208  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_cscAdd->GetName(), m_h_cscAdd));
209 
210  m_h_cscHashID = new TH1F("h_cscHashID", "hash ID of strip collection", 100, 0, 65000);
211  m_h_cscHashID->StatOverflows();
212  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_cscHashID->GetName(), m_h_cscHashID));
213 
214  m_h_sdoID = new TH1F("h_sdoID", "sdoID", 100, 0, 1e19);
215  m_h_sdoID->StatOverflows();
216  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_sdoID->GetName(), m_h_sdoID));
217 
218  m_h_sdoWord = new TH1F("h_sdoWord", "sdoWord", 100, 0, 10);
219  m_h_sdoWord->StatOverflows();
220  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_sdoWord->GetName(), m_h_sdoWord));
221 
222  m_h_barcode= new TH1F("h_barcode", "Barcode (SDO)", 100, 0, 2.2e9);
223  m_h_barcode->StatOverflows();
224  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_barcode->GetName(), m_h_barcode));
225 
226  m_h_eventIndex = new TH1F("h_eventIndex", "Event index (SDO)", 100, 0, 1000);
227  m_h_eventIndex->StatOverflows();
228  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_eventIndex->GetName(), m_h_eventIndex));
229 
230  m_h_energy = new TH1F("h_energy", "Energy (SDO)", 100, 0, 0.3);
231  m_h_energy->StatOverflows();
232  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_energy->GetName(), m_h_energy));
233 
234  m_h_ypos = new TH1F("h_ypos", "y-position (SDO)", 100, -1e5, 1e5);
235  m_h_ypos->StatOverflows();
236  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_ypos->GetName(), m_h_ypos));
237 
238  m_h_zpos = new TH1F("h_zpos", "z-position (SDO)", 100, -1e5, 1e5);
239  m_h_zpos->StatOverflows();
240  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_zpos->GetName(), m_h_zpos));
241 
242  m_h_charge = new TH1F("h_charge", "Charge (SDO)", 100, 0, 1e5);
243  m_h_charge->StatOverflows();
244  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_charge->GetName(), m_h_charge));
245 
246  return StatusCode::SUCCESS;
247 }

◆ 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  {
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_barcode

std::vector<int>* CSC_RDOAnalysis::m_barcode
private

Definition at line 71 of file CSC_RDOAnalysis.h.

◆ m_barcode_vec

std::vector< std::vector<int> >* CSC_RDOAnalysis::m_barcode_vec
private

Definition at line 77 of file CSC_RDOAnalysis.h.

◆ m_calAmp

std::vector<uint8_t>* CSC_RDOAnalysis::m_calAmp
private

Definition at line 48 of file CSC_RDOAnalysis.h.

◆ m_calEn

std::vector<bool>* CSC_RDOAnalysis::m_calEn
private

Definition at line 56 of file CSC_RDOAnalysis.h.

◆ m_calLayer

std::vector<uint8_t>* CSC_RDOAnalysis::m_calLayer
private

Definition at line 49 of file CSC_RDOAnalysis.h.

◆ m_charge

std::vector<float>* CSC_RDOAnalysis::m_charge
private

Definition at line 76 of file CSC_RDOAnalysis.h.

◆ m_charge_vec

std::vector< std::vector<float> >* CSC_RDOAnalysis::m_charge_vec
private

Definition at line 82 of file CSC_RDOAnalysis.h.

◆ m_collID

std::vector<uint16_t>* CSC_RDOAnalysis::m_collID
private

Definition at line 39 of file CSC_RDOAnalysis.h.

◆ m_collRpuID

std::vector<uint16_t>* CSC_RDOAnalysis::m_collRpuID
private

Definition at line 42 of file CSC_RDOAnalysis.h.

◆ m_cscAdd

std::vector<uint32_t>* CSC_RDOAnalysis::m_cscAdd
private

Definition at line 65 of file CSC_RDOAnalysis.h.

◆ m_cscHashID

std::vector<uint32_t>* CSC_RDOAnalysis::m_cscHashID
private

Definition at line 66 of file CSC_RDOAnalysis.h.

◆ m_cscID

std::vector<uint16_t>* CSC_RDOAnalysis::m_cscID
private

Definition at line 60 of file CSC_RDOAnalysis.h.

◆ m_cscRpuID

std::vector<uint16_t>* CSC_RDOAnalysis::m_cscRpuID
private

Definition at line 59 of file CSC_RDOAnalysis.h.

◆ m_cscSmpl

std::vector< std::vector<uint16_t> >* CSC_RDOAnalysis::m_cscSmpl
private

Definition at line 64 of file CSC_RDOAnalysis.h.

◆ m_cscTime

std::vector<uint16_t>* CSC_RDOAnalysis::m_cscTime
private

Definition at line 61 of file CSC_RDOAnalysis.h.

◆ m_cscTimeComp

std::vector<bool>* CSC_RDOAnalysis::m_cscTimeComp
private

Definition at line 63 of file CSC_RDOAnalysis.h.

◆ m_cscWidth

std::vector<uint16_t>* CSC_RDOAnalysis::m_cscWidth
private

Definition at line 62 of file CSC_RDOAnalysis.h.

◆ m_dataType

std::vector<uint8_t>* CSC_RDOAnalysis::m_dataType
private

Definition at line 43 of file CSC_RDOAnalysis.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_energy

std::vector<float>* CSC_RDOAnalysis::m_energy
private

Definition at line 73 of file CSC_RDOAnalysis.h.

◆ m_energy_vec

std::vector< std::vector<float> >* CSC_RDOAnalysis::m_energy_vec
private

Definition at line 79 of file CSC_RDOAnalysis.h.

◆ m_eventIndex

std::vector<int>* CSC_RDOAnalysis::m_eventIndex
private

Definition at line 72 of file CSC_RDOAnalysis.h.

◆ m_eventIndex_vec

std::vector< std::vector<int> >* CSC_RDOAnalysis::m_eventIndex_vec
private

Definition at line 78 of file CSC_RDOAnalysis.h.

◆ m_eventType

std::vector<uint32_t>* CSC_RDOAnalysis::m_eventType
private

Definition at line 47 of file CSC_RDOAnalysis.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_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_firstBitSum

std::vector<uint8_t>* CSC_RDOAnalysis::m_firstBitSum
private

Definition at line 46 of file CSC_RDOAnalysis.h.

◆ m_h_barcode

TH1* CSC_RDOAnalysis::m_h_barcode
private

Definition at line 100 of file CSC_RDOAnalysis.h.

◆ m_h_charge

TH1* CSC_RDOAnalysis::m_h_charge
private

Definition at line 105 of file CSC_RDOAnalysis.h.

◆ m_h_collID

TH1* CSC_RDOAnalysis::m_h_collID
private

Definition at line 84 of file CSC_RDOAnalysis.h.

◆ m_h_collRpuID

TH1* CSC_RDOAnalysis::m_h_collRpuID
private

Definition at line 87 of file CSC_RDOAnalysis.h.

◆ m_h_cscAdd

TH1* CSC_RDOAnalysis::m_h_cscAdd
private

Definition at line 95 of file CSC_RDOAnalysis.h.

◆ m_h_cscHashID

TH1* CSC_RDOAnalysis::m_h_cscHashID
private

Definition at line 96 of file CSC_RDOAnalysis.h.

◆ m_h_cscID

TH1* CSC_RDOAnalysis::m_h_cscID
private

Definition at line 91 of file CSC_RDOAnalysis.h.

◆ m_h_cscRpuID

TH1* CSC_RDOAnalysis::m_h_cscRpuID
private

Definition at line 90 of file CSC_RDOAnalysis.h.

◆ m_h_cscSmpl

TH1* CSC_RDOAnalysis::m_h_cscSmpl
private

Definition at line 94 of file CSC_RDOAnalysis.h.

◆ m_h_cscTime

TH1* CSC_RDOAnalysis::m_h_cscTime
private

Definition at line 92 of file CSC_RDOAnalysis.h.

◆ m_h_cscWidth

TH1* CSC_RDOAnalysis::m_h_cscWidth
private

Definition at line 93 of file CSC_RDOAnalysis.h.

◆ m_h_dataType

TH1* CSC_RDOAnalysis::m_h_dataType
private

Definition at line 88 of file CSC_RDOAnalysis.h.

◆ m_h_energy

TH1* CSC_RDOAnalysis::m_h_energy
private

Definition at line 102 of file CSC_RDOAnalysis.h.

◆ m_h_eventIndex

TH1* CSC_RDOAnalysis::m_h_eventIndex
private

Definition at line 101 of file CSC_RDOAnalysis.h.

◆ m_h_rodID

TH1* CSC_RDOAnalysis::m_h_rodID
private

Definition at line 85 of file CSC_RDOAnalysis.h.

◆ m_h_sdoID

TH1* CSC_RDOAnalysis::m_h_sdoID
private

Definition at line 98 of file CSC_RDOAnalysis.h.

◆ m_h_sdoWord

TH1* CSC_RDOAnalysis::m_h_sdoWord
private

Definition at line 99 of file CSC_RDOAnalysis.h.

◆ m_h_spuCt

TH1* CSC_RDOAnalysis::m_h_spuCt
private

Definition at line 89 of file CSC_RDOAnalysis.h.

◆ m_h_subID

TH1* CSC_RDOAnalysis::m_h_subID
private

Definition at line 86 of file CSC_RDOAnalysis.h.

◆ m_h_ypos

TH1* CSC_RDOAnalysis::m_h_ypos
private

Definition at line 103 of file CSC_RDOAnalysis.h.

◆ m_h_zpos

TH1* CSC_RDOAnalysis::m_h_zpos
private

Definition at line 104 of file CSC_RDOAnalysis.h.

◆ m_inputKey

SG::ReadHandleKey<CscRawDataContainer> CSC_RDOAnalysis::m_inputKey
private

Definition at line 35 of file CSC_RDOAnalysis.h.

◆ m_inputTruthKey

SG::ReadHandleKey<CscSimDataCollection> CSC_RDOAnalysis::m_inputTruthKey
private

Definition at line 36 of file CSC_RDOAnalysis.h.

◆ m_latency

std::vector<uint16_t>* CSC_RDOAnalysis::m_latency
private

Definition at line 52 of file CSC_RDOAnalysis.h.

◆ m_neutron

std::vector<bool>* CSC_RDOAnalysis::m_neutron
private

Definition at line 55 of file CSC_RDOAnalysis.h.

◆ m_ntupleDirName

std::string CSC_RDOAnalysis::m_ntupleDirName
private

Definition at line 109 of file CSC_RDOAnalysis.h.

◆ m_ntupleFileName

std::string CSC_RDOAnalysis::m_ntupleFileName
private

Definition at line 108 of file CSC_RDOAnalysis.h.

◆ m_ntupleTreeName

std::string CSC_RDOAnalysis::m_ntupleTreeName
private

Definition at line 110 of file CSC_RDOAnalysis.h.

◆ m_numSmpl

std::vector<uint16_t>* CSC_RDOAnalysis::m_numSmpl
private

Definition at line 51 of file CSC_RDOAnalysis.h.

◆ m_path

std::string CSC_RDOAnalysis::m_path
private

Definition at line 111 of file CSC_RDOAnalysis.h.

◆ m_rate

std::vector<uint8_t>* CSC_RDOAnalysis::m_rate
private

Definition at line 53 of file CSC_RDOAnalysis.h.

◆ m_rodID

std::vector<uint16_t>* CSC_RDOAnalysis::m_rodID
private

Definition at line 40 of file CSC_RDOAnalysis.h.

◆ m_scaAdd

std::vector<uint32_t>* CSC_RDOAnalysis::m_scaAdd
private

Definition at line 50 of file CSC_RDOAnalysis.h.

◆ m_sdoID

std::vector<unsigned long long>* CSC_RDOAnalysis::m_sdoID
private

Definition at line 69 of file CSC_RDOAnalysis.h.

◆ m_sdoWord

std::vector<int>* CSC_RDOAnalysis::m_sdoWord
private

Definition at line 70 of file CSC_RDOAnalysis.h.

◆ m_smplPhase

std::vector<bool>* CSC_RDOAnalysis::m_smplPhase
private

Definition at line 44 of file CSC_RDOAnalysis.h.

◆ m_sparse

std::vector<bool>* CSC_RDOAnalysis::m_sparse
private

Definition at line 54 of file CSC_RDOAnalysis.h.

◆ m_spuCt

std::vector<uint16_t>* CSC_RDOAnalysis::m_spuCt
private

Definition at line 57 of file CSC_RDOAnalysis.h.

◆ m_subID

std::vector<uint16_t>* CSC_RDOAnalysis::m_subID
private

Definition at line 41 of file CSC_RDOAnalysis.h.

◆ m_thistSvc

ServiceHandle<ITHistSvc> CSC_RDOAnalysis::m_thistSvc
private

Definition at line 112 of file CSC_RDOAnalysis.h.

◆ m_tree

TTree* CSC_RDOAnalysis::m_tree
private

Definition at line 107 of file CSC_RDOAnalysis.h.

◆ m_trigType

std::vector<bool>* CSC_RDOAnalysis::m_trigType
private

Definition at line 45 of file CSC_RDOAnalysis.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.

◆ m_ypos

std::vector<float>* CSC_RDOAnalysis::m_ypos
private

Definition at line 74 of file CSC_RDOAnalysis.h.

◆ m_ypos_vec

std::vector< std::vector<float> >* CSC_RDOAnalysis::m_ypos_vec
private

Definition at line 80 of file CSC_RDOAnalysis.h.

◆ m_zpos

std::vector<float>* CSC_RDOAnalysis::m_zpos
private

Definition at line 75 of file CSC_RDOAnalysis.h.

◆ m_zpos_vec

std::vector< std::vector<float> >* CSC_RDOAnalysis::m_zpos_vec
private

Definition at line 81 of file CSC_RDOAnalysis.h.


The documentation for this class was generated from the following files:
CSC_RDOAnalysis::m_charge_vec
std::vector< std::vector< float > > * m_charge_vec
Definition: CSC_RDOAnalysis.h:82
CSC_RDOAnalysis::m_h_cscSmpl
TH1 * m_h_cscSmpl
Definition: CSC_RDOAnalysis.h:94
CSC_RDOAnalysis::m_h_charge
TH1 * m_h_charge
Definition: CSC_RDOAnalysis.h:105
data
char data[hepevt_bytes_allocation_ATLAS]
Definition: HepEvt.cxx:11
CSC_RDOAnalysis::m_scaAdd
std::vector< uint32_t > * m_scaAdd
Definition: CSC_RDOAnalysis.h:50
CSC_RDOAnalysis::m_h_collID
TH1 * m_h_collID
Definition: CSC_RDOAnalysis.h:84
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
CSC_RDOAnalysis::m_cscSmpl
std::vector< std::vector< uint16_t > > * m_cscSmpl
Definition: CSC_RDOAnalysis.h:64
CSC_RDOAnalysis::m_trigType
std::vector< bool > * m_trigType
Definition: CSC_RDOAnalysis.h:45
CSC_RDOAnalysis::m_sdoID
std::vector< unsigned long long > * m_sdoID
Definition: CSC_RDOAnalysis.h:69
CSC_RDOAnalysis::m_h_rodID
TH1 * m_h_rodID
Definition: CSC_RDOAnalysis.h:85
CSC_RDOAnalysis::m_h_dataType
TH1 * m_h_dataType
Definition: CSC_RDOAnalysis.h:88
CSC_RDOAnalysis::m_sparse
std::vector< bool > * m_sparse
Definition: CSC_RDOAnalysis.h:54
CSC_RDOAnalysis::m_zpos
std::vector< float > * m_zpos
Definition: CSC_RDOAnalysis.h:75
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
CSC_RDOAnalysis::m_collRpuID
std::vector< uint16_t > * m_collRpuID
Definition: CSC_RDOAnalysis.h:42
CSC_RDOAnalysis::m_rate
std::vector< uint8_t > * m_rate
Definition: CSC_RDOAnalysis.h:53
CSC_RDOAnalysis::m_cscRpuID
std::vector< uint16_t > * m_cscRpuID
Definition: CSC_RDOAnalysis.h:59
CSC_RDOAnalysis::m_smplPhase
std::vector< bool > * m_smplPhase
Definition: CSC_RDOAnalysis.h:44
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
downloadSingle.dataType
string dataType
Definition: downloadSingle.py:18
CSC_RDOAnalysis::m_eventType
std::vector< uint32_t > * m_eventType
Definition: CSC_RDOAnalysis.h:47
CSC_RDOAnalysis::m_eventIndex_vec
std::vector< std::vector< int > > * m_eventIndex_vec
Definition: CSC_RDOAnalysis.h:78
CSC_RDOAnalysis::m_path
std::string m_path
Definition: CSC_RDOAnalysis.h:111
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
CSC_RDOAnalysis::m_cscHashID
std::vector< uint32_t > * m_cscHashID
Definition: CSC_RDOAnalysis.h:66
CSC_RDOAnalysis::m_cscTimeComp
std::vector< bool > * m_cscTimeComp
Definition: CSC_RDOAnalysis.h:63
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
CscMcData
Definition: CscSimData.h:23
CSC_RDOAnalysis::m_h_spuCt
TH1 * m_h_spuCt
Definition: CSC_RDOAnalysis.h:89
CSC_RDOAnalysis::m_ntupleFileName
std::string m_ntupleFileName
Definition: CSC_RDOAnalysis.h:108
CSC_RDOAnalysis::m_inputTruthKey
SG::ReadHandleKey< CscSimDataCollection > m_inputTruthKey
Definition: CSC_RDOAnalysis.h:36
CSC_RDOAnalysis::m_barcode_vec
std::vector< std::vector< int > > * m_barcode_vec
Definition: CSC_RDOAnalysis.h:77
CSC_RDOAnalysis::m_h_barcode
TH1 * m_h_barcode
Definition: CSC_RDOAnalysis.h:100
CSC_RDOAnalysis::m_zpos_vec
std::vector< std::vector< float > > * m_zpos_vec
Definition: CSC_RDOAnalysis.h:81
CSC_RDOAnalysis::m_cscTime
std::vector< uint16_t > * m_cscTime
Definition: CSC_RDOAnalysis.h:61
CSC_RDOAnalysis::m_eventIndex
std::vector< int > * m_eventIndex
Definition: CSC_RDOAnalysis.h:72
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
CSC_RDOAnalysis::m_cscWidth
std::vector< uint16_t > * m_cscWidth
Definition: CSC_RDOAnalysis.h:62
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
CSC_RDOAnalysis::m_cscAdd
std::vector< uint32_t > * m_cscAdd
Definition: CSC_RDOAnalysis.h:65
CSC_RDOAnalysis::m_ypos_vec
std::vector< std::vector< float > > * m_ypos_vec
Definition: CSC_RDOAnalysis.h:80
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
CscSimData
Definition: CscSimData.h:44
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CSC_RDOAnalysis::m_numSmpl
std::vector< uint16_t > * m_numSmpl
Definition: CSC_RDOAnalysis.h:51
CSC_RDOAnalysis::m_collID
std::vector< uint16_t > * m_collID
Definition: CSC_RDOAnalysis.h:39
xAOD::uint16_t
setWord1 uint16_t
Definition: eFexEMRoI_v1.cxx:93
CSC_RDOAnalysis::m_tree
TTree * m_tree
Definition: CSC_RDOAnalysis.h:107
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
CSC_RDOAnalysis::m_barcode
std::vector< int > * m_barcode
Definition: CSC_RDOAnalysis.h:71
lumiFormat.i
int i
Definition: lumiFormat.py:85
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
CSC_RDOAnalysis::m_energy_vec
std::vector< std::vector< float > > * m_energy_vec
Definition: CSC_RDOAnalysis.h:79
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
HepMC::barcode
int barcode(const T *p)
Definition: Barcode.h:16
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CSC_RDOAnalysis::m_calLayer
std::vector< uint8_t > * m_calLayer
Definition: CSC_RDOAnalysis.h:49
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:79
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
CscRawDataCollection
Collection of CSC Raw Hits, arranged according to CSC Detector Elements Author: Ketevi A.
Definition: CscRawDataCollection.h:24
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
CSC_RDOAnalysis::m_subID
std::vector< uint16_t > * m_subID
Definition: CSC_RDOAnalysis.h:41
python.SystemOfUnits.bar
int bar
Definition: SystemOfUnits.py:188
CSC_RDOAnalysis::m_energy
std::vector< float > * m_energy
Definition: CSC_RDOAnalysis.h:73
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
CSC_RDOAnalysis::m_h_cscID
TH1 * m_h_cscID
Definition: CSC_RDOAnalysis.h:91
CSC_RDOAnalysis::m_calEn
std::vector< bool > * m_calEn
Definition: CSC_RDOAnalysis.h:56
CSC_RDOAnalysis::m_calAmp
std::vector< uint8_t > * m_calAmp
Definition: CSC_RDOAnalysis.h:48
CSC_RDOAnalysis::m_spuCt
std::vector< uint16_t > * m_spuCt
Definition: CSC_RDOAnalysis.h:57
CSC_RDOAnalysis::m_ntupleDirName
std::string m_ntupleDirName
Definition: CSC_RDOAnalysis.h:109
CSC_RDOAnalysis::m_dataType
std::vector< uint8_t > * m_dataType
Definition: CSC_RDOAnalysis.h:43
CSC_RDOAnalysis::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: CSC_RDOAnalysis.h:112
CSC_RDOAnalysis::m_charge
std::vector< float > * m_charge
Definition: CSC_RDOAnalysis.h:76
CSC_RDOAnalysis::m_rodID
std::vector< uint16_t > * m_rodID
Definition: CSC_RDOAnalysis.h:40
CSC_RDOAnalysis::m_h_energy
TH1 * m_h_energy
Definition: CSC_RDOAnalysis.h:102
CSC_RDOAnalysis::m_ypos
std::vector< float > * m_ypos
Definition: CSC_RDOAnalysis.h:74
CSC_RDOAnalysis::m_h_cscHashID
TH1 * m_h_cscHashID
Definition: CSC_RDOAnalysis.h:96
CSC_RDOAnalysis::m_h_zpos
TH1 * m_h_zpos
Definition: CSC_RDOAnalysis.h:104
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
a
TList * a
Definition: liststreamerinfos.cxx:10
CSC_RDOAnalysis::m_h_ypos
TH1 * m_h_ypos
Definition: CSC_RDOAnalysis.h:103
CSC_RDOAnalysis::m_ntupleTreeName
std::string m_ntupleTreeName
Definition: CSC_RDOAnalysis.h:110
h
CSC_RDOAnalysis::m_h_cscWidth
TH1 * m_h_cscWidth
Definition: CSC_RDOAnalysis.h:93
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CSC_RDOAnalysis::m_h_cscAdd
TH1 * m_h_cscAdd
Definition: CSC_RDOAnalysis.h:95
CSC_RDOAnalysis::m_cscID
std::vector< uint16_t > * m_cscID
Definition: CSC_RDOAnalysis.h:60
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
CSC_RDOAnalysis::m_h_sdoWord
TH1 * m_h_sdoWord
Definition: CSC_RDOAnalysis.h:99
CSC_RDOAnalysis::m_h_collRpuID
TH1 * m_h_collRpuID
Definition: CSC_RDOAnalysis.h:87
CSC_RDOAnalysis::m_firstBitSum
std::vector< uint8_t > * m_firstBitSum
Definition: CSC_RDOAnalysis.h:46
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
CSC_RDOAnalysis::m_h_cscRpuID
TH1 * m_h_cscRpuID
Definition: CSC_RDOAnalysis.h:90
CSC_RDOAnalysis::m_sdoWord
std::vector< int > * m_sdoWord
Definition: CSC_RDOAnalysis.h:70
CSC_RDOAnalysis::m_h_subID
TH1 * m_h_subID
Definition: CSC_RDOAnalysis.h:86
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
CSC_RDOAnalysis::m_latency
std::vector< uint16_t > * m_latency
Definition: CSC_RDOAnalysis.h:52
CSC_RDOAnalysis::m_inputKey
SG::ReadHandleKey< CscRawDataContainer > m_inputKey
Definition: CSC_RDOAnalysis.h:35
CSC_RDOAnalysis::m_neutron
std::vector< bool > * m_neutron
Definition: CSC_RDOAnalysis.h:55
fitman.k
k
Definition: fitman.py:528
CSC_RDOAnalysis::m_h_cscTime
TH1 * m_h_cscTime
Definition: CSC_RDOAnalysis.h:92
CSC_RDOAnalysis::m_h_eventIndex
TH1 * m_h_eventIndex
Definition: CSC_RDOAnalysis.h:101
ServiceHandle< ICondSvc >
CSC_RDOAnalysis::m_h_sdoID
TH1 * m_h_sdoID
Definition: CSC_RDOAnalysis.h:98
Identifier
Definition: IdentifierFieldParser.cxx:14