ATLAS Offline Software
CSC_RDOAnalysis.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 
6 #include "CSC_RDOAnalysis.h"
7 #include "StoreGate/ReadHandle.h"
8 
9 #include "TTree.h"
10 #include "TString.h"
11 
12 #include <algorithm>
13 #include <math.h>
14 #include <functional>
15 #include <iostream>
16 
17 CSC_RDOAnalysis::CSC_RDOAnalysis(const std::string& name, ISvcLocator *pSvcLocator)
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 }
99 
100 StatusCode CSC_RDOAnalysis::initialize() {
101  ATH_MSG_DEBUG( "Initializing CSC_RDOAnalysis" );
102 
103  // This will check that the properties were initialized
104  // properly by job configuration.
105  ATH_CHECK( m_inputKey.initialize() );
106  ATH_CHECK( m_inputTruthKey.initialize() );
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 }
248 
249 StatusCode CSC_RDOAnalysis::execute() {
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 
294  SG::ReadHandle<CscRawDataContainer> p_CSCcont (m_inputKey);
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
380  SG::ReadHandle<CscSimDataCollection> simDataMapCSC (m_inputTruthKey);
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 }
457 
458 StatusCode CSC_RDOAnalysis::finalize() {
459  return StatusCode::SUCCESS;
460 }
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::finalize
virtual StatusCode finalize() override final
Definition: CSC_RDOAnalysis.cxx:458
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
CSC_RDOAnalysis::CSC_RDOAnalysis
CSC_RDOAnalysis(const std::string &name, ISvcLocator *pSvcLocator)
Definition: CSC_RDOAnalysis.cxx:17
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::execute
virtual StatusCode execute() override final
Definition: CSC_RDOAnalysis.cxx:249
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
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
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
CSC_RDOAnalysis::m_cscWidth
std::vector< uint16_t > * m_cscWidth
Definition: CSC_RDOAnalysis.h:62
CscSimData::word
int word() const
Definition: CscSimData.h:63
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
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:88
CSC_RDOAnalysis::m_tree
TTree * m_tree
Definition: CSC_RDOAnalysis.h:107
CSC_RDOAnalysis::m_barcode
std::vector< int > * m_barcode
Definition: CSC_RDOAnalysis.h:71
lumiFormat.i
int i
Definition: lumiFormat.py:92
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
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
CSC_RDOAnalysis.h
m_path
std::string m_path
the path being used
Definition: OutputStreamData.cxx:88
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:242
CSC_RDOAnalysis::m_calLayer
std::vector< uint8_t > * m_calLayer
Definition: CSC_RDOAnalysis.h:49
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
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
TH1::Fill
int Fill(double)
Definition: rootspy.cxx:285
CscRawDataCollection
Collection of CSC Raw Hits, arranged according to CSC Detector Elements Author: Ketevi A.
Definition: CscRawDataCollection.h:24
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
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
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
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::initialize
virtual StatusCode initialize() override final
Definition: CSC_RDOAnalysis.cxx:100
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
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
CSC_RDOAnalysis::m_h_zpos
TH1 * m_h_zpos
Definition: CSC_RDOAnalysis.h:104
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
Identifier::get_compact
value_type get_compact(void) const
Get the compact id.
CSC_RDOAnalysis::m_h_cscWidth
TH1 * m_h_cscWidth
Definition: CSC_RDOAnalysis.h:93
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
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
CscSimData::getdeposits
const std::vector< Deposit > & getdeposits() const
Definition: CscSimData.h:67
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
ReadHandle.h
Handle class for reading from StoreGate.
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
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
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
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
CSC_RDOAnalysis::m_h_sdoID
TH1 * m_h_sdoID
Definition: CSC_RDOAnalysis.h:98
Generated on Fri Jul 5 2024 21:13:17 for ATLAS Offline Software by   doxygen 1.8.18