Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
TileCellMonitorAlgorithm.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 #include "TileCellMonitorAlgorithm.h"
6 #include "PairBuilder.h"
7 #include "TileEvent/TileCell.h"
8 #include "TileIdentifier/TileHWID.h"
9 #include "TileCalibBlobObjs/TileCalibUtils.h"
10 
11 #include "CaloIdentifier/TileID.h"
12 
13 #include "StoreGate/ReadHandle.h"
14 #include "StoreGate/ReadCondHandle.h"
15 #include "AthenaKernel/Units.h"
16 #include "CxxUtils/trapping_fp.h"
17 
18 using Athena::Units::GeV;
19 using Athena::Units::ns;
20 
21 StatusCode TileCellMonitorAlgorithm::initialize() {
22 
23  ATH_MSG_INFO("in initialize()");
24 
25  ATH_CHECK( detStore()->retrieve(m_tileID) );
26  ATH_CHECK( detStore()->retrieve(m_tileHWID) );
27 
28  ATH_CHECK( m_cablingSvc.retrieve() );
29  m_cabling = m_cablingSvc->cablingService();
30 
31  ATH_CHECK( m_DQstatusKey.initialize() );
32  ATH_CHECK( m_badChannelsKey.initialize() );
33  ATH_CHECK( m_caloCellContainerKey.initialize() );
34 
35  using Tile = TileCalibUtils;
36  using namespace Monitored;
37 
38  int nL1Triggers = getNumberOfL1Triggers();
39 
40  m_cellSynchGroups = buildToolMap<int>(m_tools, "TileCellSynch", nL1Triggers);
41  m_energyBalModPartGroups = buildToolMap<int>(m_tools, "TileCellEneBalModPart", nL1Triggers);
42  m_timeBalModPartGroups = buildToolMap<int>(m_tools, "TileCellTimeBalModPart", nL1Triggers);
43  m_maskedOnFlyGroups = buildToolMap<int>(m_tools, "TileCellStatusOnFly", Tile::MAX_ROS - 1);
44  m_maskedDueDQGroups = buildToolMap<int>(m_tools, "TileMaskChannelDueDQvsLB", MAX_PART);
45  m_maskedCellsDueDQGroups = buildToolMap<int>(m_tools, "TileMaskedCellDueDQvsLB", MAX_PART);
46 
47  m_maskedOnFlyLBGroups = buildToolMap<int>(m_tools, "TileMaskChannelOnFlyLB", MAX_PART);
48  m_maskedCellsLBGroups = buildToolMap<int>(m_tools, "TileMaskCellLB", MAX_PART);
49 
50  m_maskedGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellStatusInDB",
51  Tile::MAX_ROS - 1, Tile::MAX_GAIN);
52 
53  m_energySampEGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellEventEnergy_SampE",
54  Tile::MAX_ROS, nL1Triggers);
55 
56  m_moduleCorrGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellModuleCorrelation",
57  Tile::MAX_ROS, nL1Triggers);
58 
59  m_chanTimeGroups = buildToolMap<std::vector<int>>(m_tools, "TileChanPartTime",
60  Tile::MAX_ROS - 1, nL1Triggers);
61 
62  m_digiTimeGroups = buildToolMap<std::vector<int>>(m_tools, "TileDigiPartTime",
63  Tile::MAX_ROS - 1, nL1Triggers);
64 
65  m_detailOccupGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellDetailOccMap",
66  Tile::MAX_ROS - 1, nL1Triggers);
67 
68  m_overThrOccupGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellDetailOccMapOvThr",
69  Tile::MAX_ROS - 1, nL1Triggers);
70 
71  m_overThr30GeVOccupGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellDetailOccMapOvThr30GeV",
72  Tile::MAX_ROS - 1, nL1Triggers);
73 
74  m_overThr300GeVOccupGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellDetailOccMapOvThr300GeV",
75  Tile::MAX_ROS - 1, nL1Triggers);
76 
77  m_eneDiffChanModGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellEneDiffChanMod",
78  Tile::MAX_ROS - 1, nL1Triggers);
79 
80  m_overThrOccupGainGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileCellDetailOccMapOvThrGain",
81  Tile::MAX_ROS - 1, Tile::MAX_GAIN, nL1Triggers);
82 
83  m_detailOccupGainGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileCellDetailOccMapGain",
84  Tile::MAX_ROS - 1, Tile::MAX_GAIN, nL1Triggers);
85 
86  if (m_fillGapScintHistograms) {
87  m_energyGapScintGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileGapScintilatorEnergy", 2 /* EBA and EBC */,
88  Tile::MAX_DRAWER, 4 /* E1-E4 */);
89  }
90 
91  m_nCellsGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellsNumberLB",
92  Tile::MAX_ROS, nL1Triggers);
93 
94  m_nCellsOverThrGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellOccOvThrBCID",
95  Tile::MAX_ROS, nL1Triggers);
96 
97  m_eneEtaPhiGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellEneEtaPhi",
98  MAX_SAMP, nL1Triggers);
99 
100  m_overThrEtaPhiGroups = buildToolMap<std::vector<int>>(m_tools, "TileCellEtaPhiOvThr",
101  MAX_SAMP, nL1Triggers);
102 
103  if (m_fillChannelTimeHistograms) {
104  m_chanTimeSampGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileChannelTime",
105  Tile::MAX_ROS - 1, MAX_SAMP, nL1Triggers);
106  }
107 
108  m_eneDiffSampGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileCellEneDiff",
109  Tile::MAX_ROS - 1, MAX_SAMP, nL1Triggers);
110 
111  m_timeDiffSampGroups = buildToolMap<std::vector<std::vector<int>>>(m_tools, "TileCellTimeDiff",
112  Tile::MAX_ROS - 1, MAX_SAMP, nL1Triggers);
113 
114  m_negOccupGroups = buildToolMap<int>(m_tools, "TileCellDetailNegOccMap", Tile::MAX_ROS - 1);
115  m_timeBalGroups = buildToolMap<int>(m_tools, "TileCellTimeBalance", Tile::MAX_ROS - 1);
116  m_energyBalGroups = buildToolMap<int>(m_tools, "TileCellEnergyBalance", Tile::MAX_ROS - 1);
117 
118 
119  return TileMonitorAlgorithm::initialize();
120 }
121 
122 
123 StatusCode TileCellMonitorAlgorithm::fillHistograms( const EventContext& ctx ) const {
124 
125  using Tile = TileCalibUtils;
126 
127  // In case you want to measure the execution time
128  auto timer = Monitored::Timer("TIME_execute");
129 
130  const xAOD::EventInfo* eventInfo = GetEventInfo(ctx).get();
131 
132  const TileDQstatus* dqStatus = SG::makeHandle(m_DQstatusKey, ctx).get();
133  auto lumiBlock = Monitored::Scalar<int>("lumiBlock", eventInfo->lumiBlock());
134 
135 
136  if (msgLvl(MSG::DEBUG)) {
137  msg(MSG::DEBUG) << "Run = " << eventInfo->runNumber()
138  << " LB = " << eventInfo->lumiBlock()
139  << " Evt = " << eventInfo->eventNumber()
140  << " BCID = " << eventInfo->bcid()
141  << " lvl1 = 0x" << std::hex << eventInfo->level1TriggerType() << std::dec;
142 
143  const std::vector<xAOD::EventInfo::StreamTag>& eventStreamTags = eventInfo->streamTags();
144  if (!eventStreamTags.empty()) {
145  msg(MSG::DEBUG) << " stream name/type:";
146  for (const auto& eventStreamTag : eventStreamTags) {
147  msg(MSG::DEBUG) << " " << eventStreamTag.name() << "/" << eventStreamTag.type();
148  }
149  }
150 
151  msg(MSG::DEBUG) << endmsg;
152  }
153 
154  // Weights for E-cells, only towers 10..15
155  static const float energyWeight[6] = {1.f/3.f, 1.f/6.f, 1.f/11.f, 1.f/11.f, 1.f/28.f, 1.f/28.f};
156  static const int gapScintIndex[6] = {0, 1, 2, 2, 3, 3};
157 
158  std::vector<const CaloCell*> muonCells;
159 
160  std::vector<int> energyBalModPartModule;
161  std::vector<int> energyBalModPartPartition;
162 
163  std::vector<int> timeBalModPartModule;
164  std::vector<int> timeBalModPartPartition;
165 
166  double energySample[MAX_PART][MAX_SAMP] = {{0.}};
167  int nCells[MAX_PART] = {0};
168  int nBadCells[MAX_PART] = {0};
169 
170  // Arrays for BCID plots
171  int nCellsOverThreshold[MAX_PART] = {0};
172 
173  // Number of channels masked on the fly
174  int nBadChannelsOnFly[MAX_PART] = {0};
175 
176  // Number of channels masked on the fly due to bad DQ status
177  unsigned int nMaskedChannelsDueDQ[MAX_PART] = { 0 };
178 
179  // Number of cells masked on the fly due to bad DQ status
180  unsigned int nMaskedCellsDueDQ[MAX_PART] = { 0 };
181 
182  std::vector<int> negOccupModule[Tile::MAX_ROS - 1];
183  std::vector<int> negOccupChannel[Tile::MAX_ROS - 1];
184 
185  std::vector<float> timeBal[Tile::MAX_ROS - 1];
186  std::vector<int> timeBalModule[Tile::MAX_ROS - 1];
187 
188  std::vector<float> energyBal[Tile::MAX_ROS - 1];
189  std::vector<int> energyBalModule[Tile::MAX_ROS - 1];
190 
191  std::vector<int> detailOccupModule[Tile::MAX_ROS - 1];
192  std::vector<int> detailOccupChannel[Tile::MAX_ROS - 1];
193  std::vector<float> detailOccupEnergies[Tile::MAX_ROS - 1];
194 
195  std::vector<int> detailOccupGainModule[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
196  std::vector<int> detailOccupGainChannel[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
197  std::vector<float> detailOccupGainEnergies[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
198 
199  std::vector<int> overThrOccupModule[Tile::MAX_ROS - 1];
200  std::vector<int> overThrOccupChannel[Tile::MAX_ROS - 1];
201  std::vector<float> overThrOccupWeight[Tile::MAX_ROS - 1];
202 
203  std::vector<int> overThrOccupGainModule[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
204  std::vector<int> overThrOccupGainChannel[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
205  std::vector<float> overThrOccupGainWeight[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
206 
207  std::vector<int> overThr30GeVOccupModule[Tile::MAX_ROS - 1];
208  std::vector<int> overThr30GeVOccupChannel[Tile::MAX_ROS - 1];
209 
210  std::vector<int> overThr300GeVOccupModule[Tile::MAX_ROS - 1];
211  std::vector<int> overThr300GeVOccupChannel[Tile::MAX_ROS - 1];
212 
213  std::vector<int> eneDiff[Tile::MAX_ROS - 1];
214  std::vector<int> eneDiffChannel[Tile::MAX_ROS - 1];
215  std::vector<int> eneDiffModule[Tile::MAX_ROS - 1];
216 
217  std::vector<int> maskedOnFlyDrawers[Tile::MAX_ROS - 1];
218  std::vector<int> maskedOnFlyChannel[Tile::MAX_ROS - 1];
219 
220  std::vector<int> chanTime[Tile::MAX_ROS - 1];
221  std::vector<int> chanTimeDrawer[Tile::MAX_ROS - 1];
222  std::vector<int> chanTimeChannel[Tile::MAX_ROS - 1];
223  std::vector<int> chanTimeDigitizer[Tile::MAX_ROS - 1];
224 
225  int nChannelsInPartition = 2880; // LB
226  for (unsigned int partition = 0; partition < Tile::MAX_ROS - 1; ++partition) {
227  if (partition > 1) nChannelsInPartition = 2048; // EB
228  detailOccupModule[partition].reserve(nChannelsInPartition);
229  detailOccupChannel[partition].reserve(nChannelsInPartition);
230  detailOccupEnergies[partition].reserve(nChannelsInPartition);
231  }
232 
233  std::vector<float> occupEta[SAMP_ALL];
234  std::vector<float> occupPhi[SAMP_ALL];
235  std::vector<float> occupEnergy[SAMP_ALL];
236 
237  std::vector<float> overThrOccupEta[SAMP_ALL];
238  std::vector<float> overThrOccupPhi[SAMP_ALL];
239 
240  std::vector<float> sampChanTime[Tile::MAX_ROS - 1][SAMP_ALL];
241  std::vector<float> sampEnergyDiff[Tile::MAX_ROS - 1][SAMP_ALL];
242  std::vector<float> sampTimeDiff[Tile::MAX_ROS - 1][SAMP_ALL];
243 
244  PairBuilder moduleCorr[MAX_PART];
245 
246  // Indices of L1 trigger histograms to be filled in the current event
247  std::vector<int> l1TriggersIndices = getL1TriggerIndices(eventInfo->level1TriggerType());
248 
249  SG::ReadCondHandle<TileBadChannels> badChannelsHandle(m_badChannelsKey, ctx);
250  const TileBadChannels* badChannels(badChannelsHandle.cptr());
251 
252  fillMaskedInDB(badChannels);
253 
254  bool isCollision = true;
255 
256  SG::ReadHandle<CaloCellContainer> caloCellContainer(m_caloCellContainerKey, ctx);
257  ATH_CHECK( caloCellContainer.isValid() );
258 
259 
260  for (const CaloCell* cell : *caloCellContainer) {
261  // Tell clang to optimize assuming that FP operations may trap.
262  // Prevents spurious FPEs from the division by energy.
263  CXXUTILS_TRAPPING_FP;
264  Identifier id = cell->ID();
265  if (m_tileID->is_tile(id)) {
266 
267  const TileCell* tile_cell = dynamic_cast<const TileCell*>(cell);
268  if (tile_cell == 0) continue;
269 
270  int drawer = 0; // Drawer number, range 0-63, the same for both channels
271  int channel1 = -1; // Channel number, range 0-47 or -1 for unknown
272  int channel2 = -1; // Channel number, range 0-47 or -1 for unknown
273 
274  int ros1 = -1;
275  int ros2 = -1;
276 
277  int partition1 = -1;
278  int partition2 = -1;
279 
280  bool isMaskedChannel1 = false;
281  bool isMaskedAdc1 = false;
282  bool isMaskedAdc2 = false;
283 
284  int gain1 = tile_cell->gain1(); // Gain of first PMT
285  int gain2 = tile_cell->gain2(); // Gain of second PMT
286 
287  const CaloDetDescrElement* caloDDE = tile_cell->caloDDE();
288 
289  IdentifierHash hash1 = caloDDE->onl1();
290  if (hash1 != TileHWID::NOT_VALID_HASH) {
291  HWIdentifier channel1_id = m_tileHWID->channel_id(hash1);
292  channel1 = m_tileHWID->channel(channel1_id);
293  drawer = m_tileHWID->drawer(channel1_id);
294  ros1 = m_tileHWID->ros(channel1_id);
295  partition1 = ros1 - 1;
296  }
297 
298  IdentifierHash hash2 = caloDDE->onl2();
299  if (hash2 != TileHWID::NOT_VALID_HASH) {
300  HWIdentifier channel2_id = m_tileHWID->channel_id(hash2);
301  channel2 = m_tileHWID->channel(channel2_id);
302  drawer = m_tileHWID->drawer(channel2_id);
303  ros2 = m_tileHWID->ros(channel2_id);
304  partition2 = ros2 - 1;
305  }
306 
307  // Note that drawer from HWID and module from ID are different for E3 cells near MBTS
308  int module = m_tileID->module(id); // Range from 0-63
309 
310  // int samp = std::min(m_tileID->sample(id),(int)AllSamp);
311  int sample = m_tileID->sample(id);
312 
313  bool single_PMT_scin = (sample == TileID::SAMP_E);
314  bool single_PMT_C10 = (m_tileID->section(id) == TileID::GAPDET
315  && sample == TileID::SAMP_C
316  && (!m_cabling->C10_connected(module)));
317 
318  // Distinguish cells with one or two PMTs
319  bool single_PMT = single_PMT_C10 || single_PMT_scin;
320 
321  // Distinguish normal cells and fantoms (e.g. non-existing D4 in EBA15, EBC18
322  // or non-existing E3/E4 - they might appear in CaloCellContainer)
323  bool realCell = single_PMT_C10 || m_cabling->TileGap_connected(id);
324 
325  // Note that in single PMT cell both badch1() and badch2() are changed together
326  bool isBadChannel1 = tile_cell->badch1();
327  bool isBadChannel2 = tile_cell->badch2();
328 
329  int isCellGood = !tile_cell->badcell();
330 
331  bool isOkChannel1 = (channel1 > -1 && gain1 != CaloGain::INVALIDGAIN);
332  bool isOkChannel2 = (channel2 > -1 && gain2 != CaloGain::INVALIDGAIN);
333 
334  // Get the cell energy, time and position info
335  double energy = cell->energy();
336  double time = cell->time();
337  double eta = cell->eta();
338  double phi = cell->phi();
339  double energy1 = tile_cell->ene1();
340  double energy2 = tile_cell->ene2();
341  double energyDiff = (single_PMT) ? 0.0 : tile_cell->eneDiff();
342  double energyRatio = (energy != 0.0) ? energyDiff/energy : 0.0;
343  double time1 = tile_cell->time1();
344  double time2 = tile_cell->time2();
345  double timeDiff = (single_PMT) ? 0.0 : 2. * tile_cell->timeDiff(); // Attention! factor of 2 is needed here
346 
347  double weight = 1.;
348  if (single_PMT_scin) {
349  int tower = m_tileID->tower(id);
350  if (tower > 9 && tower < 16) {
351  weight = energyWeight[tower - 10];
352  }
353  if (m_fillGapScintHistograms) {
354  if (energy > m_energyThresholdForGapScint) {
355  int gapScintIdx = gapScintIndex[tower - 10];
356  unsigned int partition = (ros1 > 0) ? ros1 - 3 : ros2 - 3;
357  auto monEnergy = Monitored::Scalar<float>("energy", energy);
358  fill(m_tools[m_energyGapScintGroups[partition][drawer][gapScintIdx]], monEnergy);
359  }
360  }
361  }
362 
363  if (msgLvl(MSG::VERBOSE)) {
364 
365  msg(MSG::VERBOSE) << "Identifier: " << id << " " << m_tileID->to_string(id,-2) << endmsg;
366  msg(MSG::VERBOSE) << " region: " << m_tileID->region(id)
367  << " system: " << m_tileID->system(id)
368  << " section: "<< m_tileID->section(id)
369  << " side: " << m_tileID->side(id)
370  << " module: " << m_tileID->module(id)
371  << " tower: " << m_tileID->tower(id)
372  << " sample: " << m_tileID->sample(id) << endmsg;
373 
374  msg(MSG::VERBOSE) << "1st PMT ROS: " << ros1
375  << " drawer: " << drawer
376  << " ch1: " << channel1
377  << " gain1: " << gain1
378  << " qual1: " << (int)tile_cell->qual1()
379  << " qbit1: " << (int)tile_cell->qbit1()
380  << ((drawer != module) ? " drawer != module":" ") << endmsg;
381 
382  msg(MSG::VERBOSE) << "2nd PMT ROS: " << ros2
383  << " drawer: " << drawer
384  << " ch2: " << channel2
385  << " gain2: " << gain2
386  << " qual2: " << (int)tile_cell->qual2()
387  << " qbit2: " << (int)tile_cell->qbit2()
388  << ((ros1 != ros2) ? " ros1 != ros2" : " ") << endmsg;
389 
390  msg(MSG::VERBOSE) << "Bad status: " << !isCellGood
391  << " bad1: " << isBadChannel1
392  << " bad2: " << isBadChannel2
393  << ((single_PMT_scin && isBadChannel1 && !isMaskedChannel1)
394  ? " NEW BAD E-cell" : " ") << endmsg ;
395 
396  msg(MSG::VERBOSE) << " real_cell: " << ((realCell) ? "true" : "false")
397  << " E-cell: " << ((single_PMT_scin) ? "true" : "false")
398  << " specC10: " << ((single_PMT_C10) ? "true" : "false") << endmsg;
399 
400  msg(MSG::VERBOSE) << "Energy= " << energy << " = " << energy1 << " + " << energy2
401  << " ediff= " << energyDiff
402  << " eratio= " << energyRatio
403  << "\t Energy[GeV]= " << energy/GeV << endmsg ;
404 
405  msg(MSG::VERBOSE) << "Time= " << time << " = (" << time1 << " + " << time2 << ")/2 "
406  << "tdiff= " << timeDiff
407  << "\t time[ns]= " << time/ns << endmsg ;
408  }
409 
410 
411  if (realCell) {
412 
413  int dbGain1 = gain1;
414  int dbGain2 = gain2;
415  // When only one channel is bad, it might be that gain of masked channel is not correct
416  // If two qualities are not identical, then gains are not the same (new feature introduced in rel 17.2)
417  int quality1 = (int)tile_cell->qual1();
418  int quality2 = (int)tile_cell->qual2();
419  if (isBadChannel1 != isBadChannel2 && quality1 != quality2
420  && quality1 < 255 && quality2 < 255) {
421  if (isBadChannel1 && isOkChannel1) dbGain1 = 1 - gain1;
422  if (isBadChannel2 && isOkChannel2) dbGain2 = 1 - gain2;
423  }
424 
425  if (hash1 != TileHWID::NOT_VALID_HASH) {
426  HWIdentifier adc1_id = m_tileHWID->adc_id(hash1, dbGain1);
427  isMaskedAdc1 = badChannels->getAdcStatus(adc1_id).isBad();
428  }
429 
430  if (hash2 != TileHWID::NOT_VALID_HASH) {
431  HWIdentifier adc2_id = m_tileHWID->adc_id(hash2, dbGain2);
432  isMaskedAdc2 = badChannels->getAdcStatus(adc2_id).isBad();
433  }
434 
435  bool channel1MaskedDueDQ(false);
436  if (isBadChannel1 && isOkChannel1 && !(single_PMT_C10 && channel1 == 4)) {
437  if (!isMaskedAdc1) {
438  ++nBadChannelsOnFly[partition1];
439  maskedOnFlyDrawers[partition1].push_back(drawer);
440  maskedOnFlyChannel[partition1].push_back(channel1);
441 
442  if (!dqStatus->isAdcDQgood(ros1, drawer, channel1, gain1)) {
443  channel1MaskedDueDQ = true;
444  ++nMaskedChannelsDueDQ[partition1];
445  }
446  }
447  }
448 
449  bool channel2MaskedDueDQ(false);
450  if (isBadChannel2 && isOkChannel2 && !(single_PMT_C10 && channel2 == 4)) {
451  if (!isMaskedAdc2) {
452  ++nBadChannelsOnFly[partition2];
453  maskedOnFlyDrawers[partition2].push_back(drawer);
454  maskedOnFlyChannel[partition2].push_back(channel2);
455 
456  if (!dqStatus->isAdcDQgood(ros2, drawer, channel2, gain2)) {
457  channel2MaskedDueDQ = true;
458  ++nMaskedChannelsDueDQ[partition2];
459  }
460  }
461  }
462 
463  if (isCellGood) {
464 
465  if ((energy > m_energyRangeForMuon[0]) && (energy < m_energyRangeForMuon[1])
466  && (time > m_timeRangeForMuon[0]) && (time < m_timeRangeForMuon[1])
467  && (time != 0)) { // Cell has reconstructed time
468  muonCells.push_back(cell);
469  }
470 
471  occupEta[sample].push_back(eta);
472  occupPhi[sample].push_back(phi);
473  occupEnergy[sample].push_back(energy);
474 
475  if (isOkChannel1) {
476  detailOccupModule[partition1].push_back(module);
477  detailOccupChannel[partition1].push_back(channel1);
478  detailOccupEnergies[partition1].push_back(energy1 * weight);
479 
480  detailOccupGainModule[partition1][gain1].push_back(module);
481  detailOccupGainChannel[partition1][gain1].push_back(channel1);
482  detailOccupGainEnergies[partition1][gain1].push_back(energy1 * weight);
483  }
484 
485  if (isOkChannel2) {
486  detailOccupModule[partition2].push_back(module);
487  detailOccupChannel[partition2].push_back(channel2);
488  detailOccupEnergies[partition2].push_back(energy2);
489 
490  detailOccupGainModule[partition2][gain2].push_back(module);
491  detailOccupGainChannel[partition2][gain2].push_back(channel2);
492  detailOccupGainEnergies[partition2][gain2].push_back(energy2);
493  }
494 
495  } else {
496  ++nBadCells[partition1];
497  if (channel1MaskedDueDQ || channel2MaskedDueDQ) {
498  ++nMaskedCellsDueDQ[partition1];
499  }
500  }
501 
502  // Check if energy is below negative threshold
503  if (isOkChannel1 && energy1 < m_negativeEnergyThreshold && (!isMaskedAdc1)) {
504  negOccupModule[partition1].push_back(module);
505  negOccupChannel[partition1].push_back(channel1);
506  }
507 
508  if (isOkChannel2 && energy2 < m_negativeEnergyThreshold && (!isMaskedAdc2)) {
509  negOccupModule[partition2].push_back(module);
510  negOccupChannel[partition2].push_back(channel2);
511  }
512 
513  if (energy > m_energyThreshold) {
514 
515  // Fill channel timing histograms.
516  if (isCollision || m_fillTimeHistograms) {
517  if (isOkChannel1 && energy1 > m_energyThresholdForTime && energy1 < m_energyLimitForTime) {
518  if ((gain1 == 0) && (energy1 < 1000.)) {
519  ATH_MSG_DEBUG("Low energy in LG for time monitoring: " << Tile::getDrawerString(ros1, drawer)
520  << ", channel = " << channel1 << ", energy = " << energy1 << ", time = " << time1);
521  } else {
522  chanTime[partition1].push_back(time1);
523  chanTimeDrawer[partition1].push_back(drawer);
524  chanTimeChannel[partition1].push_back(channel1);
525  chanTimeDigitizer[partition1].push_back(getDigitizer(channel1));
526  if (m_fillChannelTimeHistograms) {
527  sampChanTime[partition1][sample].push_back(time1);
528  }
529  }
530  }
531 
532  if (isOkChannel2 && energy2 > m_energyThresholdForTime && energy2 < m_energyLimitForTime) {
533  if ((gain2 == 0) && (energy2 < 1000.)) {
534  ATH_MSG_DEBUG("Low energy in LG for time monitoring: " << Tile::getDrawerString(ros2, drawer)
535  << ", channel = " << channel2 << ", energy = " << energy2 << ", time = " << time2);
536  } else {
537  chanTime[partition2].push_back(time2);
538  chanTimeDrawer[partition2].push_back(drawer);
539  chanTimeChannel[partition2].push_back(channel2);
540  chanTimeDigitizer[partition2].push_back(getDigitizer(channel2));
541  if (m_fillChannelTimeHistograms) {
542  sampChanTime[partition2][sample].push_back(time2);
543  }
544  }
545  }
546  }
547 
548  overThrOccupEta[sample].push_back(eta);
549  overThrOccupPhi[sample].push_back(phi);
550 
551  if (isOkChannel1 && energy1 > m_energyThreshold && (!isBadChannel1)) {
552  overThrOccupModule[partition1].push_back(module);
553  overThrOccupChannel[partition1].push_back(channel1);
554  overThrOccupWeight[partition1].push_back(weight);
555 
556  if (energy1 > m_energyThresholdForGain[gain1]) {
557  overThrOccupGainModule[partition1][gain1].push_back(module);
558  overThrOccupGainChannel[partition1][gain1].push_back(channel1);
559  overThrOccupGainWeight[partition1][gain1].push_back(weight);
560  }
561 
562  if (energy1 > 30000.) {
563  overThr30GeVOccupModule[partition1].push_back(module);
564  overThr30GeVOccupChannel[partition1].push_back(channel1);
565 
566  if (energy1 > 300000.) {
567  overThr300GeVOccupModule[partition1].push_back(module);
568  overThr300GeVOccupChannel[partition1].push_back(channel1);
569  }
570  }
571  }
572 
573  if (isOkChannel2 && energy2 > m_energyThreshold && (!isBadChannel2)) {
574  overThrOccupModule[partition2].push_back(module);
575  overThrOccupChannel[partition2].push_back(channel2);
576  overThrOccupWeight[partition2].push_back(1.0F);
577 
578  if (energy2 > m_energyThresholdForGain[gain2]) {
579  overThrOccupGainModule[partition2][gain2].push_back(module);
580  overThrOccupGainChannel[partition2][gain2].push_back(channel2);
581  overThrOccupGainWeight[partition2][gain2].push_back(1.0F);
582  }
583 
584  if (energy2 > 30000.) {
585  overThr30GeVOccupModule[partition2].push_back(module);
586  overThr30GeVOccupChannel[partition2].push_back(channel2);
587 
588  if (energy2 > 300000.) {
589  overThr300GeVOccupModule[partition2].push_back(module);
590  overThr300GeVOccupChannel[partition2].push_back(channel2);
591  }
592  }
593  }
594 
595  bool fillEneAndTimeDiff(m_fillTimeAndEnergyDiffHistograms);
596 
597  // avoid double peak structure in energy and time balance histograms
598  if ((gain1 == 0 && gain2 == 1 && (energy1 < 2000 || energy2 < 10 || std::abs(energy1 / energy2) > 5))
599  || (gain1 == 1 && gain2 == 0 && (energy2 < 2000 || energy1 < 10 || std::abs(energy2 / energy1) > 5))) {
600 
601  fillEneAndTimeDiff = false;
602  }
603 
604  // Fill these histograms only if the both PMTs are good
605  if (!(isBadChannel1 || isBadChannel2 || single_PMT)) {
606 
607  if (std::abs(energyRatio) > m_energyBalanceThreshold) {
608  energyBalModPartModule.push_back(module);
609  energyBalModPartPartition.push_back(partition1);
610  }
611 
612  if (std::abs(timeDiff) > m_timeBalanceThreshold
613  && (energy1 > m_energyThresholdForTime || energy2 > m_energyThresholdForTime)
614  && (isCollision || m_fillTimeHistograms)) {
615  timeBalModPartModule.push_back(module);
616  timeBalModPartPartition.push_back(partition1);
617  }
618 
619  energyBal[partition1].push_back(energyRatio);
620  energyBalModule[partition1].push_back(module);
621 
622  eneDiff[partition1].push_back(energyDiff);
623  eneDiffChannel[partition1].push_back(channel1);
624  eneDiffModule[partition1].push_back(module);
625 
626  eneDiff[partition2].push_back(-1.0 * energyDiff);
627  eneDiffChannel[partition2].push_back(channel2);
628  eneDiffModule[partition2].push_back(module);
629 
630  if (fillEneAndTimeDiff) {
631  sampEnergyDiff[partition1][sample].push_back(energyDiff);
632  }
633 
634  if ((energy1 > m_energyThresholdForTime || energy2 > m_energyThresholdForTime)
635  && (isCollision || m_fillTimeHistograms)) {
636 
637  timeBal[partition1].push_back(timeDiff);
638  timeBalModule[partition1].push_back(module);
639 
640  if (fillEneAndTimeDiff) {
641  sampTimeDiff[partition1][sample].push_back(timeDiff);
642  }
643  }
644 
645  moduleCorr[partition1].inputxy(module);
646  moduleCorr[PART_ALL].inputxy(module);
647  }
648 
649  // Store info for BCID plots.
650  // Count the number of cells over threshold per partition
651  ++nCellsOverThreshold[partition1];
652  }
653  }
654 
655  // Count total number of cells in a partition
656  ++nCells[partition1];
657 
658  // Accumulate total energy per sample per partition
659  energySample[partition1][sample] += energy;
660  }
661  }
662 
663  // Calculate totals for all samples and all partitions
664  for (int partition = 0; partition < PART_ALL; ++partition) {
665 
666  nCells[PART_ALL] += nCells[partition];
667  nBadCells[PART_ALL] += nBadCells[partition];
668 
669  nBadChannelsOnFly[PART_ALL] += nBadChannelsOnFly[partition];
670  nCellsOverThreshold[PART_ALL] += nCellsOverThreshold[partition];
671 
672  nMaskedChannelsDueDQ[PART_ALL] += nMaskedChannelsDueDQ[partition];
673  nMaskedCellsDueDQ[PART_ALL] += nMaskedCellsDueDQ[partition];
674 
675  for (int sample = 0; sample < SAMP_ALL; ++sample) {
676  energySample[partition][SAMP_ALL] += energySample[partition][sample];
677  energySample[PART_ALL][sample] += energySample[partition][sample];
678  }
679 
680  energySample[PART_ALL][SAMP_ALL] += energySample[partition][SAMP_ALL];
681  }
682 
683  if (msgLvl(MSG::DEBUG)) {
684 
685  msg(MSG::DEBUG) << "N Cells: "
686  << " " << nCells[PART_LBA]
687  << " " << nCells[PART_LBC]
688  << " " << nCells[PART_EBA]
689  << " " << nCells[PART_EBC]
690  << " " << nCells[PART_ALL] << endmsg;
691 
692  if (nCells[PART_ALL] > 0) {
693 
694  msg(MSG::DEBUG) << "AboveThr: "
695  << " " << nCellsOverThreshold[PART_LBA]
696  << " " << nCellsOverThreshold[PART_LBC]
697  << " " << nCellsOverThreshold[PART_EBA]
698  << " " << nCellsOverThreshold[PART_EBC]
699  << " " << nCellsOverThreshold[PART_ALL] << endmsg;
700 
701  msg(MSG::DEBUG) << "MaskOnFly:"
702  << " " << nBadChannelsOnFly[PART_LBA]
703  << " " << nBadChannelsOnFly[PART_LBC]
704  << " " << nBadChannelsOnFly[PART_EBA]
705  << " " << nBadChannelsOnFly[PART_EBC]
706  << " " << nBadChannelsOnFly[PART_ALL] << endmsg;
707 
708  msg(MSG::DEBUG) << "EneSampA:"
709  << " " << energySample[PART_LBA][TileID::SAMP_A]
710  << " " << energySample[PART_LBC][TileID::SAMP_A]
711  << " " << energySample[PART_EBA][TileID::SAMP_A]
712  << " " << energySample[PART_EBC][TileID::SAMP_A]
713  << " " << energySample[PART_ALL][TileID::SAMP_A] << endmsg;
714 
715  msg(MSG::DEBUG) << "EneSampB:"
716  << " " << energySample[PART_LBA][TileID::SAMP_B]
717  << " " << energySample[PART_LBC][TileID::SAMP_B]
718  << " " << energySample[PART_EBA][TileID::SAMP_B]
719  << " " << energySample[PART_EBC][TileID::SAMP_B]
720  << " " << energySample[PART_ALL][TileID::SAMP_B] << endmsg;
721 
722  msg(MSG::DEBUG) << "EneSampD:"
723  << " " << energySample[PART_LBA][TileID::SAMP_D]
724  << " " << energySample[PART_LBC][TileID::SAMP_D]
725  << " " << energySample[PART_EBA][TileID::SAMP_D]
726  << " " << energySample[PART_EBC][TileID::SAMP_D]
727  << " " << energySample[PART_ALL][TileID::SAMP_D] << endmsg;
728 
729  msg(MSG::DEBUG) << "EneSampE:"
730  << " " << energySample[PART_LBA][TileID::SAMP_E]
731  << " " << energySample[PART_LBC][TileID::SAMP_E]
732  << " " << energySample[PART_EBA][TileID::SAMP_E]
733  << " " << energySample[PART_EBC][TileID::SAMP_E]
734  << " " << energySample[PART_ALL][TileID::SAMP_E] << endmsg;
735 
736  msg(MSG::DEBUG) << "EneTotal:"
737  << " " << energySample[PART_LBA][SAMP_ALL]
738  << " " << energySample[PART_LBC][SAMP_ALL]
739  << " " << energySample[PART_EBA][SAMP_ALL]
740  << " " << energySample[PART_EBC][SAMP_ALL]
741  << " " << energySample[PART_ALL][SAMP_ALL] << endmsg;
742 
743  }
744  }
745 
746  std::vector<int> partitions(Tile::MAX_ROS);
747  std::iota(partitions.begin(), partitions.end(), 0);
748 
749  auto monPartition = Monitored::Collection("Partition", partitions);
750  auto monBadCells = Monitored::Collection("nBadCells", nBadCells);
751  fill("TileBadCell", monPartition, monBadCells);
752 
753  fillSynchronization(muonCells, l1TriggersIndices);
754 
755  if (!energyBalModPartPartition.empty()) {
756  for (int l1TriggerIdx : l1TriggersIndices) {
757  auto monModule = Monitored::Collection("module", energyBalModPartModule);
758  auto monPartion = Monitored::Collection("partition", energyBalModPartPartition);
759  fill(m_tools[m_energyBalModPartGroups[l1TriggerIdx]], monModule, monPartion);
760  }
761  }
762 
763  if (!timeBalModPartPartition.empty()) {
764  for (int l1TriggerIdx : l1TriggersIndices) {
765  auto monModule = Monitored::Collection("module", timeBalModPartModule);
766  auto monPartion = Monitored::Collection("partition", timeBalModPartPartition);
767  fill(m_tools[m_timeBalModPartGroups[l1TriggerIdx]], monModule, monPartion);
768  }
769  }
770 
771  unsigned int bcid = eventInfo->bcid();
772 
773  for (unsigned int partition = 0; partition < Tile::MAX_ROS - 1; ++partition) {
774 
775  if (!maskedOnFlyDrawers[partition].empty()) {
776  auto monModule = Monitored::Collection("module", maskedOnFlyDrawers[partition]);
777  auto monChannel = Monitored::Collection("channel", maskedOnFlyChannel[partition]);
778  fill(m_tools[m_maskedOnFlyGroups[partition]], monModule, monChannel);
779  }
780 
781  if (!negOccupModule[partition].empty()) {
782  auto monModule = Monitored::Collection("module", negOccupModule[partition]);
783  auto monChannel = Monitored::Collection("channel", negOccupChannel[partition]);
784  fill(m_tools[m_negOccupGroups[partition]], monModule, monChannel);
785  }
786 
787  if (!energyBalModule[partition].empty()) {
788  auto monModule = Monitored::Collection("module", energyBalModule[partition]);
789  auto monEnergyBal = Monitored::Collection("energyBalance", energyBal[partition]);
790  fill(m_tools[m_energyBalGroups[partition]], monModule, monEnergyBal);
791  }
792 
793  if (!timeBalModule[partition].empty()) {
794  auto monModule = Monitored::Collection("module", timeBalModule[partition]);
795  auto monTimeBal = Monitored::Collection("timeBalance", timeBal[partition]);
796  fill(m_tools[m_timeBalGroups[partition]], monModule, monTimeBal);
797  }
798 
799  if (!chanTimeDrawer[partition].empty()) {
800  auto monTime = Monitored::Collection("time", chanTime[partition]);
801  auto monModule = Monitored::Collection("module", chanTimeDrawer[partition]);
802  auto monChannel = Monitored::Collection("channel", chanTimeChannel[partition]);
803  auto monDigitizer = Monitored::Collection("digitizer", chanTimeDigitizer[partition]);
804  for (int l1TriggerIdx : l1TriggersIndices) {
805  fill(m_tools[m_chanTimeGroups[partition][l1TriggerIdx]], monModule, monChannel, monTime);
806  fill(m_tools[m_digiTimeGroups[partition][l1TriggerIdx]], monModule, monDigitizer, monTime);
807  }
808  }
809 
810  if (!detailOccupModule[partition].empty()) {
811  auto monModule = Monitored::Collection("module", detailOccupModule[partition]);
812  auto monChannel = Monitored::Collection("channel", detailOccupChannel[partition]);
813  auto monEnergies = Monitored::Collection("energy", detailOccupEnergies[partition]);
814  for (int l1TriggerIdx : l1TriggersIndices) {
815  fill(m_tools[m_detailOccupGroups[partition][l1TriggerIdx]], monModule, monChannel, monEnergies);
816  }
817  }
818 
819  if (!overThrOccupModule[partition].empty()) {
820  auto monModule = Monitored::Collection("module", overThrOccupModule[partition]);
821  auto monChannel = Monitored::Collection("channel", overThrOccupChannel[partition]);
822  auto monWeight = Monitored::Collection("weight", overThrOccupWeight[partition]);
823  for (int l1TriggerIdx : l1TriggersIndices) {
824  fill(m_tools[m_overThrOccupGroups[partition][l1TriggerIdx]], monModule, monChannel, monWeight);
825  }
826  }
827 
828  if (!overThr30GeVOccupModule[partition].empty()) {
829  auto monModule = Monitored::Collection("module", overThr30GeVOccupModule[partition]);
830  auto monChannel = Monitored::Collection("channel", overThr30GeVOccupChannel[partition]);
831  for (int l1TriggerIdx : l1TriggersIndices) {
832  fill(m_tools[m_overThr30GeVOccupGroups[partition][l1TriggerIdx]], monModule, monChannel);
833  }
834  }
835 
836  if (!overThr300GeVOccupModule[partition].empty()) {
837  auto monModule = Monitored::Collection("module", overThr300GeVOccupModule[partition]);
838  auto monChannel = Monitored::Collection("channel", overThr300GeVOccupChannel[partition]);
839  for (int l1TriggerIdx : l1TriggersIndices) {
840  fill(m_tools[m_overThr300GeVOccupGroups[partition][l1TriggerIdx]], monModule, monChannel);
841  }
842  }
843 
844  if (!eneDiff[partition].empty()) {
845  auto monEnergyDiff = Monitored::Collection("energyDiff", eneDiff[partition]);
846  auto monModule = Monitored::Collection("module", eneDiffModule[partition]);
847  auto monChannel = Monitored::Collection("channel", eneDiffChannel[partition]);
848  for (int l1TriggerIdx : l1TriggersIndices) {
849  fill(m_tools[m_eneDiffChanModGroups[partition][l1TriggerIdx]], monModule, monChannel, monEnergyDiff);
850  }
851  }
852 
853  for (unsigned int gain = 0; gain < Tile::MAX_GAIN; ++gain) {
854  if (!overThrOccupGainModule[partition][gain].empty()) {
855  auto monModule = Monitored::Collection("module", overThrOccupGainModule[partition][gain]);
856  auto monChannel = Monitored::Collection("channel", overThrOccupGainChannel[partition][gain]);
857  auto monWeight = Monitored::Collection("weight", overThrOccupGainWeight[partition][gain]);
858  for (int l1TriggerIdx : l1TriggersIndices) {
859  fill(m_tools[m_overThrOccupGainGroups[partition][gain][l1TriggerIdx]], monModule, monChannel, monWeight);
860  }
861  }
862 
863  if (!detailOccupGainModule[partition][gain].empty()) {
864  auto monModule = Monitored::Collection("module", detailOccupGainModule[partition][gain]);
865  auto monChannel = Monitored::Collection("channel", detailOccupGainChannel[partition][gain]);
866  auto monEnergies = Monitored::Collection("energy", detailOccupGainEnergies[partition][gain]);
867  for (int l1TriggerIdx : l1TriggersIndices) {
868  fill(m_tools[m_detailOccupGainGroups[partition][gain][l1TriggerIdx]], monModule, monChannel, monEnergies);
869  }
870  }
871  }
872 
873  if (m_fillChannelTimeHistograms) {
874  for (unsigned int sample = 0; sample < SAMP_ALL; ++sample) {
875  if (!sampChanTime[partition][sample].empty()) {
876  auto monChanTime = Monitored::Collection("time", sampChanTime[partition][sample]);
877  for (int l1TriggerIdx : l1TriggersIndices) {
878  fill(m_tools[m_chanTimeSampGroups[partition][sample][l1TriggerIdx]], monChanTime);
879  fill(m_tools[m_chanTimeSampGroups[partition][SAMP_ALL][l1TriggerIdx]], monChanTime);
880  }
881  }
882  }
883  }
884 
885  if (m_fillTimeAndEnergyDiffHistograms) {
886  for (unsigned int sample = 0; sample < SAMP_ALL; ++sample) {
887  if (!sampEnergyDiff[partition][sample].empty()) {
888  auto monEneDiff = Monitored::Collection("energyDiff", sampEnergyDiff[partition][sample]);
889  for (int l1TriggerIdx : l1TriggersIndices) {
890  fill(m_tools[m_eneDiffSampGroups[partition][sample][l1TriggerIdx]], monEneDiff);
891  fill(m_tools[m_eneDiffSampGroups[partition][SAMP_ALL][l1TriggerIdx]], monEneDiff);
892  }
893  }
894 
895  if (!sampTimeDiff[partition][sample].empty()) {
896  auto monTimeDiff = Monitored::Collection("timeDiff", sampTimeDiff[partition][sample]);
897  for (int l1TriggerIdx : l1TriggersIndices) {
898  fill(m_tools[m_timeDiffSampGroups[partition][sample][l1TriggerIdx]], monTimeDiff);
899  fill(m_tools[m_timeDiffSampGroups[partition][SAMP_ALL][l1TriggerIdx]], monTimeDiff);
900  }
901  }
902  }
903  }
904 
905  }
906 
907  for (int partition = 0; partition < MAX_PART; ++partition) {
908  auto monMaskedDueDQ = Monitored::Scalar<int>("nMaskedChannelsDueDQ", nMaskedChannelsDueDQ[partition]);
909  fill(m_tools[m_maskedDueDQGroups[partition]], lumiBlock, monMaskedDueDQ);
910 
911  auto monMaskedCellsDueDQ = Monitored::Scalar<int>("nMaskedCellsDueDQ", nMaskedCellsDueDQ[partition]);
912  fill(m_tools[m_maskedCellsDueDQGroups[partition]], lumiBlock, monMaskedCellsDueDQ);
913 
914  auto monMaskedOnFly = Monitored::Scalar<int>("nMaskedChannelsOnFly", nBadChannelsOnFly[partition]);
915  fill(m_tools[m_maskedOnFlyLBGroups[partition]], lumiBlock, monMaskedOnFly);
916 
917  auto monMaskedCellsOnFly = Monitored::Scalar<int>("nMaskedCells", nBadCells[partition]);
918  fill(m_tools[m_maskedCellsLBGroups[partition]], lumiBlock, monMaskedCellsOnFly);
919 
920 
921  if (moduleCorr[partition].numberOfPairs() > 0) {
922  const PairBuilder::PairVector pairs = moduleCorr[partition].pairs();
923  auto monModule1 = Monitored::Collection("firstModule", pairs, [] (const PairBuilder::XYPair& p) {return (double) p.first;});
924  auto monModule2 = Monitored::Collection("secondModule", pairs, [] (const PairBuilder::XYPair& p) {return (double) p.second;});
925  std::vector<float> weight(moduleCorr[partition].numberOfPairs(), moduleCorr[partition].weight());
926  auto monWeight = Monitored::Collection("weight", weight);
927  for (int l1TriggerIdx : l1TriggersIndices) {
928  fill(m_tools[m_moduleCorrGroups[partition][l1TriggerIdx]], monModule1, monModule2, monWeight);
929  }
930  }
931 
932  for (int l1TriggerIdx : l1TriggersIndices) {
933  auto monCellsNumber = Monitored::Scalar<float>("nCells", nCells[partition]);
934  fill(m_tools[m_nCellsGroups[partition][l1TriggerIdx]], lumiBlock, monCellsNumber);
935 
936  auto monBCID = Monitored::Scalar<unsigned int>("BCID", bcid);
937  auto monCellsNumberOvThr = Monitored::Scalar<float>("nCells", nCellsOverThreshold[partition]);
938  fill(m_tools[m_nCellsOverThrGroups[partition][l1TriggerIdx]], monBCID, monCellsNumberOvThr);
939  }
940 
941  if (partition > 1) { // Fill SampE energy for EB
942  for (int l1TriggerIdx : l1TriggersIndices) {
943  auto monEnergy = Monitored::Scalar<float>("energy", energySample[partition][TileID::SAMP_E]);
944  fill(m_tools[m_energySampEGroups[partition][l1TriggerIdx]], monEnergy);
945  }
946  }
947  }
948 
949  for (unsigned int sample = 0; sample < SAMP_ALL; ++sample) {
950  if (!occupEnergy[sample].empty()) {
951  auto monEta = Monitored::Collection("eta", occupEta[sample]);
952  auto monPhi = Monitored::Collection("phi", occupPhi[sample]);
953  auto monEnergy = Monitored::Collection("energy", occupEnergy[sample]);
954  for (int l1TriggerIdx : l1TriggersIndices) {
955  fill(m_tools[m_eneEtaPhiGroups[sample][l1TriggerIdx]], monEta, monPhi, monEnergy);
956  fill(m_tools[m_eneEtaPhiGroups[SAMP_ALL][l1TriggerIdx]], monEta, monPhi, monEnergy);
957  }
958  }
959 
960  if (!overThrOccupEta[sample].empty()) {
961  auto monEta = Monitored::Collection("eta", overThrOccupEta[sample]);
962  auto monPhi = Monitored::Collection("phi", overThrOccupPhi[sample]);
963  for (int l1TriggerIdx : l1TriggersIndices) {
964  fill(m_tools[m_overThrEtaPhiGroups[sample][l1TriggerIdx]], monEta, monPhi);
965  fill(m_tools[m_overThrEtaPhiGroups[SAMP_ALL][l1TriggerIdx]], monEta, monPhi);
966  }
967  }
968  }
969 
970 
971 
972  fill("TileCellMonExecuteTime", timer);
973 
974  return StatusCode::SUCCESS;
975 }
976 
977 
978 void TileCellMonitorAlgorithm::fillMaskedInDB(const TileBadChannels* badChannels) const {
979 
980  using Tile = TileCalibUtils;
981 
982  std::vector<HWIdentifier>::const_iterator adc_it = m_tileHWID->adc_begin();
983  std::vector<HWIdentifier>::const_iterator adc_end = m_tileHWID->adc_end();
984 
985  std::vector<int> drawers[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
986  std::vector<int> channels[Tile::MAX_ROS - 1][Tile::MAX_GAIN];
987 
988  for (; adc_it != adc_end; ++adc_it) {
989  HWIdentifier adc_id(*adc_it);
990 
991  if (badChannels->getAdcStatus(adc_id).isBad()) {
992 
993  unsigned int partition = m_tileHWID->ros(adc_id) - 1; // ROS - 1
994  unsigned int drawer = m_tileHWID->drawer(adc_id);
995  unsigned int channel = m_tileHWID->channel(adc_id);
996  unsigned int adc = m_tileHWID->adc(adc_id);
997 
998  drawers[partition][adc].push_back(drawer);
999  channels[partition][adc].push_back(channel);
1000 
1001  }
1002  }
1003 
1004  for (unsigned int partition = 0; partition < Tile::MAX_ROS - 1; ++partition) {
1005  for (unsigned int gain = 0; gain < Tile::MAX_GAIN; ++gain) {
1006  if (!drawers[partition][gain].empty()) {
1007 
1008  auto monModule = Monitored::Collection("module", drawers[partition][gain]);
1009  auto monChannel = Monitored::Collection("channel", channels[partition][gain]);
1010  fill(m_tools[m_maskedGroups[partition][gain]], monModule, monChannel);
1011 
1012  }
1013  }
1014  }
1015 }
1016 
1017 
1018 void TileCellMonitorAlgorithm::fillSynchronization(const std::vector<const CaloCell*>& cells,
1019  const std::vector<int>& l1TriggersIndices) const {
1020 
1021  std::vector<float> timeDifference;
1022 
1023  int size = cells.size();
1024  if (size > 1) {
1025  for (int i = 1; i < size; ++i) {
1026  float x1 = cells[i]->x();
1027  float y1 = cells[i]->y();
1028  float z1 = cells[i]->z();
1029  float time1 = cells[i]->time();
1030 
1031  for (int j = 0; j < i; ++j) {
1032  float x2 = cells[j]->x();
1033  float y2 = cells[j]->y();
1034  float z2 = cells[j]->z();
1035  float time2 = cells[j]->time();
1036 
1037  float timeMeasured = (y2 > y1) ? time1 - time2 : time2 - time1;
1038 
1039  float distance = sqrt( (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2) + (z1 - z2) * (z1 - z2));
1040  float timeExpected = distance / 300.;
1041 
1042  timeDifference.push_back(timeExpected - timeMeasured);
1043  }
1044  }
1045 
1046  auto monTimeDifference = Monitored::Collection("timeDifference", timeDifference);
1047  for (int l1TriggerIdx : l1TriggersIndices) {
1048  fill(m_tools[m_cellSynchGroups[l1TriggerIdx]], monTimeDifference);
1049  }
1050  }
1051 }
1052 
1053 int TileCellMonitorAlgorithm::getDigitizer(int channel) const {
1054 
1055  // Conversion from channel number to digitizer number
1056  static const int channel2digitizer[48] = {8, 8, 8, 8, 8, 8,
1057  7, 7, 7, 7, 7, 7,
1058  6, 6, 6, 6, 6, 6,
1059  5, 5, 5, 5, 5, 5,
1060  4, 4, 4, 4, 4, 4,
1061  3, 3, 3, 3, 3, 3,
1062  2, 2, 2, 2, 2, 2,
1063  1, 1, 1, 1, 1, 1};
1064 
1065  return channel2digitizer[channel];
1066 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileCellMonitorAlgorithm::m_overThrOccupGainGroups
std::vector< std::vector< std::vector< int > > > m_overThrOccupGainGroups
Definition: TileCellMonitorAlgorithm.h:129
TileCell::badcell
virtual bool badcell(void) const override final
check if whole cell is bad (i.e.
Definition: TileCell.h:220
TileCell
Definition: TileCell.h:57
TileCellMonitorAlgorithm::m_cellSynchGroups
std::vector< int > m_cellSynchGroups
Definition: TileCellMonitorAlgorithm.h:110
TileCellMonitorAlgorithm::m_energyRangeForMuon
Gaudi::Property< std::vector< float > > m_energyRangeForMuon
Definition: TileCellMonitorAlgorithm.h:77
PairBuilder::PairVector
std::vector< XYPair > PairVector
Definition: PairBuilder.h:36
CaloDetDescrElement::onl2
IdentifierHash onl2() const
cell online identifier 2
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:408
RunTileCalibRec.cells
cells
Definition: RunTileCalibRec.py:271
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
CXXUTILS_TRAPPING_FP
#define CXXUTILS_TRAPPING_FP
Definition: trapping_fp.h:24
TileMonitorAlgorithm::getL1TriggerIndices
std::vector< int > getL1TriggerIndices(uint32_t lvl1TriggerType) const
Return indices of histograms to be filled according fired L1 trigger type.
Definition: TileMonitorAlgorithm.cxx:67
TileCell::time1
float time1(void) const
get time of first PMT
Definition: TileCell.h:198
TileCablingService::TileGap_connected
bool TileGap_connected(const Identifier &id) const
Definition: TileCablingService.cxx:1756
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:17
Tile_Base_ID::SAMP_B
@ SAMP_B
Definition: Tile_Base_ID.h:54
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
TileCellMonitorAlgorithm::m_timeBalanceThreshold
Gaudi::Property< float > m_timeBalanceThreshold
Definition: TileCellMonitorAlgorithm.h:59
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TileMonitorAlgorithm::PART_EBA
@ PART_EBA
Definition: TileMonitorAlgorithm.h:46
TileCellMonitorAlgorithm::m_detailOccupGroups
std::vector< std::vector< int > > m_detailOccupGroups
Definition: TileCellMonitorAlgorithm.h:124
TileMonitorAlgorithm::PART_EBC
@ PART_EBC
Definition: TileMonitorAlgorithm.h:47
TileCellMonitorAlgorithm::m_badChannelsKey
SG::ReadCondHandleKey< TileBadChannels > m_badChannelsKey
Name of TileBadChannels in condition store.
Definition: TileCellMonitorAlgorithm.h:98
TileCell::time2
float time2(void) const
get time of second PMT
Definition: TileCell.h:200
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
TileCellMonitorAlgorithm::getDigitizer
int getDigitizer(int channel) const
Definition: TileCellMonitorAlgorithm.cxx:1053
TileCellMonitorAlgorithm::m_energyThresholdForGapScint
Gaudi::Property< float > m_energyThresholdForGapScint
Definition: TileCellMonitorAlgorithm.h:62
Tile_Base_ID::SAMP_A
@ SAMP_A
Definition: Tile_Base_ID.h:53
TileCell::ene1
float ene1(void) const
get energy of first PMT
Definition: TileCell.h:193
plotBeamSpotCompare.x2
x2
Definition: plotBeamSpotCompare.py:218
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
TileCell::badch1
bool badch1(void) const
check if first PMT is in bad channel list and masked
Definition: TileCell.h:215
PairBuilder::pairs
const PairVector & pairs() const
Return the pairs as a vector of pairs of integers.
Definition: PairBuilder.cxx:42
TileCellMonitorAlgorithm::m_fillTimeHistograms
Gaudi::Property< bool > m_fillTimeHistograms
Definition: TileCellMonitorAlgorithm.h:65
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
CaloTime_fillDB.gain2
gain2
Definition: CaloTime_fillDB.py:357
TileCellMonitorAlgorithm::m_chanTimeGroups
std::vector< std::vector< int > > m_chanTimeGroups
Definition: TileCellMonitorAlgorithm.h:120
Tile_Base_ID::side
int side(const Identifier &id) const
Definition: Tile_Base_ID.cxx:153
Tile_Base_ID::sample
int sample(const Identifier &id) const
Definition: Tile_Base_ID.cxx:171
PairBuilder
Class to build pairs of XY values.
Definition: PairBuilder.h:30
TileCellMonitorAlgorithm::m_digiTimeGroups
std::vector< std::vector< int > > m_digiTimeGroups
Definition: TileCellMonitorAlgorithm.h:121
TileHWID::adc_begin
std::vector< HWIdentifier >::const_iterator adc_begin(void) const
begin iterator for ADC Identifiers
Definition: TileHWID.h:308
AthCommonMsg< Gaudi::Algorithm >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TileCellMonitorAlgorithm::m_energyLimitForTime
Gaudi::Property< float > m_energyLimitForTime
Definition: TileCellMonitorAlgorithm.h:53
PairBuilder::XYPair
std::pair< int, int > XYPair
Definition: PairBuilder.h:35
Tile_Base_ID::GAPDET
@ GAPDET
Definition: Tile_Base_ID.h:48
TileCalibUtils.h
TileCellMonitorAlgorithm::m_nCellsGroups
std::vector< std::vector< int > > m_nCellsGroups
Definition: TileCellMonitorAlgorithm.h:122
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
TileCellMonitorAlgorithm::m_maskedCellsLBGroups
std::vector< int > m_maskedCellsLBGroups
Definition: TileCellMonitorAlgorithm.h:115
Tile_Base_ID::SAMP_E
@ SAMP_E
Definition: Tile_Base_ID.h:55
TileMonitorAlgorithm::MAX_SAMP
@ MAX_SAMP
Definition: TileMonitorAlgorithm.h:40
Tile_Base_ID::system
int system(const Identifier &id) const
Definition: Tile_Base_ID.cxx:141
TileCellMonitorAlgorithm::m_negativeEnergyThreshold
Gaudi::Property< float > m_negativeEnergyThreshold
Definition: TileCellMonitorAlgorithm.h:47
TileHWID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: TileHWID.h:314
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileCellMonitorAlgorithm::m_maskedOnFlyGroups
std::vector< int > m_maskedOnFlyGroups
Definition: TileCellMonitorAlgorithm.h:111
ReadCondHandle.h
makeTRTBarrelCans.y1
tuple y1
Definition: makeTRTBarrelCans.py:15
TileCellMonitorAlgorithm::m_maskedGroups
std::vector< std::vector< int > > m_maskedGroups
Definition: TileCellMonitorAlgorithm.h:116
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
Tile_Base_ID::region
int region(int section, int side) const
Definition: Tile_Base_ID.cxx:119
python.utils.AtlRunQueryTimer.timer
def timer(name, disabled=False)
Definition: AtlRunQueryTimer.py:86
TileID.h
TileCellMonitorAlgorithm::fillSynchronization
void fillSynchronization(const std::vector< const CaloCell * > &cells, const std::vector< int > &l1TriggersIndices) const
Definition: TileCellMonitorAlgorithm.cxx:1018
dq_defect_copy_defect_database.channels
def channels
Definition: dq_defect_copy_defect_database.py:56
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
Monitored::Collection
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
Definition: MonitoredCollection.h:38
Tile_Base_ID::SAMP_C
@ SAMP_C
Definition: Tile_Base_ID.h:54
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
python.CreateTierZeroArgdict.pairs
pairs
Definition: CreateTierZeroArgdict.py:201
TileCellMonitorAlgorithm::m_overThrEtaPhiGroups
std::vector< std::vector< int > > m_overThrEtaPhiGroups
Definition: TileCellMonitorAlgorithm.h:138
dqt_zlumi_pandas.weight
int weight
Definition: dqt_zlumi_pandas.py:189
TileMonitorAlgorithm::SAMP_ALL
@ SAMP_ALL
Definition: TileMonitorAlgorithm.h:40
TileCellMonitorAlgorithm::m_fillTimeAndEnergyDiffHistograms
Gaudi::Property< bool > m_fillTimeAndEnergyDiffHistograms
Definition: TileCellMonitorAlgorithm.h:74
TileMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: TileMonitorAlgorithm.cxx:10
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:274
CaloDetDescrElement::onl1
IdentifierHash onl1() const
cell online identifier 1
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:404
CaloGain::INVALIDGAIN
@ INVALIDGAIN
Definition: CaloGain.h:18
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
python.PyAthena.module
module
Definition: PyAthena.py:131
TileCell::timeDiff
float timeDiff(void) const
get time diff for two PMTs (data member)
Definition: TileCell.h:190
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TileCell::qual2
uint8_t qual2(void) const
get quality of second PMT (data member)
Definition: TileCell.h:206
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
Tile
Definition: TileVolumeBuilder.h:43
TileCellMonitorAlgorithm::m_timeRangeForMuon
Gaudi::Property< std::vector< float > > m_timeRangeForMuon
Definition: TileCellMonitorAlgorithm.h:80
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
TileCellMonitorAlgorithm::fillMaskedInDB
void fillMaskedInDB(const TileBadChannels *badChannels) const
Definition: TileCellMonitorAlgorithm.cxx:978
TileCellMonitorAlgorithm::m_energyBalanceThreshold
Gaudi::Property< float > m_energyBalanceThreshold
Definition: TileCellMonitorAlgorithm.h:56
TileHWID.h
TileCellMonitorAlgorithm::m_energyThreshold
Gaudi::Property< float > m_energyThreshold
Definition: TileCellMonitorAlgorithm.h:44
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
TileCellMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: TileCellMonitorAlgorithm.cxx:123
Tile_Base_ID::module
int module(const Identifier &id) const
Definition: Tile_Base_ID.cxx:159
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:116
xAOD::nCells
setRawEt setRawPhi nCells
Definition: TrigCaloCluster_v1.cxx:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
TileCellMonitorAlgorithm::m_timeDiffSampGroups
std::vector< std::vector< std::vector< int > > > m_timeDiffSampGroups
Definition: TileCellMonitorAlgorithm.h:135
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
TileCellMonitorAlgorithm::m_overThr30GeVOccupGroups
std::vector< std::vector< int > > m_overThr30GeVOccupGroups
Definition: TileCellMonitorAlgorithm.h:126
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
TileCellMonitorAlgorithm::m_maskedCellsDueDQGroups
std::vector< int > m_maskedCellsDueDQGroups
Definition: TileCellMonitorAlgorithm.h:113
CaloCell::caloDDE
const CaloDetDescrElement * caloDDE() const
get pointer to CaloDetDescrElement (data member)
Definition: CaloCell.h:305
makeTRTBarrelCans.y2
tuple y2
Definition: makeTRTBarrelCans.py:18
TileCell::badch2
bool badch2(void) const
check if second PMT is in bad channel list and masked
Definition: TileCell.h:218
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
TileCellMonitorAlgorithm::m_overThr300GeVOccupGroups
std::vector< std::vector< int > > m_overThr300GeVOccupGroups
Definition: TileCellMonitorAlgorithm.h:127
TileCellMonitorAlgorithm::m_caloCellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_caloCellContainerKey
Definition: TileCellMonitorAlgorithm.h:101
TileCell.h
TileMonitorAlgorithm::PART_ALL
@ PART_ALL
Definition: TileMonitorAlgorithm.h:47
TileCellMonitorAlgorithm::m_timeBalGroups
std::vector< int > m_timeBalGroups
Definition: TileCellMonitorAlgorithm.h:141
TileMonitorAlgorithm::PART_LBC
@ PART_LBC
Definition: TileMonitorAlgorithm.h:46
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:695
TileCell::qbit1
uint8_t qbit1(void) const
get quality bits of first PMT (data member)
Definition: TileCell.h:209
TileCellMonitorAlgorithm::m_nCellsOverThrGroups
std::vector< std::vector< int > > m_nCellsOverThrGroups
Definition: TileCellMonitorAlgorithm.h:123
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
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
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
TileCell::gain1
int gain1(void) const
get gain of first PMT
Definition: TileCell.cxx:182
TileCellMonitorAlgorithm::m_energyBalModPartGroups
std::vector< int > m_energyBalModPartGroups
Definition: TileCellMonitorAlgorithm.h:108
DeMoScan.partitions
dictionary partitions
Definition: DeMoScan.py:67
TileCell::eneDiff
float eneDiff(void) const
all get methods
Definition: TileCell.h:188
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TileCellMonitorAlgorithm::m_energyThresholdForGain
Gaudi::Property< std::vector< float > > m_energyThresholdForGain
Definition: TileCellMonitorAlgorithm.h:83
TileDQstatus::isAdcDQgood
bool isAdcDQgood(int partition, int drawer, int ch, int gain) const
returns status of single ADC returns False if there are any errors
Definition: TileDQstatus.cxx:178
CaloTime_fillDB.gain1
gain1
Definition: CaloTime_fillDB.py:356
trapping_fp.h
Tell the compiler to optimize assuming that FP may trap.
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
TileCellMonitorAlgorithm::m_energySampEGroups
std::vector< std::vector< int > > m_energySampEGroups
Definition: TileCellMonitorAlgorithm.h:118
TileBadChannels
Condition object to keep Tile channel and ADC status.
Definition: TileBadChannels.h:24
TileHWID::channel_id
HWIdentifier channel_id(int ros, int drawer, int channel) const
channel HWIdentifer
Definition: TileHWID.cxx:199
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition: EventInfo_v1.cxx:133
Units.h
Wrapper to avoid constant divisions when using units.
TileCellMonitorAlgorithm::m_detailOccupGainGroups
std::vector< std::vector< std::vector< int > > > m_detailOccupGainGroups
Definition: TileCellMonitorAlgorithm.h:130
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
TileBadChannels::getAdcStatus
const TileBchStatus & getAdcStatus(const HWIdentifier adc_id) const
Return Tile ADC status.
Definition: TileBadChannels.cxx:24
TileCellMonitorAlgorithm::m_eneDiffSampGroups
std::vector< std::vector< std::vector< int > > > m_eneDiffSampGroups
Definition: TileCellMonitorAlgorithm.h:134
TileHWID::adc_id
HWIdentifier adc_id(int ros, int drawer, int channel, int adc) const
adc HWIdentifer
Definition: TileHWID.cxx:229
TileCellMonitorAlgorithm::m_eneDiffChanModGroups
std::vector< std::vector< int > > m_eneDiffChanModGroups
Definition: TileCellMonitorAlgorithm.h:128
TileCell::qbit2
uint8_t qbit2(void) const
get quality bits of second PMT (data member)
Definition: TileCell.h:212
Tile_Base_ID::SAMP_D
@ SAMP_D
Definition: Tile_Base_ID.h:55
TileCell::gain2
int gain2(void) const
get gain of second PMT
Definition: TileCell.cxx:189
TileCell::ene2
float ene2(void) const
get energy of second PMT
Definition: TileCell.h:195
TileCellMonitorAlgorithm::m_maskedOnFlyLBGroups
std::vector< int > m_maskedOnFlyLBGroups
Definition: TileCellMonitorAlgorithm.h:114
TileCablingService::C10_connected
static bool C10_connected(int module)
Definition: TileCablingService.cxx:1779
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
TileMonitorAlgorithm::getNumberOfL1Triggers
int getNumberOfL1Triggers(void) const
Return number of L1 triggers for which histograms should be filled.
Definition: TileMonitorAlgorithm.h:66
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
TileCellMonitorAlgorithm::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileCellMonitorAlgorithm.h:105
TileCellMonitorAlgorithm::m_moduleCorrGroups
std::vector< std::vector< int > > m_moduleCorrGroups
Definition: TileCellMonitorAlgorithm.h:119
Tile_Base_ID::to_string
std::string to_string(const Identifier &id, int level=0) const
Definition: Tile_Base_ID.cxx:52
TileMonitorAlgorithm::MAX_PART
@ MAX_PART
Definition: TileMonitorAlgorithm.h:47
PairBuilder::inputxy
void inputxy(const int ystrip)
Input a new y value.
Definition: PairBuilder.cxx:31
DEBUG
#define DEBUG
Definition: page_access.h:11
F
#define F(x, y, z)
Definition: MD5.cxx:112
python.Classes.TileCalibUtils
TileCalibUtils
Definition: TileCalib/TileCalibBlobObjs/python/Classes.py:5
TileCellMonitorAlgorithm::m_energyThresholdForTime
Gaudi::Property< float > m_energyThresholdForTime
Definition: TileCellMonitorAlgorithm.h:50
AthCommonMsg< Gaudi::Algorithm >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TileCellMonitorAlgorithm.h
StateLessPT_NewConfig.partition
partition
Definition: StateLessPT_NewConfig.py:49
TileCellMonitorAlgorithm::m_fillChannelTimeHistograms
Gaudi::Property< bool > m_fillChannelTimeHistograms
Definition: TileCellMonitorAlgorithm.h:68
TileCellMonitorAlgorithm::m_maskedDueDQGroups
std::vector< int > m_maskedDueDQGroups
Definition: TileCellMonitorAlgorithm.h:112
TileCell::qual1
uint8_t qual1(void) const
get quality of first PMT (data member)
Definition: TileCell.h:203
python.SystemOfUnits.ns
int ns
Definition: SystemOfUnits.py:130
TileCellMonitorAlgorithm::m_negOccupGroups
std::vector< int > m_negOccupGroups
Definition: TileCellMonitorAlgorithm.h:140
TileCellMonitorAlgorithm::m_chanTimeSampGroups
std::vector< std::vector< std::vector< int > > > m_chanTimeSampGroups
Definition: TileCellMonitorAlgorithm.h:133
TileCellMonitorAlgorithm::m_eneEtaPhiGroups
std::vector< std::vector< int > > m_eneEtaPhiGroups
Definition: TileCellMonitorAlgorithm.h:137
TileCellMonitorAlgorithm::m_cabling
const TileCablingService * m_cabling
Definition: TileCellMonitorAlgorithm.h:106
PairBuilder.h
TileCellMonitorAlgorithm::m_energyBalGroups
std::vector< int > m_energyBalGroups
Definition: TileCellMonitorAlgorithm.h:142
TileCellMonitorAlgorithm::m_overThrOccupGroups
std::vector< std::vector< int > > m_overThrOccupGroups
Definition: TileCellMonitorAlgorithm.h:125
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:13
Tile_Base_ID::section
int section(const Identifier &id) const
Definition: Tile_Base_ID.cxx:147
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
ReadHandle.h
Handle class for reading from StoreGate.
TileCellMonitorAlgorithm::m_tileID
const TileID * m_tileID
Definition: TileCellMonitorAlgorithm.h:104
xAOD::lumiBlock
setTeId lumiBlock
Definition: L2StandAloneMuon_v1.cxx:327
TileCellMonitorAlgorithm::m_cablingSvc
ServiceHandle< TileCablingSvc > m_cablingSvc
Name of Tile cabling service.
Definition: TileCellMonitorAlgorithm.h:89
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
TileCellMonitorAlgorithm::m_fillGapScintHistograms
Gaudi::Property< bool > m_fillGapScintHistograms
Definition: TileCellMonitorAlgorithm.h:71
TileHWID::adc_end
std::vector< HWIdentifier >::const_iterator adc_end(void) const
end iterator for ADC Identifiers
Definition: TileHWID.h:312
TileCellMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: TileCellMonitorAlgorithm.cxx:21
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
TileCellMonitorAlgorithm::m_timeBalModPartGroups
std::vector< int > m_timeBalModPartGroups
Definition: TileCellMonitorAlgorithm.h:109
TileMonitorAlgorithm::PART_LBA
@ PART_LBA
Definition: TileMonitorAlgorithm.h:46
TileCellMonitorAlgorithm::m_DQstatusKey
SG::ReadHandleKey< TileDQstatus > m_DQstatusKey
Definition: TileCellMonitorAlgorithm.h:92
SG::ReadCondHandle::cptr
const_pointer_type cptr()
Definition: ReadCondHandle.h:71
TileCellMonitorAlgorithm::m_energyGapScintGroups
std::vector< std::vector< std::vector< int > > > m_energyGapScintGroups
Definition: TileCellMonitorAlgorithm.h:131
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Sat Mar 29 2025 21:19:37 for ATLAS Offline Software by   doxygen 1.8.18