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