ATLAS Offline Software
TileTBMonitorAlgorithm.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
8 #include "TileEvent/TileCell.h"
9 
10 #include "CaloIdentifier/TileID.h"
12 
13 #include "StoreGate/ReadHandle.h"
14 
15 #include <algorithm>
16 
18 
19  ATH_MSG_INFO("in initialize()");
21 
22  ATH_CHECK( m_cablingSvc.retrieve() );
23 
25 
28 
30 
31  std::vector<std::string> modules;
32  for (int fragID : m_fragIDs) {
33  int ros = fragID >> 8;
34  int drawer = fragID & 0x3F;
35  modules.push_back(TileCalibUtils::getDrawerString(ros, drawer));
37  }
38 
39  using namespace Monitored;
40  m_timeGroups = buildToolMap<int>(m_tools, "TileTBChannelTime", modules);
41  m_cellMapGroups = buildToolMap<int>(m_tools, "TileTBCellMap", modules);
42 
43  std::ostringstream os;
44  if ( m_fragIDs.size() != 0) {
45  std::sort(m_fragIDs.begin(), m_fragIDs.end());
46  for (int fragID : m_fragIDs) {
47  unsigned int ros = fragID >> 8;
48  unsigned int drawer = fragID & 0xFF;
50  os << " " << module << "/0x" << std::hex << fragID << std::dec;
51  }
52  } else {
53  os << "NONE";
54  }
55 
56  ATH_MSG_INFO("Monitored modules/frag ID:" << os.str());
57 
58  std::map<std::string, unsigned int> roses = { {"AUX", 0}, {"LBA", 1}, {"LBC", 2}, {"EBA", 3}, {"EBC", 4} };
59  for (const std::string& maskedModuleChannels : m_masked) {
60 
61  std::string module = maskedModuleChannels.substr(0, 5);
62  std::string partition = module.substr(0, 3);
63  if (roses.count(partition) != 1) {
64  ATH_MSG_WARNING("There no such partition: " << partition << " in module: " << module
65  << " => skip because of bad format: " << maskedModuleChannels);
66  continue;
67  }
68 
69  unsigned int drawer = std::stoi(module.substr(3, 2)) - 1;
71  ATH_MSG_WARNING("There no such drawer: " << drawer + 1 << " in module: " << module
72  << " => skip because of bad format: " << maskedModuleChannels);
73  continue;
74  }
75 
76  unsigned int ros = roses.at(partition);
77  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
78 
79  std::string gain = maskedModuleChannels.substr(5,7);
80  unsigned int adc = std::stoi(gain);
81 
83  ATH_MSG_WARNING("There no such gain: " << gain << " => skip because of bad format: " << maskedModuleChannels);
84  continue;
85  }
86 
87  std::stringstream channels(maskedModuleChannels.substr(7));
88  std::string channel;
89  while (std::getline(channels, channel, ',')) {
90  if (!channel.empty()) {
91  unsigned int chan = std::stoi(channel);
93  ATH_MSG_WARNING("There no such channel: " << chan << " in channels: " << channels.str()
94  << " => skip because of bad format: " << maskedModuleChannels);
95  continue;
96  }
97  m_maskedChannels[drawerIdx][chan] |= (1U << adc);
98  ATH_MSG_INFO(TileCalibUtils::getDrawerString(ros, drawer) << " ch" << chan << (adc ? " HG" : " LG") << ": masked!");
99  }
100  }
101 
102  }
103 
104  m_xCellLB.push_back(m_xCellLB_A.value());
105  m_xCellLB.push_back(m_xCellLB_BC.value());
106  m_xCellLB.push_back(m_xCellLB_D.value());
107 
108  m_yCellLB.push_back(m_yCellLB_A.value());
109  m_yCellLB.push_back(m_yCellLB_BC.value());
110  m_yCellLB.push_back(m_yCellLB_D.value());
111 
112  m_xCellEB.push_back(m_xCellEB_A.value());
113  m_xCellEB.push_back(m_xCellEB_BC.value());
114  m_xCellEB.push_back(m_xCellEB_D.value());
115 
116  m_yCellEB.push_back(m_yCellEB_A.value());
117  m_yCellEB.push_back(m_yCellEB_BC.value());
118  m_yCellEB.push_back(m_yCellEB_D.value());
119 
120  // Sanity check
121  std::vector<unsigned int> maxTower{10, 10, 16, 16};
122  std::vector<std::reference_wrapper<const std::vector<std::vector<std::vector<double>>>>> xyCells{m_xCellLB, m_yCellLB, m_xCellEB, m_yCellEB};
123  for (unsigned int i = 0; i < xyCells.size(); ++i) {
124  for (const std::vector<std::vector<double>>& xy : xyCells[i].get()) {
125  if (xy.size() != maxTower[i]) {
126  std::string properties = ((i % 2 == 0) ? "xCell" : "yCell");
127  properties += (i < 2) ? "LongBarrelSample[A,BC,D]" : "ExtendedBarrelSample[A,BC,D]";
128  ATH_MSG_ERROR("Properties " << properties << " should be configured for " << maxTower[i] << " towers");
129  return StatusCode::FAILURE;
130  }
131  }
132  }
133 
134 
135  const CaloCell_ID* caloID = nullptr;
136  ATH_CHECK( detStore()->retrieve(caloID) );
137 
138  unsigned int minCellTower = 1;
139  unsigned int maxCellTower = 9;
140 
141  std::vector<std::vector<int>> lbCellsD{{}, {0, 2}, {2, 4}, {2, 4}, {1, 4, 6}, {4, 6}, {4, 6}, {6}, {6}};
142  for (unsigned int cellTower = minCellTower; cellTower < maxCellTower; ++cellTower) {
143  std::vector<IdentifierHash>& cells = m_cellsNearTower[cellTower];
144  for (unsigned int cellModule = 0; cellModule < 2; ++cellModule) {
145  for (unsigned int cellSample = 0; cellSample < 2; ++cellSample) {
146  for (unsigned int tower = cellTower - 1; tower < cellTower + 2; ++tower) {
147  Identifier cell_id = m_tileID->cell_id(TileID::BARREL, TileID::NEGATIVE, cellModule, tower, cellSample);
148  cells.push_back(caloID->calo_cell_hash(cell_id));
149  }
150  }
151 
152  const std::vector<int>& towersD = lbCellsD[cellTower];
153  for (int towerD : towersD) {
154  unsigned int side = (towerD == 0) ? TileID::POSITIVE : TileID::NEGATIVE;
155  Identifier cell_id = m_tileID->cell_id(TileID::BARREL, side, cellModule, towerD, TileID::SAMP_D);
156  cells.push_back(caloID->calo_cell_hash(cell_id));
157  }
158  }
159  }
160 
161  static const std::vector<std::vector<std::vector<int>>> ebCellsNearTower{{{}},
162  {{11, 12}, {9, 10, 11, 12}, {8, 10}},
163  {{11, 12}, {9, 10, 11, 12}, {8, 10}},
164  {{12, 13}, {11, 12}, {10, 12}},
165  {{12, 13, 14}, {11, 12, 13}, {10, 12}},
166  {{13, 14}, {12, 13}, {12}},
167  {{14, 15}, {13, 14}, {12}},
168  {{14, 15}, {13, 14}, {12}},
169  {{15}, {14}, {12}}};
170  for (unsigned int cellTower = minCellTower; cellTower < maxCellTower; ++cellTower) {
171  std::vector<IdentifierHash>& cells = m_cellsNearTower[cellTower];
172  const std::vector<std::vector<int>>& ebCells = ebCellsNearTower[cellTower];
173  for (unsigned int cellSample = 0; cellSample < 3; ++cellSample) {
174  const std::vector<int>& ebCellsInSample = ebCells[cellSample];
175  for (int tower : ebCellsInSample) {
176  int section = (tower < 10) ? TileID::GAPDET : TileID::EXTBAR;
177  Identifier cell_id = m_tileID->cell_id(section, TileID::NEGATIVE, 2, tower, cellSample);
178  cells.push_back(caloID->calo_cell_hash(cell_id));
179  }
180  }
181  }
182 
183  for (unsigned int cellTower = minCellTower; cellTower < maxCellTower; ++cellTower) {
184  std::vector<IdentifierHash>& cells = m_cellsNearTower[cellTower];
185  ATH_MSG_INFO("The are " << cells.size() << " Tile cells near the tower " << cellTower << " in LBC02: ");
186  for (IdentifierHash hash : cells) {
187  ATH_MSG_INFO(" " << m_tileID->to_string(caloID->cell_id(hash)));
188  }
189  }
190 
191  return StatusCode::SUCCESS;
192 }
193 
194 
195 StatusCode TileTBMonitorAlgorithm::fillHistograms( const EventContext& ctx ) const {
196 
197  // In case you want to measure the execution time
198  auto timer = Monitored::Timer("TIME_execute");
199 
201  ATH_CHECK( caloCellContainer.isValid() );
202 
203  if (caloCellContainer->empty()) return StatusCode::SUCCESS;
204 
205  const TileCell* cellWithMaxEnergy = nullptr;
206 
207  double totalEnergy(0.0);
208  bool onlyLBC04(true);
209  int nCellsOverThreshold(0);
210 
211  double totalEnergyLBA01 = 0.;
212  double totalEnergyLBA02 = 0.;
213  double totalEnergyLBC01 = 0.;
214  double totalEnergyLBC02 = 0.;
215  double totalEnergyEBC03 = 0.;
216 
217  for (const CaloCell* cell : *caloCellContainer) {
218  if (m_tileID->is_tile(cell->ID())) {
219  const TileCell* tile_cell = dynamic_cast<const TileCell*>(cell);
220  if (!tile_cell) continue;
221 
222  const CaloDetDescrElement* caloDDE = cell->caloDDE();
223 
224  IdentifierHash hash1 = caloDDE->onl1();
225  IdentifierHash hash2 = caloDDE->onl2();
226 
227  int side = m_tileID->side(cell->ID());
228  int section = m_tileID->section(cell->ID());
229  int module = m_tileID->module(cell->ID());
230  int tower = m_tileID->tower(cell->ID());
231  int sample = m_tileID->sample(cell->ID());
232 
233  if ((section == TileID::BARREL) && (side == TileID::NEGATIVE) && (module == 1) && (sample == TileID::SAMP_A)
234  && (!cellWithMaxEnergy || cellWithMaxEnergy->energy() < tile_cell->energy())) {
235  cellWithMaxEnergy = tile_cell;
236  }
237 
238  double energy = 0.0;
239  double energy_pC(0.0);
240 
241  int gain1 = tile_cell->gain1();
242 
243  HWIdentifier channelId1 = m_tileHWID->channel_id(hash1);
244 
245  int ros1 = m_tileHWID->ros(channelId1);
246  int drawer1 = m_tileHWID->drawer(channelId1);
247  int chan1 = m_tileHWID->channel(channelId1);
248  int drawerIdx1 = TileCalibUtils::getDrawerIdx(ros1, drawer1);
249 
250  std::string moduleName1 = TileCalibUtils::getDrawerString(ros1, drawer1);
251  int drawerIdx2 = 0;
252  std::string moduleName2 = "";
253 
254  if (m_monitoredDrawerIdx[drawerIdx1] && tile_cell->ene1() > m_energyThresholdForTime) {
255  auto monTime = Monitored::Scalar<float>("time", tile_cell->time1());
256  auto monChannel = Monitored::Scalar<float>("channel", chan1);
257  fill(m_tools[m_timeGroups.at(moduleName1)], monTime, monChannel);
258  }
259 
260  if (onlyLBC04 && chan1 > 0 && drawerIdx1 != 87) onlyLBC04 = false;
261 
262  if (hash2 == TileHWID::NOT_VALID_HASH) {
263  if (!((m_maskedChannels[drawerIdx1][chan1] >> gain1) & 1U)) {
264  energy = cell->energy();
265  }
266  } else {
267 
268  int gain2 = tile_cell->gain2();
269 
270  HWIdentifier channelId2 = m_tileHWID->channel_id(hash2);
271 
272  int ros2 = m_tileHWID->ros(channelId2);
273  int drawer2 = m_tileHWID->drawer(channelId2);
274  int chan2 = m_tileHWID->channel(channelId2);
275  drawerIdx2 = TileCalibUtils::getDrawerIdx(ros2, drawer2);
276 
277  moduleName2 = TileCalibUtils::getDrawerString(ros2, drawer2);
278 
279  if (m_monitoredDrawerIdx[drawerIdx1] && tile_cell->ene2() > m_energyThresholdForTime) {
280  auto monTime = Monitored::Scalar<float>("time", tile_cell->time2());
281  auto monChannel = Monitored::Scalar<float>("channel", chan2);
282  fill(m_tools[m_timeGroups.at(moduleName2)], monTime, monChannel);
283  }
284 
285  if ((m_maskedChannels[drawerIdx1][chan1] >> gain1) & 1U) {
286  if (!((m_maskedChannels[drawerIdx2][chan2] >> gain2) & 1U)) {
287  energy = tile_cell->ene2() * 2;
288  }
289  } else if ((m_maskedChannels[drawerIdx2][chan2] >> gain2) & 1U) {
290  if (!((m_maskedChannels[drawerIdx1][chan1] >> gain1) & 1U)) {
291  energy =tile_cell->ene1() * 2;
292  }
293  } else {
294  energy = cell->energy();
295  }
296  }
297 
298  energy_pC = energy * 0.001; // keep energy in pC
299  totalEnergy += energy_pC;
300 
301  if (section == TileID::BARREL) {
302  if (side == TileID::POSITIVE) {
303  if (module == 0) totalEnergyLBA01 += energy_pC;
304  else if (module == 1) totalEnergyLBA02 += energy_pC;
305  } else if (side == TileID::NEGATIVE) {
306  if (module == 0) totalEnergyLBC01 += energy_pC;
307  else if (module == 1) totalEnergyLBC02 += energy_pC;
308  }
309  } else {
310  if (module == 2 && side == TileID::NEGATIVE && sample < TileID::SAMP_E) {
311  totalEnergyEBC03 += energy_pC;
312  }
313  }
314 
315  if (side < 0) {
317  ++nCellsOverThreshold;
318  }
319  }
320 
321  if (section == TileID::BARREL) {
322  if (m_monitoredDrawerIdx[drawerIdx1]) {
323  auto monX = Monitored::Collection("x", m_xCellLB[sample][tower]);
324  auto monY = Monitored::Collection("y", m_yCellLB[sample][tower]);
325 
326  std::vector<double> cellEnergy(m_xCellLB[sample][tower].size(), energy_pC);
327  auto monEnergy = Monitored::Collection("energy", cellEnergy);
328  if (m_monitoredDrawerIdx[drawerIdx1]) {
329  fill(m_tools[m_cellMapGroups.at(moduleName1)], monX, monY, monEnergy);
330  }
331 
332  if (tower == 0 && sample == TileID::SAMP_D && m_monitoredDrawerIdx[drawerIdx2]) {
333  fill(m_tools[m_cellMapGroups.at(moduleName2)], monX, monY, monEnergy);
334  }
335  }
336  } else if (section == TileID::EXTBAR
337  || (section == TileID::GAPDET
338  && (sample == TileID::SAMP_C || sample == TileID::SAMP_D))) {
339  if (m_monitoredDrawerIdx[drawerIdx1]) {
340  auto monX = Monitored::Collection("x", m_xCellEB[sample][tower]);
341  auto monY = Monitored::Collection("y", m_yCellEB[sample][tower]);
342 
343  std::vector<double> cellEnergy(m_xCellEB[sample][tower].size(), energy_pC);
344  auto monEnergy = Monitored::Collection("energy", cellEnergy);
345 
346  fill(m_tools[m_cellMapGroups.at(moduleName1)], monX, monY, monEnergy);
347  }
348  }
349  }
350  }
351 
352  if (cellWithMaxEnergy && !onlyLBC04) {
353 
354  int tower = m_tileID->tower(cellWithMaxEnergy->ID());
355  auto monTower = Monitored::Scalar<float>("tower", tower);
356  fill("TileTBHotCellA_LBC02", monTower);
357 
358  if ((tower > 0) && (tower < 9)) {
359 
360  double sumClong = 0.0;
361  double sumCtot = 0.0;
362 
363  const std::vector<IdentifierHash>& cellsHashes = m_cellsNearTower[tower];
365  caloCellContainer->findCellVector(cellsHashes, cells);
366 
367  float alpha = (m_beamEnergy < 100000) ? 0.6 : 0.38;
368  unsigned int nCells = cells.size();
369 
370  if (nCells) {
371  double sumCellEnergyAlpha = 0.;
372  for (const CaloCell* cell : cells) {
373  double energy = cell->energy();
374  if(energy >= 0) {
375  sumCellEnergyAlpha += std::pow(energy, alpha);
376  }
377  }
378 
379  double avgCellEnergyAlpha = sumCellEnergyAlpha / nCells;
380 
381  for (const CaloCell* cell : cells) {
382  double energy = cell->energy();
383  if (energy >= 0) {
384  sumCtot += std::pow( std::pow(energy, alpha) - avgCellEnergyAlpha, 2 );
385  int sample = m_tileID->sample(cell->ID());
386  if (sample != TileID::SAMP_D) {
387  sumClong += energy;
388  }
389  }
390  }
391 
392  double Ctot = std::sqrt(sumCtot / nCells) / sumCellEnergyAlpha;
393  double Clong = sumClong / m_beamEnergy;
394 
395  auto monCtot = Monitored::Scalar<float>("Ctot", Ctot);
396  auto monClong = Monitored::Scalar<float>("Clong", Clong);
397  fill("TileTBCtot", monCtot);
398  fill("TileTBClong", monClong);
399  fill("TileTBCtotVsClong", monClong, monCtot);
400 
401  }
402  }
403  }
404 
405  if (!onlyLBC04) {
406 
407  auto monEnergy = Monitored::Scalar<float>("energy", totalEnergy);
408  fill("TileTBTotalEventEnergy", monEnergy);
409 
410  auto monCellsOvThr = Monitored::Scalar<float>("nCells", nCellsOverThreshold);
411  fill("TileTBCellsNumberVsTotalEnergy", monCellsOvThr, monEnergy);
412 
413  std::vector<int> side{0,0,1,1,1};
414  auto monSide = Monitored::Collection("side", side);
415 
416  std::vector<int> module{0,1,0,1,2};
417  auto monModule = Monitored::Collection("module", module);
418 
419  std::vector<double> moduleEnergy{totalEnergyLBA01, totalEnergyLBA02,
420  totalEnergyLBC01, totalEnergyLBC02,
421  totalEnergyEBC03};
422  auto monModEnergy = Monitored::Collection("energy", moduleEnergy);
423 
424  fill("TileTBHitMap", monSide, monModule, monModEnergy);
425  }
426 
427 
428  fill("TileTBMonExecuteTime", timer);
429 
430  return StatusCode::SUCCESS;
431 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileCell
Definition: TileCell.h:57
TileTBMonitorAlgorithm::m_xCellLB_BC
Gaudi::Property< std::vector< std::vector< double > > > m_xCellLB_BC
Definition: TileTBMonitorAlgorithm.h:56
CaloDetDescrElement::onl2
IdentifierHash onl2() const
cell online identifier 2
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:408
TileCell::time1
float time1(void) const
get time of first PMT
Definition: TileCell.h:198
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:24
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
python.TestDriveDummies.properties
dictionary properties
Definition: TestDriveDummies.py:14
TileTBMonitorAlgorithm::m_yCellLB
std::vector< std::vector< std::vector< double > > > m_yCellLB
Definition: TileTBMonitorAlgorithm.h:108
TileTBMonitorAlgorithm::m_yCellLB_BC
Gaudi::Property< std::vector< std::vector< double > > > m_yCellLB_BC
Definition: TileTBMonitorAlgorithm.h:65
TileCell::time2
float time2(void) const
get time of second PMT
Definition: TileCell.h:200
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
TileCalibUtils::MAX_DRAWERIDX
static const unsigned int MAX_DRAWERIDX
Maximal drawer index
Definition: TileCalibUtils.h:143
TileTBMonitorAlgorithm::m_yCellEB_A
Gaudi::Property< std::vector< std::vector< double > > > m_yCellEB_A
Definition: TileTBMonitorAlgorithm.h:80
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
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
CaloTime_fillDB.gain2
gain2
Definition: CaloTime_fillDB.py:357
TileTBMonitorAlgorithm::m_cellMapGroups
std::map< std::string, int > m_cellMapGroups
Definition: TileTBMonitorAlgorithm.h:97
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
TileTBMonitorAlgorithm::m_yCellLB_D
Gaudi::Property< std::vector< std::vector< double > > > m_yCellLB_D
Definition: TileTBMonitorAlgorithm.h:68
TileTBMonitorAlgorithm::m_energyThresholdForTime
Gaudi::Property< float > m_energyThresholdForTime
Definition: TileTBMonitorAlgorithm.h:41
Tile_Base_ID::GAPDET
@ GAPDET
Definition: Tile_Base_ID.h:48
TileCalibUtils.h
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
Tile_Base_ID::SAMP_E
@ SAMP_E
Definition: Tile_Base_ID.h:55
Tile_Base_ID::BARREL
@ BARREL
Definition: Tile_Base_ID.h:48
TileTBMonitorAlgorithm::m_yCellLB_A
Gaudi::Property< std::vector< std::vector< double > > > m_yCellLB_A
Definition: TileTBMonitorAlgorithm.h:62
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
python.utils.AtlRunQueryTimer.timer
def timer(name, disabled=False)
Definition: AtlRunQueryTimer.py:86
TileID.h
TileTBMonitorAlgorithm::m_monitoredDrawerIdx
std::vector< bool > m_monitoredDrawerIdx
Definition: TileTBMonitorAlgorithm.h:102
dq_defect_copy_defect_database.channels
def channels
Definition: dq_defect_copy_defect_database.py:56
CaloCell_ID.h
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
TileCalibUtils::MAX_DRAWER
static const unsigned int MAX_DRAWER
Number of drawers in ROS 1-4.
Definition: TileCalibUtils.h:139
TileTBMonitorAlgorithm.fragID
fragID
Definition: TileTBMonitorAlgorithm.py:237
CaloCell::energy
double energy() const
get energy (data member)
Definition: CaloCell.h:311
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
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TileTBMonitorAlgorithm::m_xCellEB_BC
Gaudi::Property< std::vector< std::vector< double > > > m_xCellEB_BC
Definition: TileTBMonitorAlgorithm.h:74
CaloDetDescrElement::onl1
IdentifierHash onl1() const
cell online identifier 1
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:404
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
python.PyAthena.module
module
Definition: PyAthena.py:131
Tile_Base_ID::EXTBAR
@ EXTBAR
Definition: Tile_Base_ID.h:48
TileTBMonitorAlgorithm::m_xCellLB
std::vector< std::vector< std::vector< double > > > m_xCellLB
Definition: TileTBMonitorAlgorithm.h:107
TileTBMonitorAlgorithm::m_xCellLB_D
Gaudi::Property< std::vector< std::vector< double > > > m_xCellLB_D
Definition: TileTBMonitorAlgorithm.h:59
TileHWID.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ParticleGun_FastCalo_ChargeFlip_Config.energy
energy
Definition: ParticleGun_FastCalo_ChargeFlip_Config.py:78
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
TileTBMonitorAlgorithm.h
TileTBMonitorAlgorithm::m_xCellEB_A
Gaudi::Property< std::vector< std::vector< double > > > m_xCellEB_A
Definition: TileTBMonitorAlgorithm.h:71
xAOD::nCells
setRawEt setRawPhi nCells
Definition: TrigCaloCluster_v1.cxx:33
lumiFormat.i
int i
Definition: lumiFormat.py:85
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
TileTBMonitorAlgorithm::m_yCellEB
std::vector< std::vector< std::vector< double > > > m_yCellEB
Definition: TileTBMonitorAlgorithm.h:111
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TileCell.h
TileTBMonitorAlgorithm::m_fragIDs
Gaudi::Property< std::vector< int > > m_fragIDs
Definition: TileTBMonitorAlgorithm.h:50
Tile_Base_ID::POSITIVE
@ POSITIVE
Definition: Tile_Base_ID.h:56
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
python.LArCondContChannels.chan1
chan1
Definition: LArCondContChannels.py:666
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:695
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
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileTBMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: TileTBMonitorAlgorithm.cxx:17
TileCell::gain1
int gain1(void) const
get gain of first PMT
Definition: TileCell.cxx:182
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
TileTBMonitorAlgorithm::m_maskedChannels
std::array< std::array< unsigned char, TileCalibUtils::MAX_CHAN >, TileCalibUtils::MAX_DRAWERIDX > m_maskedChannels
Definition: TileTBMonitorAlgorithm.h:104
TileTBMonitorAlgorithm::m_cablingSvc
ServiceHandle< TileCablingSvc > m_cablingSvc
Name of Tile cabling service.
Definition: TileTBMonitorAlgorithm.h:92
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TileTBMonitorAlgorithm::m_yCellEB_D
Gaudi::Property< std::vector< std::vector< double > > > m_yCellEB_D
Definition: TileTBMonitorAlgorithm.h:86
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
TileTBMonitorAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: TileTBMonitorAlgorithm.cxx:195
TileTBMonitorAlgorithm::m_caloCellContainerKey
SG::ReadHandleKey< CaloCellContainer > m_caloCellContainerKey
Definition: TileTBMonitorAlgorithm.h:35
TileHWID::channel_id
HWIdentifier channel_id(int ros, int drawer, int channel) const
channel HWIdentifer
Definition: TileHWID.cxx:199
TileTBMonitorAlgorithm::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileTBMonitorAlgorithm.h:100
Tile_Base_ID::NEGATIVE
@ NEGATIVE
Definition: Tile_Base_ID.h:56
TileTBMonitorAlgorithm::m_masked
Gaudi::Property< std::vector< std::string > > m_masked
Definition: TileTBMonitorAlgorithm.h:47
TileTBMonitorAlgorithm::m_cellEnergyThreshold
Gaudi::Property< float > m_cellEnergyThreshold
Definition: TileTBMonitorAlgorithm.h:38
TileTBMonitorAlgorithm::m_tileID
const TileID * m_tileID
Definition: TileTBMonitorAlgorithm.h:99
CaloCell::ID
Identifier ID() const
get ID (from cached data member) non-virtual and inline for fast access
Definition: CaloCell.h:279
TileTBMonitorAlgorithm::m_yCellEB_BC
Gaudi::Property< std::vector< std::vector< double > > > m_yCellEB_BC
Definition: TileTBMonitorAlgorithm.h:83
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
Tile_Base_ID::SAMP_D
@ SAMP_D
Definition: Tile_Base_ID.h:55
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition: TileCalibUtils.cxx:145
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
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
CaloCondBlobAlgs_fillNoiseFromASCII.hash
dictionary hash
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
Tile_Base_ID::to_string
std::string to_string(const Identifier &id, int level=0) const
Definition: Tile_Base_ID.cxx:52
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
StateLessPT_NewConfig.partition
partition
Definition: StateLessPT_NewConfig.py:49
get
T * get(TKey *tobj)
get a TObject* from a TKey* (why can't a TObject be a TKey?)
Definition: hcg.cxx:127
TileTBMonitorAlgorithm::m_cellsNearTower
std::vector< std::vector< IdentifierHash > > m_cellsNearTower
Definition: TileTBMonitorAlgorithm.h:105
TileTBMonitorAlgorithm.cells
cells
Definition: TileTBMonitorAlgorithm.py:265
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
TileTBMonitorAlgorithm::m_xCellEB
std::vector< std::vector< std::vector< double > > > m_xCellEB
Definition: TileTBMonitorAlgorithm.h:110
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.
TileCalibUtils::MAX_CHAN
static const unsigned int MAX_CHAN
Number of channels in drawer.
Definition: TileCalibUtils.h:141
section
void section(const std::string &sec)
Definition: TestTriggerMenuAccess.cxx:22
TileTBMonitorAlgorithm::m_beamEnergy
Gaudi::Property< float > m_beamEnergy
Definition: TileTBMonitorAlgorithm.h:44
Tile_Base_ID::cell_id
Identifier cell_id(const Identifier &any_id) const
Definition: Tile_Base_ID.cxx:581
TileTBMonitorAlgorithm::m_timeGroups
std::map< std::string, int > m_timeGroups
Definition: TileTBMonitorAlgorithm.h:96
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
TileTBMonitorAlgorithm::m_xCellEB_D
Gaudi::Property< std::vector< std::vector< double > > > m_xCellEB_D
Definition: TileTBMonitorAlgorithm.h:77
TileTBMonitorAlgorithm::m_xCellLB_A
Gaudi::Property< std::vector< std::vector< double > > > m_xCellLB_A
Definition: TileTBMonitorAlgorithm.h:53
Monitored::Timer
A monitored timer.
Definition: MonitoredTimer.h:32
DataVector::empty
bool empty() const noexcept
Returns true if the collection is empty.
CaloCellContainer::CellVector
std::vector< const CaloCell * > CellVector
type to be used for the internal lookup table, and to return list of cells
Definition: CaloCellContainer.h:83
TileCalibUtils::MAX_GAIN
static const unsigned int MAX_GAIN
Number of gains per channel
Definition: TileCalibUtils.h:142
Identifier
Definition: IdentifierFieldParser.cxx:14