ATLAS Offline Software
TileRDOAnalysis.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 
6 #include "TileRDOAnalysis.h"
7 #include "StoreGate/ReadHandle.h"
8 
9 #include "TileEvent/TileRawChannelCollection.h"
10 #include "TileEvent/TileDigitsCollection.h"
11 
12 #include "TTree.h"
13 #include "TString.h"
14 
15 #include <algorithm>
16 #include <math.h>
17 #include <functional>
18 #include <iostream>
19 
20 TileRDOAnalysis::TileRDOAnalysis(const std::string& name, ISvcLocator* pSvcLocator)
21  : AthAlgorithm(name, pSvcLocator)
22  , m_inputRawChKey("TileRawChannelCnt")
23  , m_inputMuRcvRawChKey("TileRawChannelCnt")
24  , m_inputMuRcvKey("TileMuRcvCnt")
25  , m_inputMBTS_TTL1Key("TileTTL1MBTS")
26  , m_inputTileTTL1Key("TileTTL1Cnt")
27  , m_inputL2Key("TileL2Cnt")
28  , m_inputDigitsFltKey("TileDigitsFlt")
29  , m_inputDigitsMuRcvKey("MuRcvDigitsCnt")
30  , m_adcID(0)
31  , m_pmtID(0)
32  , m_cellID(0)
33  , m_ttID(0)
34  , m_mtID(0)
35  , m_fragID(0)
36  , m_rawAmp(0)
37  , m_rawTime(0)
38  , m_rawQual(0)
39  , m_rawPed(0)
40  , m_adcID_mu(0)
41  , m_pmtID_mu(0)
42  , m_cellID_mu(0)
43  , m_ttID_mu(0)
44  , m_mtID_mu(0)
45  , m_fragID_mu(0)
46  , m_rawAmp_mu(0)
47  , m_rawTime_mu(0)
48  , m_rawQual_mu(0)
49  , m_rawPed_mu(0)
50  , m_muRcvID(0)
51  , m_muRcv_dec(0)
52  , m_muRcv_thresh(0)
53  , m_muRcv_energy(0)
54  , m_muRcv_time(0)
55  , m_ttl1MBTS_ID(0)
56  , m_ttl1MBTS_digits(0)
57  , m_ttl1_ID(0)
58  , m_ttl1_digits(0)
59  , m_L2ID(0)
60  , m_L2val(0)
61  , m_L2eta(0)
62  , m_L2phi(0)
63  , m_L2energyA(0)
64  , m_L2energyBC(0)
65  , m_L2energyD(0)
66  , m_L2qual(0)
67  , m_L2sumE(0)
68  , m_fragSize(0)
69  , m_fragBCID(0)
70  , m_digits(0)
71  , m_muFragSize(0)
72  , m_muFragBCID(0)
73  , m_muDigits(0)
74 
75  , m_h_adcID(0)
76  , m_h_rawAmp(0)
77  , m_h_rawTime(0)
78  , m_h_rawQual(0)
79  , m_h_rawPed(0)
80  , m_h_adcID_mu(0)
81  , m_h_rawAmp_mu(0)
82  , m_h_rawTime_mu(0)
83  , m_h_rawQual_mu(0)
84  , m_h_rawPed_mu(0)
85  , m_h_muRcvID(0)
86  , m_h_muRcv_dec(0)
87  , m_h_muRcv_thresh(0)
88  , m_h_muRcv_energy(0)
89  , m_h_muRcv_time(0)
90  , m_h_ttl1MBTS_ID(0)
91  , m_h_ttl1MBTS_digits(0)
92  , m_h_ttl1_ID(0)
93  , m_h_ttl1_digits(0)
94  , m_h_L2ID(0)
95  , m_h_L2val(0)
96  , m_h_L2eta(0)
97  , m_h_L2phi(0)
98  , m_h_L2energyA(0)
99  , m_h_L2energyBC(0)
100  , m_h_L2energyD(0)
101  , m_h_L2qual(0)
102  , m_h_L2sumE(0)
103  , m_h_digits(0)
104  , m_h_muDigits(0)
105 
106  , m_tree(0)
107  , m_ntupleFileName("/ntuples/file1")
108  , m_ntupleDirName("/TileRDOAnalysis/")
109  , m_ntupleTreeName("TileRDOAna")
110  , m_path("/TileRDOAnalysis/")
111  , m_thistSvc("THistSvc", name)
112 {
113  declareProperty("InputRawChKey", m_inputRawChKey);
114  declareProperty("InputMuRcvRawChKey", m_inputMuRcvRawChKey);
115  declareProperty("InputMuRcvKey", m_inputMuRcvKey);
116  declareProperty("InputMBTS_TTL1Key", m_inputMBTS_TTL1Key);
117  declareProperty("InputTileTTL1Key", m_inputTileTTL1Key);
118  declareProperty("InputL2Key", m_inputL2Key);
119  declareProperty("InputDigitsFltKey", m_inputDigitsFltKey);
120  declareProperty("InputDigitsMuRcvKey", m_inputDigitsMuRcvKey);
121  declareProperty("NtupleFileName", m_ntupleFileName);
122  declareProperty("NtupleDirectoryName", m_ntupleDirName);
123  declareProperty("NtupleTreeName", m_ntupleTreeName);
124  declareProperty("HistPath", m_path);
125 }
126 
127 StatusCode TileRDOAnalysis::initialize() {
128  ATH_MSG_DEBUG( "Initializing TileRDOAnalysis" );
129 
130 
131  // This will check that the properties were initialized
132  // properly by job configuration.
133  ATH_CHECK( m_inputRawChKey.initialize(SG::AllowEmpty) );
134  ATH_CHECK( m_inputMuRcvRawChKey.initialize(SG::AllowEmpty) );
135  ATH_CHECK( m_inputMuRcvKey.initialize(SG::AllowEmpty) );
136  ATH_CHECK( m_inputMBTS_TTL1Key.initialize(SG::AllowEmpty) );
137  ATH_CHECK( m_inputTileTTL1Key.initialize(SG::AllowEmpty) );
138  ATH_CHECK( m_inputL2Key.initialize(SG::AllowEmpty) );
139  ATH_CHECK( m_inputDigitsFltKey.initialize() );
140  ATH_CHECK( m_inputDigitsMuRcvKey.initialize() );
141 
142  // Grab Ntuple and histogramming service for tree
143  ATH_CHECK(m_thistSvc.retrieve());
144 
145  m_tree = new TTree(TString(m_ntupleTreeName), "TileRDOAna");
146  std::string fullNtupleName = "/" + m_ntupleFileName + "/" + m_ntupleDirName + "/" + m_ntupleTreeName;
147  ATH_CHECK(m_thistSvc->regTree(fullNtupleName, m_tree));
148  if (m_tree) {
149  m_tree->Branch("adcID", &m_adcID);
150  m_tree->Branch("pmtID", &m_pmtID);
151  m_tree->Branch("cellID", &m_cellID);
152  m_tree->Branch("ttID", &m_ttID);
153  m_tree->Branch("mtID", &m_mtID);
154  m_tree->Branch("fragID", &m_fragID);
155  m_tree->Branch("rawAmp", &m_rawAmp);
156  m_tree->Branch("rawTime", &m_rawTime);
157  m_tree->Branch("rawQual", &m_rawQual);
158  m_tree->Branch("rawPed", &m_rawPed);
159  m_tree->Branch("adcID_mu", &m_adcID_mu);
160  m_tree->Branch("pmtID_mu", &m_pmtID_mu);
161  m_tree->Branch("cellID_mu", &m_cellID_mu);
162  m_tree->Branch("ttID_mu", &m_ttID_mu);
163  m_tree->Branch("mtID_mu", &m_mtID_mu);
164  m_tree->Branch("fragID_mu", &m_fragID_mu);
165  m_tree->Branch("rawAmp_mu", &m_rawAmp_mu);
166  m_tree->Branch("rawTime_mu", &m_rawTime_mu);
167  m_tree->Branch("rawQual_mu", &m_rawQual_mu);
168  m_tree->Branch("rawPed_mu", &m_rawPed_mu);
169  m_tree->Branch("muRcvID", &m_muRcvID);
170  m_tree->Branch("muRcv_dec", &m_muRcv_dec);
171  m_tree->Branch("muRcv_thresh", &m_muRcv_thresh);
172  m_tree->Branch("muRcv_energy", &m_muRcv_energy);
173  m_tree->Branch("muRcv_time", &m_muRcv_time);
174  m_tree->Branch("ttl1MBTS_ID", &m_ttl1MBTS_ID);
175  m_tree->Branch("ttl1MBTS_digits", &m_ttl1MBTS_digits);
176  m_tree->Branch("ttl1_ID", &m_ttl1_ID);
177  m_tree->Branch("ttl1_digits", &m_ttl1_digits);
178  m_tree->Branch("L2ID", &m_L2ID);
179  m_tree->Branch("L2val", &m_L2val);
180  m_tree->Branch("L2eta", &m_L2eta);
181  m_tree->Branch("L2phi", &m_L2phi);
182  m_tree->Branch("L2energyA", &m_L2energyA);
183  m_tree->Branch("L2energyBC", &m_L2energyBC);
184  m_tree->Branch("L2energyD", &m_L2energyD);
185  m_tree->Branch("L2qual", &m_L2qual);
186  m_tree->Branch("L2sumE", &m_L2sumE);
187  m_tree->Branch("fragSize", &m_fragSize);
188  m_tree->Branch("fragBCID", &m_fragBCID);
189  m_tree->Branch("digits", &m_digits);
190  m_tree->Branch("muFragSize", &m_muFragSize);
191  m_tree->Branch("muFragBCID", &m_muFragBCID);
192  m_tree->Branch("muDigits", &m_muDigits);
193  }
194  else {
195  ATH_MSG_ERROR("No tree found!");
196  }
197 
198  // HISTOGRAMS
199  m_h_adcID = new TH1F("h_adcID", "adc ID", 100, 0, 9.25e18);
200  m_h_adcID->StatOverflows();
201  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_adcID->GetName(), m_h_adcID));
202 
203  m_h_rawAmp = new TH1F("h_rawAmp", "Raw amplitude", 100, -1200, 1200);
204  m_h_rawAmp->StatOverflows();
205  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rawAmp->GetName(), m_h_rawAmp));
206 
207  m_h_rawTime = new TH1F("h_rawTime", "Raw time", 100, -90, 90);
208  m_h_rawTime->StatOverflows();
209  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rawTime->GetName(), m_h_rawTime));
210 
211  m_h_rawQual = new TH1F("h_rawQual", "Raw quality", 100, 0, 1100);
212  m_h_rawQual->StatOverflows();
213  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rawQual->GetName(), m_h_rawQual));
214 
215  m_h_rawPed = new TH1F("h_rawPed", "Raw pedestal", 100, 0, 2e5);
216  m_h_rawPed->StatOverflows();
217  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rawPed->GetName(), m_h_rawPed));
218 
219  m_h_adcID_mu = new TH1F("h_adcID_mu", "MuRcv adc ID", 100, 0, 9.25e18);
220  m_h_adcID_mu->StatOverflows();
221  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_adcID_mu->GetName(), m_h_adcID_mu));
222 
223  m_h_rawAmp_mu = new TH1F("h_rawAmp_mu", "MuRcv raw amplitude", 100, -1000, 11000);
224  m_h_rawAmp_mu->StatOverflows();
225  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rawAmp_mu->GetName(), m_h_rawAmp_mu));
226 
227  m_h_rawTime_mu = new TH1F("h_rawTime_mu", "MuRcv raw time", 100, -90, 90);
228  m_h_rawTime_mu->StatOverflows();
229  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rawTime_mu->GetName(), m_h_rawTime_mu));
230 
231  m_h_rawQual_mu = new TH1F("h_rawQual_mu", "MuRcv raw quality", 100, 0, 8e34);
232  m_h_rawQual_mu->StatOverflows();
233  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rawQual_mu->GetName(), m_h_rawQual_mu));
234 
235  m_h_rawPed_mu = new TH1F("h_rawPed_mu", "MuRcv raw pedestal", 100, 0, 13);
236  m_h_rawPed_mu->StatOverflows();
237  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_rawPed_mu->GetName(), m_h_rawPed_mu));
238 
239  m_h_muRcvID = new TH1F("h_muRcvID", "Muon receiver object ID", 100, 0, 500);
240  m_h_muRcvID->StatOverflows();
241  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_muRcvID->GetName(), m_h_muRcvID));
242 
243  m_h_muRcv_dec = new TH1F("h_muRcv_dec", "Muon receiver object decision", 100, 0, 2);
244  m_h_muRcv_dec->StatOverflows();
245  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_muRcv_dec->GetName(), m_h_muRcv_dec));
246 
247  m_h_muRcv_thresh = new TH1F("h_muRcv_thresh", "Muon receiver object threshold", 100, 0, 650);
248  m_h_muRcv_thresh->StatOverflows();
249  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_muRcv_thresh->GetName(), m_h_muRcv_thresh));
250 
251  m_h_muRcv_energy = new TH1F("h_muRcv_energy", "Muon receiver object energy", 100, 0, 20000);
252  m_h_muRcv_energy->StatOverflows();
253  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_muRcv_energy->GetName(), m_h_muRcv_energy));
254 
255  m_h_muRcv_time = new TH1F("h_muRcv_time", "Muon receiver object time", 100, -90, 90);
256  m_h_muRcv_time->StatOverflows();
257  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_muRcv_time->GetName(), m_h_muRcv_time));
258 
259  m_h_ttl1MBTS_ID = new TH1F("h_ttl1MBTS_ID", "TTL1 MBTS ID", 100, 0, 9.25e18);
260  m_h_ttl1MBTS_ID->StatOverflows();
261  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_ttl1MBTS_ID->GetName(), m_h_ttl1MBTS_ID));
262 
263  m_h_ttl1MBTS_digits = new TH1F("h_ttl1MBTS_digits", "TTL1 MBTS digits", 100, 0, 2000);
264  m_h_ttl1MBTS_digits->StatOverflows();
265  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_ttl1MBTS_digits->GetName(), m_h_ttl1MBTS_digits));
266 
267  m_h_ttl1_ID = new TH1F("h_ttl1_ID", "TTL1 ID", 100, 0, 2e19);
268  m_h_ttl1_ID->StatOverflows();
269  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_ttl1_ID->GetName(), m_h_ttl1_ID));
270 
271  m_h_ttl1_digits = new TH1F("h_ttl1_digits", "TTL1 digits", 100, 0, 2000);
272  m_h_ttl1_digits->StatOverflows();
273  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_ttl1_digits->GetName(), m_h_ttl1_digits));
274 
275  m_h_L2ID = new TH1F("h_L2ID", "L2 ID", 100, 0, 2e19);
276  m_h_L2ID->StatOverflows();
277  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_L2ID->GetName(), m_h_L2ID));
278 
279  m_h_L2val = new TH1F("h_L2val", "L2 data values", 100, 0, 100);
280  m_h_L2val->StatOverflows();
281  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_L2val->GetName(), m_h_L2val));
282 
283  m_h_L2eta = new TH1F("h_L2eta", "L2 eta", 100, -1.5, 1.5);
284  m_h_L2eta->StatOverflows();
285  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_L2eta->GetName(), m_h_L2eta));
286 
287  m_h_L2phi = new TH1F("h_L2phi", "L2 phi", 100, -3.5, 3.5);
288  m_h_L2phi->StatOverflows();
289  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_L2phi->GetName(), m_h_L2phi));
290 
291  m_h_L2energyA = new TH1F("h_L2energyA", "L2 energy in A cells", 100, 0, 12500);
292  m_h_L2energyA->StatOverflows();
293  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_L2energyA->GetName(), m_h_L2energyA));
294 
295  m_h_L2energyBC = new TH1F("h_L2energyBC", "L2 energy in BC cells", 100, 0, 12500);
296  m_h_L2energyBC->StatOverflows();
297  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_L2energyBC->GetName(), m_h_L2energyBC));
298 
299  m_h_L2energyD = new TH1F("h_L2energyD", "L2 energy in D cells", 100, 0, 12500);
300  m_h_L2energyD->StatOverflows();
301  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_L2energyD->GetName(), m_h_L2energyD));
302 
303  m_h_L2qual = new TH1F("h_L2qual", "L2 quality", 100, 0, 2);
304  m_h_L2qual->StatOverflows();
305  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_L2qual->GetName(), m_h_L2qual));
306 
307  m_h_L2sumE = new TH1F("h_L2sumE", "L2 energy sum", 100, 0, 2.25e5);
308  m_h_L2sumE->StatOverflows();
309  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_L2sumE->GetName(), m_h_L2sumE));
310 
311  m_h_digits = new TH1F("h_digits", "Tile digits", 100, 0, 1100);
312  m_h_digits->StatOverflows();
313  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_digits->GetName(), m_h_digits));
314 
315  m_h_muDigits = new TH1F("h_muDigits", "Tile muon receiver object digits", 100, 0, 150);
316  m_h_muDigits->StatOverflows();
317  ATH_CHECK(m_thistSvc->regHist(m_path + m_h_muDigits->GetName(), m_h_muDigits));
318 
319 
320 
321  return StatusCode::SUCCESS;
322 }
323 
324 StatusCode TileRDOAnalysis::execute() {
325  ATH_MSG_DEBUG( "In TileRDOAnalysis::execute()" );
326 
327  m_adcID->clear();
328  m_pmtID->clear();
329  m_cellID->clear();
330  m_ttID->clear();
331  m_mtID->clear();
332  m_fragID->clear();
333  m_rawAmp->clear();
334  m_rawTime->clear();
335  m_rawQual->clear();
336  m_rawPed->clear();
337  m_adcID_mu->clear();
338  m_pmtID_mu->clear();
339  m_cellID_mu->clear();
340  m_ttID_mu->clear();
341  m_mtID_mu->clear();
342  m_fragID_mu->clear();
343  m_rawAmp_mu->clear();
344  m_rawTime_mu->clear();
345  m_rawQual_mu->clear();
346  m_rawPed_mu->clear();
347  m_muRcvID->clear();
348  m_muRcv_dec->clear();
349  m_muRcv_thresh->clear();
350  m_muRcv_energy->clear();
351  m_muRcv_time->clear();
352  m_ttl1MBTS_ID->clear();
353  m_ttl1MBTS_digits->clear();
354  m_ttl1_ID->clear();
355  m_ttl1_digits->clear();
356  m_L2ID->clear();
357  m_L2val->clear();
358  m_L2eta->clear();
359  m_L2phi->clear();
360  m_L2energyA->clear();
361  m_L2energyBC->clear();
362  m_L2energyD->clear();
363  m_L2qual->clear();
364  m_L2sumE->clear();
365  m_fragSize->clear();
366  m_fragBCID->clear();
367  m_digits->clear();
368  m_muFragSize->clear();
369  m_muFragBCID->clear();
370  m_muDigits->clear();
371 
372  // Tile Raw Channels
373  // Raw info (pulse height, time, quality) for in-time beam crossing in Tile
374  if (!m_presampling)
375  {
376  SG::ReadHandle<TileRawChannelContainer> p_rawCont(m_inputRawChKey);
377  if (p_rawCont.isValid()) {
378  // loop over tile raw channels container
379  TileRawChannelContainer::const_iterator rawCont_itr(p_rawCont->begin());
380  const TileRawChannelContainer::const_iterator rawCont_end(p_rawCont->end());
381  for ( ; rawCont_itr != rawCont_end; ++rawCont_itr ) {
382  const TileRawDataCollection<TileRawChannel>* p_rawColl(*rawCont_itr);
383  TileRawDataCollection<TileRawChannel>::const_iterator raw_itr(p_rawColl->begin());
384  const TileRawDataCollection<TileRawChannel>::const_iterator raw_end(p_rawColl->end());
385  for ( ; raw_itr != raw_end; ++raw_itr ) {
386  const Identifier adcID((*raw_itr)->adc_ID());
387  const Identifier pmtID((*raw_itr)->pmt_ID());
388  const Identifier cellID((*raw_itr)->cell_ID());
389  const Identifier ttID((*raw_itr)->tt_ID());
390  const Identifier mtID((*raw_itr)->mt_ID());
391  const int fragID((*raw_itr)->frag_ID());
392 
393  const unsigned long long adcID_int = adcID.get_compact();
394  const unsigned long long pmtID_int = pmtID.get_compact();
395  const unsigned long long cellID_int = cellID.get_compact();
396  const unsigned long long ttID_int = ttID.get_compact();
397  const unsigned long long mtID_int = mtID.get_compact();
398 
399  m_adcID->push_back(adcID_int);
400  m_pmtID->push_back(pmtID_int);
401  m_cellID->push_back(cellID_int);
402  m_ttID->push_back(ttID_int);
403  m_mtID->push_back(mtID_int);
404  m_fragID->push_back(fragID);
405 
406  m_h_adcID->Fill(adcID_int);
407 
408  for (int ix = 0; ix != (*raw_itr)->size(); ++ix) {
409  m_rawAmp->push_back((*raw_itr)->amplitude(ix)); // [ADC counts]
410  m_h_rawAmp->Fill((*raw_itr)->amplitude(ix));
411  m_rawQual->push_back((*raw_itr)->quality(ix)); // sampling distr.
412  m_h_rawQual->Fill((*raw_itr)->quality(ix));
413  }
414  for (int jx = 0; jx != (*raw_itr)->sizeTime(); ++jx) {
415  m_rawTime->push_back((*raw_itr)->time(jx)); // rel to triggering bunch
416  m_h_rawTime->Fill((*raw_itr)->time(jx));
417  }
418  // // cannot find member 'sizeQuality()' --- using old header?
419  // for (int kx = 0; kx != (*raw_itr)->sizeQuality(); ++kx) {
420  // m_rawQual->push_back((*raw_itr)->quality(kx)); // sampling distr.
421  // m_h_rawQual->Fill((*raw_itr)->quality(kx));
422  // }
423  m_rawPed->push_back((*raw_itr)->pedestal()); // reconstructed
424  m_h_rawPed->Fill((*raw_itr)->pedestal());
425  }
426  }
427  }
428 
429  // Muon Receiver Raw Channels
430  SG::ReadHandle<TileRawChannelContainer> p_mu_rawCont(m_inputMuRcvRawChKey);
431  if (p_mu_rawCont.isValid()) {
432  // loop over muon receiver raw channels container
433  TileRawChannelContainer::const_iterator muRawCont_itr(p_mu_rawCont->begin());
434  const TileRawChannelContainer::const_iterator muRawCont_end(p_mu_rawCont->end());
435  for ( ; muRawCont_itr != muRawCont_end; ++muRawCont_itr ) {
436  const TileRawDataCollection<TileRawChannel>* p_mu_rawColl(*muRawCont_itr);
437  TileRawDataCollection<TileRawChannel>::const_iterator muRaw_itr(p_mu_rawColl->begin());
438  const TileRawDataCollection<TileRawChannel>::const_iterator muRaw_end(p_mu_rawColl->end());
439  for ( ; muRaw_itr != muRaw_end; ++muRaw_itr ) {
440  const Identifier adcID_mu((*muRaw_itr)->adc_ID());
441  const Identifier pmtID_mu((*muRaw_itr)->pmt_ID());
442  const Identifier cellID_mu((*muRaw_itr)->cell_ID());
443  const Identifier ttID_mu((*muRaw_itr)->tt_ID());
444  const Identifier mtID_mu((*muRaw_itr)->mt_ID());
445  const int fragID_mu((*muRaw_itr)->frag_ID());
446 
447  const unsigned long long adcID_mu_int = adcID_mu.get_compact();
448  const unsigned long long pmtID_mu_int = pmtID_mu.get_compact();
449  const unsigned long long cellID_mu_int = cellID_mu.get_compact();
450  const unsigned long long ttID_mu_int = ttID_mu.get_compact();
451  const unsigned long long mtID_mu_int = mtID_mu.get_compact();
452 
453  m_adcID_mu->push_back(adcID_mu_int);
454  m_pmtID_mu->push_back(pmtID_mu_int);
455  m_cellID_mu->push_back(cellID_mu_int);
456  m_ttID_mu->push_back(ttID_mu_int);
457  m_mtID_mu->push_back(mtID_mu_int);
458  m_fragID_mu->push_back(fragID_mu);
459 
460  m_h_adcID_mu->Fill(adcID_mu_int);
461 
462  for (int lx = 0; lx != (*muRaw_itr)->size(); ++lx){
463  m_rawAmp_mu->push_back((*muRaw_itr)->amplitude(lx));
464  m_h_rawAmp_mu->Fill((*muRaw_itr)->amplitude(lx));
465  m_rawQual_mu->push_back((*muRaw_itr)->quality(lx));
466  m_h_rawQual_mu->Fill((*muRaw_itr)->quality(lx));
467  }
468  for (int mx = 0; mx != (*muRaw_itr)->sizeTime(); ++mx) {
469  m_rawTime_mu->push_back((*muRaw_itr)->time(mx));
470  m_h_rawTime_mu->Fill((*muRaw_itr)->time(mx));
471  }
472  // // cannot find member 'sizeQuality()' --- using old header?
473  // for (int nx = 0; nx != (*muRaw_itr)->sizeQuality(); ++nx) {
474  // m_rawQual_mu->push_back((*muRaw_itr)->quality(nx));
475  // m_h_rawQual_mu->Fill((*muRaw_itr)->quality(nx));
476  // }
477  m_rawPed_mu->push_back((*muRaw_itr)->pedestal());
478  m_h_rawPed_mu->Fill((*muRaw_itr)->pedestal());
479  }
480  }
481  }
482 
483 
484  // Tile Container - TileMuonReceiverContainer
485  SG::ReadHandle<TileMuonReceiverContainer> p_muRcv_cont(m_inputMuRcvKey);
486  if (p_muRcv_cont.isValid()) {
487  // loop over muon receiver container
488  TileMuonReceiverContainer::const_iterator muRcv_itr(p_muRcv_cont->begin());
489  const TileMuonReceiverContainer::const_iterator muRcv_end(p_muRcv_cont->end());
490  for ( ; muRcv_itr != muRcv_end; ++muRcv_itr ) {
491  const int muRcvID((*muRcv_itr)->GetID());
492  const std::vector<bool>& dec_vec = (*muRcv_itr)->GetDecision();
493  const std::vector<float>& thresh_vec = (*muRcv_itr)->GetThresholds();
494  const std::vector<float>& ene_vec = (*muRcv_itr)->GetEne();
495  const std::vector<float>& time_vec = (*muRcv_itr)->GetTime();
496 
497  m_muRcvID->push_back(muRcvID);
498 
499  for (std::vector<bool>::size_type i = 0; i != dec_vec.size(); ++i) {
500  m_muRcv_dec->push_back(dec_vec.at(i));
501  m_h_muRcv_dec->Fill(dec_vec.at(i));
502  }
503  for (std::vector<float>::size_type j = 0; j != thresh_vec.size(); ++j) {
504  m_muRcv_thresh->push_back(thresh_vec.at(j));
505  m_h_muRcv_thresh->Fill(thresh_vec.at(j));
506  }
507  for (std::vector<float>::size_type k = 0; k != ene_vec.size(); ++k) {
508  m_muRcv_energy->push_back(ene_vec.at(k));
509  m_h_muRcv_energy->Fill(ene_vec.at(k));
510  }
511  for (std::vector<float>::size_type l = 0; l != time_vec.size(); ++l) {
512  m_muRcv_time->push_back(time_vec.at(l));
513  m_h_muRcv_time->Fill(time_vec.at(l));
514  }
515 
516  m_h_muRcvID->Fill(muRcvID);
517  }
518  }
519 
520 
521  // Tile Container - TileTTL1Container
522  // Raw Tile L1 Trigger Towers
523  SG::ReadHandle<TileTTL1Container> p_ttl1MBTS_cont(m_inputMBTS_TTL1Key);
524  if (p_ttl1MBTS_cont.isValid()) {
525  // loop over TTL1 MBTS container
526  TileTTL1Container::const_iterator ttl1MBTS_itr(p_ttl1MBTS_cont->begin());
527  const TileTTL1Container::const_iterator ttl1MBTS_end(p_ttl1MBTS_cont->end());
528  for ( ; ttl1MBTS_itr != ttl1MBTS_end; ++ttl1MBTS_itr ) {
529  const Identifier ttl1MBTS_ID((*ttl1MBTS_itr)->identify());
530  const std::vector<double> ttl1MBTS_digits((*ttl1MBTS_itr)->samples());
531 
532  const unsigned long long ttl1MBTS_ID_int = ttl1MBTS_ID.get_compact();
533  m_ttl1MBTS_ID->push_back(ttl1MBTS_ID_int); // identifier
534  m_ttl1MBTS_digits->push_back(ttl1MBTS_digits); // hardware sum of Tile channels; read out in N time slices
535 
536  for (std::vector<double>::size_type iy = 0; iy != ttl1MBTS_digits.size(); ++iy) {
537 
538  m_h_ttl1MBTS_digits->Fill(ttl1MBTS_digits.at(iy));
539  }
540 
541  m_h_ttl1MBTS_ID->Fill(ttl1MBTS_ID_int);
542  }
543  }
544  SG::ReadHandle<TileTTL1Container> p_ttl1Cont(m_inputTileTTL1Key);
545  if (p_ttl1Cont.isValid()) {
546  // loop over TTL1 container
547  TileTTL1Container::const_iterator ttl1_itr(p_ttl1Cont->begin());
548  const TileTTL1Container::const_iterator ttl1_end(p_ttl1Cont->end());
549  for ( ; ttl1_itr != ttl1_end; ++ttl1_itr ) {
550  const Identifier ttl1ID((*ttl1_itr)->identify());
551  const std::vector<double> ttl1_digits((*ttl1_itr)->samples());
552 
553  const unsigned long long ttl1ID_int = ttl1ID.get_compact();
554  m_ttl1_ID->push_back(ttl1ID_int);
555  m_ttl1_digits->push_back(ttl1_digits);
556 
557  for (std::vector<double>::size_type jy = 0; jy != ttl1_digits.size(); ++jy) {
558  m_h_ttl1_digits->Fill(ttl1_digits.at(jy));
559  }
560 
561  m_h_ttl1_ID->Fill(ttl1ID_int);
562  }
563  }
564 
565 
566  // Tile Container - TileL2
567  // TileMuId and Et computed at TileCal ROD DSPs (use for L2 trigger)
568  std::vector<unsigned int> val_vec;
569  std::vector<float> eta_vec;
570  std::vector<float> enemu0_vec;
571  std::vector<float> enemu1_vec;
572  std::vector<float> enemu2_vec;
573  std::vector<unsigned int> qual_vec;
574  std::vector<float> sumE_vec;
575 
576  SG::ReadHandle<TileL2Container> p_L2Cont(m_inputL2Key);
577  if (p_L2Cont.isValid()) {
578  // loop over L2 container
579  TileL2Container::const_iterator L2_itr(p_L2Cont->begin());
580  const TileL2Container::const_iterator L2_end(p_L2Cont->end());
581  for ( ; L2_itr != L2_end; ++L2_itr ) {
582  // drawer ID
583  const int L2ID((*L2_itr)->identify());
584  // packed muon info (32-bit words)
585  for (unsigned int ii = 0; ii != (*L2_itr)->Ndata(); ii++) {
586  val_vec.push_back((*L2_itr)->val(ii));
587  m_h_L2val->Fill(val_vec.at(ii));
588  }
589  // muon info - energy deposited in TileCal layers, eta, quality flag
590  for (unsigned int jj = 0; jj != (*L2_itr)->NMuons(); jj++) {
591  eta_vec.push_back((*L2_itr)->eta(jj));
592  enemu0_vec.push_back((*L2_itr)->enemu0(jj));
593  enemu1_vec.push_back((*L2_itr)->enemu1(jj));
594  enemu2_vec.push_back((*L2_itr)->enemu2(jj));
595  qual_vec.push_back((*L2_itr)->qual(jj));
596 
597  m_h_L2eta->Fill(eta_vec.at(jj));
598  m_h_L2energyA->Fill(enemu0_vec.at(jj));
599  m_h_L2energyBC->Fill(enemu1_vec.at(jj));
600  m_h_L2energyD->Fill(enemu2_vec.at(jj));
601  m_h_L2qual->Fill(qual_vec.at(jj));
602  }
603  // drawer phi
604  const float l2phi((*L2_itr)->phi(0));
605  // vector sumE = [sumEt, sumEz, sumE] per TileCal superdrawer
606  for (unsigned int kk = 0; kk != (*L2_itr)->NsumE(); kk++) {
607  sumE_vec.push_back((*L2_itr)->sumE(kk));
608  m_h_L2sumE->Fill(sumE_vec.at(kk));
609  }
610 
611  m_L2ID->push_back(L2ID);
612  m_L2val->push_back(val_vec);
613  m_L2eta->push_back(eta_vec);
614  m_L2energyA->push_back(enemu0_vec);
615  m_L2energyBC->push_back(enemu1_vec);
616  m_L2energyD->push_back(enemu2_vec);
617  m_L2qual->push_back(qual_vec);
618  m_L2phi->push_back(l2phi);
619  m_L2sumE->push_back(sumE_vec);
620 
621  m_h_L2ID->Fill(L2ID);
622  m_h_L2phi->Fill(l2phi);
623 
624  val_vec.clear();
625  eta_vec.clear();
626  enemu0_vec.clear();
627  enemu1_vec.clear();
628  enemu2_vec.clear();
629  qual_vec.clear();
630  sumE_vec.clear();
631  }
632  }
633  }
634 
635  // TileDigitsContainer - TileDigitsFlt
636  SG::ReadHandle<TileDigitsContainer> p_digiCont(m_inputDigitsFltKey);
637  if (p_digiCont.isValid()) {
638  // loop over tile digits container
639  TileDigitsContainer::const_iterator digiCont_itr(p_digiCont->begin());
640  const TileDigitsContainer::const_iterator digiCont_end(p_digiCont->end());
641  for ( ; digiCont_itr != digiCont_end; ++digiCont_itr ) {
642  uint32_t fragSize((*digiCont_itr)->getFragSize());
643  uint32_t fragBCID((*digiCont_itr)->getFragBCID());
644 
645  m_fragSize->push_back(fragSize);
646  m_fragBCID->push_back(fragBCID);
647 
648  const TileRawDataCollection<TileDigits>* p_digiColl(*digiCont_itr);
649  TileRawDataCollection<TileDigits>::const_iterator digi_itr(p_digiColl->begin());
650  const TileRawDataCollection<TileDigits>::const_iterator digi_end(p_digiColl->end());
651  for ( ; digi_itr != digi_end; ++digi_itr ) {
652  const std::vector<double> digits((*digi_itr)->get_digits());
653  m_digits->push_back(digits);
654 
655  for (std::vector<double>::size_type iz = 0; iz != digits.size(); ++iz) {
656  m_h_digits->Fill(digits.at(iz));
657  }
658  }
659  }
660  }
661 
662  // TileDigitsContainer - MuRcvDigitsCnt
663  SG::ReadHandle<TileDigitsContainer> p_mu_digiCont(m_inputDigitsMuRcvKey);
664  if (p_mu_digiCont.isValid()) {
665  // loop over tile digits container
666  TileDigitsContainer::const_iterator muDigiCont_itr(p_mu_digiCont->begin());
667  const TileDigitsContainer::const_iterator muDigiCont_end(p_mu_digiCont->end());
668  for ( ; muDigiCont_itr != muDigiCont_end; ++muDigiCont_itr ) {
669  const uint32_t muFragSize((*muDigiCont_itr)->getFragSize());
670  const uint32_t muFragBCID((*muDigiCont_itr)->getFragBCID());
671 
672  m_muFragSize->push_back(muFragSize);
673  m_muFragBCID->push_back(muFragBCID);
674 
675  const TileRawDataCollection<TileDigits>* p_mu_digiColl(*muDigiCont_itr);
676  DataVector<TileDigits>::const_iterator muDigi_itr(p_mu_digiColl->begin());
677  const DataVector<TileDigits>::const_iterator muDigi_end(p_mu_digiColl->end());
678  for ( ; muDigi_itr != muDigi_end; ++muDigi_itr ) {
679  const std::vector<double> muDigits((*muDigi_itr)->get_digits());
680  m_muDigits->push_back(muDigits);
681 
682  for (std::vector<double>::size_type jz = 0; jz != muDigits.size(); ++jz) {
683  m_h_muDigits->Fill(muDigits.at(jz));
684  }
685  }
686  }
687  }
688 
689  if (m_tree) {
690  m_tree->Fill();
691  }
692 
693  return StatusCode::SUCCESS;
694 }
695 
696 StatusCode TileRDOAnalysis::finalize() {
697  return StatusCode::SUCCESS;
698 }
TileRDOAnalysis::m_cellID
std::vector< unsigned long long > * m_cellID
Definition: TileRDOAnalysis.h:49
TileRawChannelCollection.h
TileRDOAnalysis::m_inputMBTS_TTL1Key
SG::ReadHandleKey< TileTTL1Container > m_inputMBTS_TTL1Key
Definition: TileRDOAnalysis.h:39
RunTileTBMonitoring.fragID
fragID
Definition: RunTileTBMonitoring.py:212
TileRDOAnalysis::m_L2energyBC
std::vector< std::vector< float > > * m_L2energyBC
Definition: TileRDOAnalysis.h:84
TileRDOAnalysis::m_ttID_mu
std::vector< unsigned long long > * m_ttID_mu
Definition: TileRDOAnalysis.h:60
RatesAnalysisFullMenu.e34
e34
Definition: RatesAnalysisFullMenu.py:25
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TileRDOAnalysis::m_h_muRcv_energy
TH1 * m_h_muRcv_energy
Definition: TileRDOAnalysis.h:110
TileRDOAnalysis::m_inputRawChKey
SG::ReadHandleKey< TileRawChannelContainer > m_inputRawChKey
Definition: TileRDOAnalysis.h:36
TileDigitsCollection.h
TileRDOAnalysis::m_fragID_mu
std::vector< int > * m_fragID_mu
Definition: TileRDOAnalysis.h:62
TileRDOAnalysis::m_L2ID
std::vector< int > * m_L2ID
Definition: TileRDOAnalysis.h:79
TileRDOAnalysis::m_ntupleFileName
std::string m_ntupleFileName
Definition: TileRDOAnalysis.h:130
TileRDOAnalysis::m_h_adcID
TH1 * m_h_adcID
Definition: TileRDOAnalysis.h:97
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileRDOAnalysis::m_fragID
std::vector< int > * m_fragID
Definition: TileRDOAnalysis.h:52
TileRDOAnalysis::m_adcID_mu
std::vector< unsigned long long > * m_adcID_mu
Definition: TileRDOAnalysis.h:57
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
TileRDOAnalysis::m_h_L2val
TH1 * m_h_L2val
Definition: TileRDOAnalysis.h:117
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileRDOAnalysis::m_inputL2Key
SG::ReadHandleKey< TileL2Container > m_inputL2Key
Definition: TileRDOAnalysis.h:41
TileRDOAnalysis::m_L2energyD
std::vector< std::vector< float > > * m_L2energyD
Definition: TileRDOAnalysis.h:85
TileRDOAnalysis::m_h_L2sumE
TH1 * m_h_L2sumE
Definition: TileRDOAnalysis.h:124
TileRDOAnalysis::m_L2val
std::vector< std::vector< unsigned int > > * m_L2val
Definition: TileRDOAnalysis.h:80
TileRDOAnalysis::m_h_rawAmp_mu
TH1 * m_h_rawAmp_mu
Definition: TileRDOAnalysis.h:103
TileRDOAnalysis::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: TileRDOAnalysis.h:134
Identifier::get_compact
value_type get_compact() const
Get the compact id.
TileRDOAnalysis::m_adcID
std::vector< unsigned long long > * m_adcID
Definition: TileRDOAnalysis.h:47
TileRDOAnalysis::m_h_rawAmp
TH1 * m_h_rawAmp
Definition: TileRDOAnalysis.h:98
fitman.mx
mx
Definition: fitman.py:520
UploadAMITag.l
list l
Definition: UploadAMITag.larcaf.py:158
TileRDOAnalysis::m_fragBCID
std::vector< uint32_t > * m_fragBCID
Definition: TileRDOAnalysis.h:90
TileRDOAnalysis::finalize
virtual StatusCode finalize() override final
Definition: TileRDOAnalysis.cxx:696
TileRDOAnalysis::m_L2qual
std::vector< std::vector< unsigned int > > * m_L2qual
Definition: TileRDOAnalysis.h:86
TileRDOAnalysis::m_presampling
BooleanProperty m_presampling
Definition: TileRDOAnalysis.h:44
TileRDOAnalysis::m_h_L2ID
TH1 * m_h_L2ID
Definition: TileRDOAnalysis.h:116
TileRDOAnalysis::execute
virtual StatusCode execute() override final
Definition: TileRDOAnalysis.cxx:324
TileRDOAnalysis::m_h_ttl1MBTS_digits
TH1 * m_h_ttl1MBTS_digits
Definition: TileRDOAnalysis.h:113
TileRDOAnalysis::m_h_rawQual
TH1 * m_h_rawQual
Definition: TileRDOAnalysis.h:100
TileRDOAnalysis::m_ntupleTreeName
std::string m_ntupleTreeName
Definition: TileRDOAnalysis.h:132
TileRDOAnalysis::m_rawQual
std::vector< float > * m_rawQual
Definition: TileRDOAnalysis.h:55
TileRDOAnalysis::m_inputDigitsMuRcvKey
SG::ReadHandleKey< TileDigitsContainer > m_inputDigitsMuRcvKey
Definition: TileRDOAnalysis.h:43
TileRDOAnalysis::m_muRcv_energy
std::vector< float > * m_muRcv_energy
Definition: TileRDOAnalysis.h:71
TileRDOAnalysis::m_inputDigitsFltKey
SG::ReadHandleKey< TileDigitsContainer > m_inputDigitsFltKey
Definition: TileRDOAnalysis.h:42
python.changerun.kk
list kk
Definition: changerun.py:41
TileRDOAnalysis::m_h_L2energyBC
TH1 * m_h_L2energyBC
Definition: TileRDOAnalysis.h:121
TileRDOAnalysis::m_mtID
std::vector< unsigned long long > * m_mtID
Definition: TileRDOAnalysis.h:51
TileRDOAnalysis::m_L2sumE
std::vector< std::vector< float > > * m_L2sumE
Definition: TileRDOAnalysis.h:87
TileRDOAnalysis::m_h_rawPed
TH1 * m_h_rawPed
Definition: TileRDOAnalysis.h:101
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
TileRDOAnalysis::m_h_L2qual
TH1 * m_h_L2qual
Definition: TileRDOAnalysis.h:123
TileRDOAnalysis::m_h_digits
TH1 * m_h_digits
Definition: TileRDOAnalysis.h:125
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TileRDOAnalysis::m_muRcv_thresh
std::vector< float > * m_muRcv_thresh
Definition: TileRDOAnalysis.h:70
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
m_path
std::string m_path
the path being used
Definition: OutputStreamData.cxx:88
TileRDOAnalysis::m_muFragBCID
std::vector< uint32_t > * m_muFragBCID
Definition: TileRDOAnalysis.h:93
TileRDOAnalysis::initialize
virtual StatusCode initialize() override final
Definition: TileRDOAnalysis.cxx:127
TileRDOAnalysis::m_rawPed
std::vector< float > * m_rawPed
Definition: TileRDOAnalysis.h:56
TileRDOAnalysis::m_digits
std::vector< std::vector< double > > * m_digits
Definition: TileRDOAnalysis.h:91
TileRDOAnalysis::m_h_L2energyD
TH1 * m_h_L2energyD
Definition: TileRDOAnalysis.h:122
TileRawDataCollection< TileRawChannel >
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
TileRDOAnalysis::TileRDOAnalysis
TileRDOAnalysis(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TileRDOAnalysis.cxx:20
TileRDOAnalysis::m_h_L2phi
TH1 * m_h_L2phi
Definition: TileRDOAnalysis.h:119
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
TileRDOAnalysis::m_pmtID_mu
std::vector< unsigned long long > * m_pmtID_mu
Definition: TileRDOAnalysis.h:58
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
TileRDOAnalysis::m_h_muRcv_dec
TH1 * m_h_muRcv_dec
Definition: TileRDOAnalysis.h:108
DataVector
Derived DataVector<T>.
Definition: DataVector.h:581
TileRDOAnalysis::m_cellID_mu
std::vector< unsigned long long > * m_cellID_mu
Definition: TileRDOAnalysis.h:59
TileRDOAnalysis::m_mtID_mu
std::vector< unsigned long long > * m_mtID_mu
Definition: TileRDOAnalysis.h:61
TileRDOAnalysis::m_L2eta
std::vector< std::vector< float > > * m_L2eta
Definition: TileRDOAnalysis.h:81
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TileRDOAnalysis::m_h_rawQual_mu
TH1 * m_h_rawQual_mu
Definition: TileRDOAnalysis.h:105
TileRDOAnalysis::m_ttl1MBTS_ID
std::vector< unsigned long long > * m_ttl1MBTS_ID
Definition: TileRDOAnalysis.h:74
TileRDOAnalysis::m_h_muDigits
TH1 * m_h_muDigits
Definition: TileRDOAnalysis.h:126
TileRDOAnalysis::m_h_ttl1MBTS_ID
TH1 * m_h_ttl1MBTS_ID
Definition: TileRDOAnalysis.h:112
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
TileRDOAnalysis::m_h_rawTime
TH1 * m_h_rawTime
Definition: TileRDOAnalysis.h:99
TileRDOAnalysis::m_L2energyA
std::vector< std::vector< float > > * m_L2energyA
Definition: TileRDOAnalysis.h:83
TileRDOAnalysis::m_L2phi
std::vector< float > * m_L2phi
Definition: TileRDOAnalysis.h:82
TileRDOAnalysis::m_muRcv_dec
std::vector< bool > * m_muRcv_dec
Definition: TileRDOAnalysis.h:69
TileRDOAnalysis::m_h_L2energyA
TH1 * m_h_L2energyA
Definition: TileRDOAnalysis.h:120
TileRDOAnalysis::m_ttID
std::vector< unsigned long long > * m_ttID
Definition: TileRDOAnalysis.h:50
TileRDOAnalysis::m_rawTime_mu
std::vector< float > * m_rawTime_mu
Definition: TileRDOAnalysis.h:64
TileRDOAnalysis::m_h_rawPed_mu
TH1 * m_h_rawPed_mu
Definition: TileRDOAnalysis.h:106
TileRDOAnalysis::m_muFragSize
std::vector< uint32_t > * m_muFragSize
Definition: TileRDOAnalysis.h:92
TileRDOAnalysis::m_path
std::string m_path
Definition: TileRDOAnalysis.h:133
TileRDOAnalysis::m_ttl1_digits
std::vector< std::vector< double > > * m_ttl1_digits
Definition: TileRDOAnalysis.h:77
TileRDOAnalysis::m_rawAmp_mu
std::vector< float > * m_rawAmp_mu
Definition: TileRDOAnalysis.h:63
TileRDOAnalysis::m_muRcv_time
std::vector< float > * m_muRcv_time
Definition: TileRDOAnalysis.h:72
TileRDOAnalysis::m_tree
TTree * m_tree
Definition: TileRDOAnalysis.h:129
TileRDOAnalysis.h
TileRDOAnalysis::m_pmtID
std::vector< unsigned long long > * m_pmtID
Definition: TileRDOAnalysis.h:48
TileRDOAnalysis::m_inputTileTTL1Key
SG::ReadHandleKey< TileTTL1Container > m_inputTileTTL1Key
Definition: TileRDOAnalysis.h:40
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TileRDOAnalysis::m_fragSize
std::vector< uint32_t > * m_fragSize
Definition: TileRDOAnalysis.h:89
TileRDOAnalysis::m_h_rawTime_mu
TH1 * m_h_rawTime_mu
Definition: TileRDOAnalysis.h:104
TileRDOAnalysis::m_h_muRcv_time
TH1 * m_h_muRcv_time
Definition: TileRDOAnalysis.h:111
TileRDOAnalysis::m_h_ttl1_ID
TH1 * m_h_ttl1_ID
Definition: TileRDOAnalysis.h:114
TileRDOAnalysis::m_h_L2eta
TH1 * m_h_L2eta
Definition: TileRDOAnalysis.h:118
TileRDOAnalysis::m_h_ttl1_digits
TH1 * m_h_ttl1_digits
Definition: TileRDOAnalysis.h:115
TileRDOAnalysis::m_inputMuRcvKey
SG::ReadHandleKey< TileMuonReceiverContainer > m_inputMuRcvKey
Definition: TileRDOAnalysis.h:38
TileRDOAnalysis::m_h_muRcvID
TH1 * m_h_muRcvID
Definition: TileRDOAnalysis.h:107
TileRDOAnalysis::m_muDigits
std::vector< std::vector< double > > * m_muDigits
Definition: TileRDOAnalysis.h:94
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.
TileRDOAnalysis::m_rawQual_mu
std::vector< float > * m_rawQual_mu
Definition: TileRDOAnalysis.h:65
TileRDOAnalysis::m_rawPed_mu
std::vector< float > * m_rawPed_mu
Definition: TileRDOAnalysis.h:66
TileRDOAnalysis::m_muRcvID
std::vector< int > * m_muRcvID
Definition: TileRDOAnalysis.h:68
TileRDOAnalysis::m_h_muRcv_thresh
TH1 * m_h_muRcv_thresh
Definition: TileRDOAnalysis.h:109
SG::AllowEmpty
@ AllowEmpty
Definition: StoreGate/StoreGate/VarHandleKey.h:30
TileRDOAnalysis::m_ttl1MBTS_digits
std::vector< std::vector< double > > * m_ttl1MBTS_digits
Definition: TileRDOAnalysis.h:75
TileRDOAnalysis::m_ttl1_ID
std::vector< unsigned long long > * m_ttl1_ID
Definition: TileRDOAnalysis.h:76
TileRDOAnalysis::m_inputMuRcvRawChKey
SG::ReadHandleKey< TileRawChannelContainer > m_inputMuRcvRawChKey
Definition: TileRDOAnalysis.h:37
TileRDOAnalysis::m_ntupleDirName
std::string m_ntupleDirName
Definition: TileRDOAnalysis.h:131
TileRDOAnalysis::m_h_adcID_mu
TH1 * m_h_adcID_mu
Definition: TileRDOAnalysis.h:102
TileRDOAnalysis::m_rawTime
std::vector< float > * m_rawTime
Definition: TileRDOAnalysis.h:54
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
TileRDOAnalysis::m_rawAmp
std::vector< float > * m_rawAmp
Definition: TileRDOAnalysis.h:53
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Thu Nov 7 2024 21:28:27 for ATLAS Offline Software by   doxygen 1.8.18