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