ATLAS Offline Software
TileCellNoiseMonTool.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 // ********************************************************************
6 //
7 // NAME: TileCellNoiseMonTool.cxx
8 // PACKAGE: TileMonitoring
9 //
10 // Produce CellNoise folder in tilemon.root for monitoring cell noise
11 // Input is RAW
12 // Output:
13 // -- Cell noise histos for each individual cell (possibly do not keep in the final tilemon.root)
14 // -- 2D map histograms per partition/gain/ for sigma1, sigma2, R, chi2, chi2prb, RMS, RMS/Sigma1
15 //
16 // AUTHOR: Christophe Clement largely (inspired from TileCellMonTool.cxx)
17 //
18 //
19 // ********************************************************************
20 
21 #include "TileCellNoiseMonTool.h"
22 #include "PairBuilder.h"
23 
24 #include "CaloEvent/CaloCellContainer.h"
25 
26 #include "TileCalibBlobObjs/TileCalibUtils.h"
27 #include "TileIdentifier/TileHWID.h"
28 #include "TileConditions/ITileBadChanTool.h"
29 #include "TileEvent/TileCell.h"
30 
31 #include "TH1F.h"
32 #include "TH2F.h"
33 #include "TF1.h"
34 #include "TProfile.h"
35 #include "TProfile2D.h"
36 #include "TString.h"
37 
38 #include <sstream>
39 #include <iomanip>
40 #include <iostream>
41 #include <map>
42 
43 
44 
45 /*---------------------------------------------------------*/
46 TileCellNoiseMonTool::TileCellNoiseMonTool(const std::string & type, const std::string & name, const IInterface* parent)
47  : TileFatherMonTool(type, name, parent)
48  , m_tileBadChanTool("TileBadChanTool")
49  //, m_TileCellTrig(0U)
50  //, m_delta_lumiblock(0U)
51  //, m_oldLumiblock(-1)
52  , m_isFirstEvent(true)
53  , m_mapSigma1{}
54  , m_mapSigma2{}
55  , m_mapR{}
56  , m_mapChi2{}
57  , m_mapChi2prb{}
58  , m_mapRmsOsig{}
59  , m_mapRms{}
60  , m_hPartition1(0)
61  , m_hPartition2(0)
62  , m_h2Partition0(0)
63  , m_h2Partition1(0)
64  , m_h2Partition2(0)
65  , m_h2Partition3(0)
66 
67 
68 /*---------------------------------------------------------*/
69 {
70  declareInterface<IMonitorToolBase>(this);
71 
72  declareProperty("cellsContainerName" , m_cellsContName="AllCalo"); //SG Cell Container
73  declareProperty("doOnline" , m_doOnline=false); //online mode
74  declareProperty("TileBadChanTool" , m_tileBadChanTool);
75  declareProperty("Xmin" , m_xMin = -1000. ); //xmin for the single cell noise histos
76  declareProperty("Xmax" , m_xMax = 1000. ); //xmax for the single cell noise histos
77 
78  m_path = "/Tile/CellNoise";
79 
80 }
81 
82 /*---------------------------------------------------------*/
83 TileCellNoiseMonTool::~TileCellNoiseMonTool()
84 /*---------------------------------------------------------*/
85 {
86 }
87 
88 /*---------------------------------------------------------*/
89 StatusCode TileCellNoiseMonTool::initialize() {
90 /*---------------------------------------------------------*/
91 
92  ATH_MSG_INFO( "in initialize()" );
93 
94  //=== get TileBadChanTool
95  CHECK( m_tileBadChanTool.retrieve() );
96 
97  ATH_MSG_INFO( "in TileCellNoiseMonTool::initialize (...) " );
98  ATH_MSG_INFO( " - m_path = " << m_path );
99 
100  return TileFatherMonTool::initialize();
101 }
102 
103 
104 /*---------------------------------------------------------*/
105 StatusCode TileCellNoiseMonTool::bookCellNoiseHistos() {
106 /*---------------------------------------------------------*/
107 
108  ATH_MSG_INFO( "in bookCellNoiseHistos()" );
109  ATH_MSG_INFO( " - m_path = " << m_path );
110 
111  // Create a vector of Long Barrel Cell CellName+CellID
112  const int NLBCells = 23;
113  std::string LBCellName[NLBCells] = {
114  "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "A10",
115  "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9",
116  "D0", "D1", "D2", "D3"
117  };
118 
119  const int NEBCells = 18;
120  std::string EBCellName[NEBCells] = {
121  "A12", "A13", "A14", "A15", "A16",
122  "B11", "B12", "B13", "B14", "B15",
123  "D4", "D5", "D6",
124  "E1", "E2", "E3", "E4", "C10"
125  };
126 
127  // follows TileFatherMonTool.cxx/h m_ros2partition and m_partition2ros conventions
128  const int Npartitions = 4;
129  std::string PartitionName[Npartitions] = { "EBA", "LBA", "LBC", "EBC" };
130 
131  const int Nmodules = 64;
132 
133  std::string module_str;
134 
135  std::string runNumStr = getRunNumStr();
136 
137  char CellName[30];
138  char modName[10];
139 
140  for (int imod = 0; imod < Nmodules; ++imod) {
141 
142  std::ostringstream convert;
143  convert << imod + 1;
144 
145  if (imod <= 8) {
146  module_str = "0" + convert.str();
147  }
148  if (imod > 8) {
149  module_str = convert.str();
150  }
151 
152  // MYHISTOS
153  // ""
154  // Long barrel cells
155  for (int icell = 0; icell < NLBCells; ++icell) {
156 
157  m_tileCellEne[PartLBA][imod].push_back(
158  book1F("",
159  "CellNoise_" + PartitionName[PartLBA] + module_str + "_" + LBCellName[icell],
160  "TileCellNoise - Run " + runNumStr + " " + PartitionName[PartLBA] + module_str + " "
161  + LBCellName[icell], 100, m_xMin, m_xMax));
162 
163 
164  m_tileCellEne[PartLBC][imod].push_back(
165  book1F("",
166  "CellNoise_" + PartitionName[PartLBC] + module_str + "_" + LBCellName[icell],
167  "TileCellNoise - Run " + runNumStr + " " + PartitionName[PartLBC] + module_str + " "
168  + LBCellName[icell], 100, m_xMin, m_xMax));
169 
170  } // icell
171 
172  // Extended barrel cells
173  for (int icell = 0; icell < NEBCells; ++icell) {
174 
175  m_tileCellEne[PartEBA][imod].push_back(
176  book1F("",
177  "CellNoise_" + PartitionName[PartEBA] + module_str + "_" + EBCellName[icell],
178  "TileCellNoise - Run " + runNumStr + " " + PartitionName[PartEBA] + module_str + " "
179  + EBCellName[icell], 100, m_xMin, m_xMax));
180 
181  m_tileCellEne[PartEBC][imod].push_back(
182  book1F("",
183  "CellNoise_" + PartitionName[PartEBC] + module_str + "_" + EBCellName[icell],
184  "TileCellNoise Run " + runNumStr + " " + PartitionName[PartEBC] + module_str + " "
185  + EBCellName[icell], 100, m_xMin, m_xMax));
186 
187  } // icell
188 
189  } // module
190 
191  m_hPartition1 = book1F ("" , "h_partitions1","partitions1", 8, -2., 6.);
192  m_hPartition2 = book1F ("" , "h_partitions2","partitions1", 8, -2., 6.);
193  m_h2Partition0 = book2F ("" , "h2_partition0","h2_partition0", 100, -2., 2., 100, 0, 6.28);
194  m_h2Partition1 = book2F ("" , "h2_partition1","h2_partition1", 100, -2., 2., 100, 0, 6.28);
195  m_h2Partition2 = book2F ("" , "h2_partition2","h2_partition2", 100, -2., 2., 100, 0, 6.28);
196  m_h2Partition3 = book2F ("" , "h2_partition3","h2_partition3", 100, -2., 2., 100, 0, 6.28);
197 
198  for (int ipart = 0; ipart < 4; ++ipart) {
199  m_mapSigma1[ipart] = book2F("", "map_sigma1_" + PartitionName[ipart]
200  , "Sigma 1 - " + PartitionName[ipart], 23, 0., 23., 65, 0., 65.);
201 
202  m_mapSigma2[ipart] = book2F("", "map_sigma2_" + PartitionName[ipart]
203  , "Sigma 2 - " + PartitionName[ipart], 23, 0., 23., 65, 0., 65.);
204 
205  m_mapR[ipart] = book2F("", "map_R_" + PartitionName[ipart]
206  , "R (A_{1}/A_{2})- " + PartitionName[ipart], 23, 0., 23., 65, 0., 65.);
207 
208  m_mapChi2[ipart] = book2F("", "map_chi2_" + PartitionName[ipart]
209  , "chi2 - " + PartitionName[ipart], 23, 0., 23., 65, 0., 65.);
210 
211  m_mapChi2prb[ipart] = book2F("", "map_chi2prb_" + PartitionName[ipart]
212  , "chi2 prob. - " + PartitionName[ipart], 23, 0., 23., 65, 0., 65.);
213 
214  m_mapRmsOsig[ipart] = book2F("", "map_rmsOsig_" + PartitionName[ipart]
215  , "RMS/ Sigma1 - " + PartitionName[ipart], 23, 0., 23., 65, 0., 65.);
216 
217  m_mapRms[ipart] = book2F("", "map_rms_" + PartitionName[ipart]
218  , "RMS - " + PartitionName[ipart], 23, 0., 23., 65, 0., 65.);
219 
220  // Set cell Names for LB partitions
221  if (PartitionName[ipart] == "LBA" || PartitionName[ipart] == "LBC") {
222  for (int icell = 0; icell < NLBCells; ++icell) {
223 
224  sprintf(CellName, "%s ", LBCellName[icell].c_str());
225  m_mapSigma1[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
226  m_mapSigma2[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
227  m_mapR[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
228  m_mapChi2[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
229  m_mapChi2prb[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
230  m_mapRmsOsig[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
231  m_mapRms[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
232  } // icell
233  } // if ipart is Barrel
234  if (PartitionName[ipart] == "EBA" || PartitionName[ipart] == "EBC") {
235  for (int icell = 0; icell < NEBCells; ++icell) {
236 
237  sprintf(CellName, "%s ", EBCellName[icell].c_str());
238  m_mapSigma1[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
239  m_mapSigma2[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
240  m_mapR[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
241  m_mapChi2[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
242  m_mapChi2prb[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
243  m_mapRmsOsig[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
244  m_mapRms[ipart]->GetXaxis()->SetBinLabel(icell + 1, CellName);
245  } // icell
246  } // if ipart is Barrel
248  for (int imod = 1; imod < 65; imod = imod + 2) {
249  sprintf(modName, "%s%s%i ", PartitionName[ipart].c_str(), (imod < 10 ? "0" : ""), imod);
250  m_mapSigma1[ipart]->GetYaxis()->SetBinLabel(imod + 1, modName);
251  m_mapSigma2[ipart]->GetYaxis()->SetBinLabel(imod + 1, modName);
252  m_mapR[ipart]->GetYaxis()->SetBinLabel(imod + 1, modName);
253  m_mapChi2[ipart]->GetYaxis()->SetBinLabel(imod + 1, modName);
254  m_mapChi2prb[ipart]->GetYaxis()->SetBinLabel(imod + 1, modName);
255  m_mapRmsOsig[ipart]->GetYaxis()->SetBinLabel(imod + 1, modName);
256  m_mapRms[ipart]->GetYaxis()->SetBinLabel(imod + 1, modName);
257  } // imod
258 
259  } // ipart
260 
261  return StatusCode::SUCCESS;
262 } // bookCellNoiseHistos
263 
264 /*---------------------------------------------------------*/
265 StatusCode TileCellNoiseMonTool::bookHistograms()
266 /*---------------------------------------------------------*/
267 {
268  ATH_MSG_INFO( "in bookHistograms()" );
269  ATH_MSG_INFO( "--- m_path = " << m_path );
270 
271  cleanHistVec(); //necessary to avoid problems at the run, evblock, lumi blocks boundaries
272  m_isFirstEvent = true;
273 
274  // Use all triggers (if needs to be done per trigger type then move the booking to the fillhisto where we check the trigger)
275 
276  if (bookCellNoiseHistos().isFailure()) {
277  ATH_MSG_WARNING( "Error with bookCellNoiseHistos() " );
278  }
279 
280  return StatusCode::SUCCESS;
281 }
282 
283 /*---------------------------------------------------------*/
284 void TileCellNoiseMonTool::cleanHistVec() {
285 /*---------------------------------------------------------*/
286 
287  for (int i = 0; i < 9; i++) {
288  m_activeTrigs[i] = -1;
289  }
290 
291  for (int ipart = 0; ipart < 4; ++ipart) {
292  for (int imod = 0; imod < 64; ++imod) {
293  m_tileCellEne[ipart][imod].clear();
294  } // imod
295  } // ipart
296 
297 } // cleanHistVec
298 
299 /*---------------------------------------------------------*/
300 void TileCellNoiseMonTool::do2GFit() {
301 /*---------------------------------------------------------*/
302 
303  ATH_MSG_VERBOSE( "in do2GFit() " );
304 
305  // check there is at least one histo to fit!
306  float xmin = -1000.;
307  float xmax = 1000.;
308 
309  if (m_tileCellEne[0][0].size() == 0) {
310  ATH_MSG_WARNING( "in do2GFit() - m_TileCellEne[0][0] contains zero histogram - bailing out from 2G fit section " );
311  return;
312  }
313 
314  TF1 fitfunction ("total", "gaus(0)+gaus(3)", xmin, xmax);
315  fitfunction.SetLineColor(2);
316 
317  double fitresults[9] = {0};
318  double R, rmsOsig;
319  for (int ipart = 0; ipart < 4; ++ipart) {
320 
321  for (int imod = 0; imod < 64; ++imod) {
322  // loop over cells
323  for (unsigned int icell = 0; icell < m_tileCellEne[ipart][imod].size(); ++icell) {
324  // fit the single cell energy distributions
325 
326  ATH_MSG_VERBOSE( "in do2GFit() : ipart = " << ipart
327  << " imod = " << imod
328  << " icell = " << icell );
329 
330  if (m_tileCellEne[ipart][imod][icell] != 0
331  && m_tileCellEne[ipart][imod][icell]->GetEntries() > 0) {
332 
333  do2GFit(m_tileCellEne[ipart][imod][icell], fitresults, &fitfunction);
334  }
335 
336  // then store the fitresults into a permanent container
337  ATH_MSG_VERBOSE( "Fit results:"
338  << " sigma1 = " << fitresults[2]
339  << " sigma2 = " << fitresults[5]
340  << " amp1 = " << fitresults[0]
341  << " amp2 = " << fitresults[3]
342  << " chi2 = " << fitresults[6]
343  << " chi2prb = " << fitresults[7]
344  << " CellRMS = " << fitresults[8] );
345 
346 
348 
350  R = (fitresults[3] != 0) ? fitresults[0] / fitresults[3] : -1;
351  m_mapSigma1[ipart]->Fill((float) icell + 0.5, (float) imod + 1.5, fitresults[2]); // sigma 1
352  m_mapSigma2[ipart]->Fill((float) icell + 0.5, (float) imod + 1.5, fitresults[5]); // sigma 2
353  m_mapR[ipart]->Fill((float) icell + 0.5, (float) imod + 1.5, R); // R = Amp1/Amp2
354  m_mapChi2[ipart]->Fill((float) icell + 0.5, (float) imod + 1.5, fitresults[6]);
355  m_mapChi2prb[ipart]->Fill((float) icell + 0.5, (float) imod + 1.5, fitresults[7]);
356  rmsOsig = (fitresults[2] != 0) ? (fitresults[8] / fitresults[2]) : -1;
357  m_mapRmsOsig[ipart]->Fill((float) icell + 0.5, (float) imod + 1.5, rmsOsig);
358  m_mapRms[ipart]->Fill((float) icell + 0.5, (float) imod + 1.5, fitresults[8]);
359 
360  } // icell
361 
362  } // imodule
363 
364  } // partition
365 
366  return;
367 }
368 
369 /*---------------------------------------------------------*/
370 void TileCellNoiseMonTool::do2GFit(TH1F* h, double * fitresults, TF1* fitfunction) {
371 /*---------------------------------------------------------*/
372 
373  ATH_MSG_DEBUG( "entering do2GFit(TH1F* h, double * fitresults, TF1* fitfunction) = " << h->GetName() );
374 
375  double par[6];
376 
377  // start values for fit parameters should be the same as in the main reconstruction
378  float nentries = h->GetEntries();
379  float rms = h->GetRMS();
380 
381  ATH_MSG_DEBUG( "in do2GFit(...) : nentries = " << nentries << ", rms = " << rms );
382 
383  par[0] = 0.1 * nentries;
384  par[1] = 0.;
385  par[2] = 0.7 * rms;
386 
387  par[3] = 0.15 * par[0];
388  par[4] = 0.;
389  par[5] = 5. * par[2];
390 
391  fitfunction->SetParameters(par);
392 
393  float bin = h->GetBinWidth(0);
394  float lim1 = bin;
395  float lim2 = std::max(rms * 1.05, bin * 2.0);
396  float lim3 = std::max(rms * 10.0, bin * 20.);
397 
398  // ATH_MSG_DEBUG( "in do2GFit(...) : test1 " );
399 
400  fitfunction->SetParLimits(0,0.,nentries);
401  // ATH_MSG_DEBUG( "in do2GFit(...) : test2 " );
402 
403  fitfunction->FixParameter(1,0.);
404  fitfunction->SetParLimits(2,lim1,lim2);
405  // ATH_MSG_DEBUG( "in do2GFit(...) : test3 " );
406 
407  fitfunction->SetParLimits(3,0.,nentries);
408  // ATH_MSG_DEBUG( "in do2GFit(...) : test4 " );
409 
410  fitfunction->FixParameter(4,0.);
411  fitfunction->SetParLimits(5,lim2,lim3);
412  // ATH_MSG_DEBUG( "in do2GFit(...) : test5 " );
413 
414  h->Fit(fitfunction, "B");
415 
416  fitresults [0] = fitfunction->GetParameter(0);
417  fitresults [1] = fitfunction->GetParameter(1);
418  fitresults [2] = fitfunction->GetParameter(2);
419  fitresults [3] = fitfunction->GetParameter(3);
420  fitresults [4] = fitfunction->GetParameter(4);
421  fitresults [5] = fitfunction->GetParameter(5);
422  fitresults [6] = fitfunction->GetChisquare();
423 
424 // ATH_MSG_DEBUG( "in do2GFit(...) : chi2 = " << fitfunction->GetChisquare() );
425 //
426 // int NDF = fitfunction->GetNDF();
427 // ATH_MSG_DEBUG( "in do2GFit(...) : NDF = " << NDF );
428 //
429 // double chi2prob = TMath::Prob(fitfunction->GetChisquare(), NDF);
430 // ATH_MSG_DEBUG( "in do2GFit(...) : chi2prob = " << chi2prob );
431 
432 
433  //fitresults [7] = chi2prob; // fitfunction->GetProb();
434  fitresults[7] = fitfunction->GetProb();
435  fitresults[8] = h->GetRMS();
436 
437  return;
438 }
439 
440 
441 /*---------------------------------------------------------*/
442 StatusCode TileCellNoiseMonTool::fillHistoPerCell() {
443 /*---------------------------------------------------------*/
444 
445 
446  ATH_MSG_VERBOSE( "in fillHistoPerCell() " );
447 
448  // transform a channel index into a CellIndex: -1 is a channel not connected to a cell
449  int LBch2cellID[48] = {
450  19, 0, 10, 10, 0, 1, 11, 11, 1, 2, 2, 12,
451  12, 20, 20, 3, 13, 13, 3, 4, 4, 14, 14, 5,
452  21, 21, 5, 15, 15, 6, -1, -1, 6, 16, 16, 7,
453  8, 8, 7, 17, 17, 22, 18, -1, 22, 9, 9, 18
454  };
455 
456 
457  int EBch2cellID[48] = {
458  15, 16, 10, 10, 17, 17, 0, 0, 5, 5, 1, 1,
459  13, 14, 6, 6, 11, 11, 15, 16, 2, 2, 7, 7,
460  -1, -1, -1, -1, -1, -1, 8, 3, 3, -1, -1, 8,
461  9, 12, 12, 9, 4, 4, -1, -1, -1, -1, -1, -1
462  };
463 
464 
465  const int NLBCells = 23;
466  std::string LBCellName[NLBCells] = {
467  "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "A10",
468  "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9",
469  "D0", "D1", "D2", "D3"
470  };
471 
472  const int NEBCells = 18;
473  std::string EBCellName[NEBCells] = {
474  "A12", "A13", "A14", "A15", "A16",
475  "B11", "B12", "B13", "B14", "B15",
476  "D4", "D5", "D6",
477  "E1", "E2", "E3", "E4", "C10"
478  };
479 
480  // do we need to do something for the first event?
481  if (m_isFirstEvent) {
482  initFirstEvent();
483  }
484 
485  // Pointer to a Tile cell container
486  const CaloCellContainer* cell_container;
487 
488  //Retrieve Cell collection from SG
489  CHECK( evtStore()->retrieve(cell_container, m_cellsContName) );
490 
491  // Loop over calorimeter cells
492  CaloCellContainer::const_iterator iCell = cell_container->begin();
493  CaloCellContainer::const_iterator lastCell = cell_container->end();
494 
495  for ( ; iCell != lastCell; ++iCell) {
496 
497  const CaloCell * cell_ptr = *iCell; // pointer to cell object
498  Identifier id = cell_ptr->ID();
499 
500  // Continue only if this is a TileCal Cell
501  if (m_tileID->is_tile(id)) {
502 
503  const TileCell* tile_cell = dynamic_cast<const TileCell*>(cell_ptr);
504  if (tile_cell == 0) continue;
505 
506  short ch1 = -1;
507  short ch2 = -1; // channel number, range 0-47 or -1 for unknown
508  int partition1 = -1;
509  int partition2 = -1;
510 
511  const CaloDetDescrElement * caloDDE = tile_cell->caloDDE();
512 
513  // note that m_ros2partition returns 0-4 following definition in TileFatherMonTool.h
514  IdentifierHash hash1 = caloDDE->onl1();
515  if (hash1 != TileHWID::NOT_VALID_HASH) {
516  HWIdentifier hw1 = m_tileHWID->channel_id(hash1);
517  ch1 = m_tileHWID->channel(hw1);
518  partition1 = m_ros2partition[m_tileHWID->ros(hw1)];
519  }
520 
521  IdentifierHash hash2 = caloDDE->onl2();
522  if (hash2 != TileHWID::NOT_VALID_HASH) {
523  HWIdentifier hw2 = m_tileHWID->channel_id(hash2);
524  ch2 = m_tileHWID->channel(hw2);
525  partition2 = m_ros2partition[m_tileHWID->ros(hw2)];
526  }
527 
528 
529  m_hPartition1->Fill(partition1);
530  m_hPartition2->Fill(partition2);
531 
532  // just to avoid potential problems with disconnected cells
533  if (partition1 >= 4) partition1 = getPartition(cell_ptr);
534  if (partition2 >= 4) partition2 = partition1;
535 
536  // something is wrong - go to next cell
537  if (partition1 >= 4) {
538  ATH_MSG_WARNING( "TileCellNoiseMonTool:fillHistoPerCell : partition1 >= 5 ! - partition = " << partition1 );
539  ATH_MSG_WARNING( "TileCellNoiseMonTool:fillHistoPerCell : skipping to next event " );
540  continue;
541  }
542 
543  // note that in single PMT cell both badch1() and badch2() are changed together
544  bool badch1 = (tile_cell->badch1());
545  bool badch2 = (tile_cell->badch2());
546 
547  // 0 = both PMTs are good; 1= 1 PMT is bad; 2= both PMTs are bad, or PMT is bad for single PMT cell
548  int cell_isbad = (int)badch1 + (int)badch2;
549 
550  int gn1 = tile_cell->gain1(); // gain of first PMT
551  int gn2 = tile_cell->gain2(); // gain of second PMT
552 
553  bool ch1Ok = (ch1>-1 && gn1 != CaloGain::INVALIDGAIN);
554  bool ch2Ok = (ch2>-1 && gn2 != CaloGain::INVALIDGAIN);
555 
556  // Cell energy and position info
557  double energy = cell_ptr -> energy();
558  double eta = cell_ptr -> eta();
559  double phi = cell_ptr -> phi();
560 
561  if (partition1 == 0) {
562  m_h2Partition0->Fill(eta, phi);
563  } else if (partition1 == 1) {
564  m_h2Partition1->Fill(eta, phi);
565  } else if (partition1 == 2) {
566  m_h2Partition2->Fill(eta, phi);
567  } else if (partition1 == 3) {
568  m_h2Partition3->Fill(eta, phi);
569  }
570 
571  // From the channel number we need to decide which cell this is
572 
573  // if LB
574  int CellID1=0, CellID2=0;
575  std::string CellName1 = "";
576  std::string CellName2 = "";
577 
578  if (ch1 >= 0) {
579  if (partition1 == PartLBA || partition1 == PartLBC) {
580  CellID1 = LBch2cellID[ch1];
581  } else {
582  CellID1 = EBch2cellID[ch1];
583  }
584  }
585 
586  if (ch2 >= 0) {
587  if (partition2 == PartLBA || partition2 == PartLBC) {
588  CellID2 = LBch2cellID[ch2];
589  } else {
590  CellID2 = EBch2cellID[ch2];
591  }
592  }
593 
594  if (msgLvl(MSG::DEBUG) && (fabs(energy - 1.) < 0.01)) {
595  msg(MSG::DEBUG) << "ch1 = " << ch1
596  << " ch2 = " << ch2
597  << " CellID1 = " << CellID1
598  << " CellID2 = " << CellID2 << endmsg;
599 
600  msg(MSG::DEBUG) << "partition1 = " << partition1 << endmsg;
601  msg(MSG::DEBUG) << "partition2 = " << partition2 << endmsg;
602  msg(MSG::DEBUG) << "m_tileID->module(id) = " << m_tileID->module(id) << endmsg;
603  msg(MSG::DEBUG) << "gain1 = " << gn1 << endmsg;
604  msg(MSG::DEBUG) << "gain2 = " << gn2 << endmsg;
605  }
606 
607  if (partition1 == PartLBA || partition1 == PartLBC) {
608  CellName1 = LBCellName[CellID1];
609  } else {
610  CellName1 = EBCellName[CellID1];
611  }
612 
613  if (partition2 == PartLBA || partition2 == PartLBC) {
614  CellName2 = LBCellName[CellID2];
615  } else {
616  CellName2 = EBCellName[CellID2];
617  }
618 
619 
620  if (msgLvl(MSG::DEBUG) && (fabs(energy - 1) < 0.01)) {
621  msg(MSG::DEBUG) << "CellName1 = " << CellName1 << endmsg;
622  msg(MSG::DEBUG) << "CellName2 = " << CellName2 << endmsg;
623  msg(MSG::DEBUG) << "Cell energy = " << energy << endmsg;
624  msg(MSG::DEBUG) << "ch1Ok = " << (ch1Ok ? 1 : 0) << " ch2Ok = " << (ch2Ok ? 1 : 0) << endmsg;
625  if (partition1 >= 0){
626  msg(MSG::DEBUG) << "HistoName = " << m_tileCellEne[partition1][m_tileID->module(id)][CellID1]->GetName() << endmsg;
627  }
628  }
629 
630  ATH_MSG_DEBUG( "ch1Ok = " << ch1Ok
631  << " ch2Ok = " << ch2Ok
632  << " cell_isbad = " << cell_isbad
633  << " gn1 = " << gn1
634  << " gn2 = " << gn2
635  << " energy = " << energy );
636 
638  if (ch1Ok && ch2Ok && cell_isbad == 0) {
639 
640  if (gn1 == gn2) {
641  if (partition1 >= 0){
642  m_tileCellEne[partition1][m_tileID->module(id)][CellID1]->Fill(energy);
643  } else {
644  ATH_MSG_ERROR("Attempting to access m_tileCellEne at index "<<partition1);
645  }
646  }
647  //if(gn1==1 && gn2==1) m_TileCellEne[partition1][m_tileID->module(id)][CellID1]->Fill(energy);
648 
649  if (CellName1 != CellName2) {
650  ATH_MSG_WARNING( " CellName1 and 2 are different : CellName1 = " << CellName1
651  << " CellName2 =" << CellName2 );
652  }
653 
654  }
655 
656  } // if ( m_tileID->is_tile(id)
657 
658  } // Cell Loop
659 
660  return StatusCode::SUCCESS;
661 } // fillHistoPerCell
662 
663 
664 
665 
666 /*---------------------------------------------------------*/
667 StatusCode TileCellNoiseMonTool::fillHistograms() {
668 /*---------------------------------------------------------*/
669 
670  ATH_MSG_DEBUG( "in fillHistograms() " );
671 
672  if (fillHistoPerCell().isFailure()) {
673  ATH_MSG_WARNING( "Error in fillHistoPerCell() " );
674  }
675 
676  return StatusCode::SUCCESS;
677 
678 } // fillHistograms
679 
680 
681 
682 /*---------------------------------------------------------*/
683 StatusCode TileCellNoiseMonTool::procHistograms() {
684 /*---------------------------------------------------------*/
685 
686  if (endOfLumiBlockFlag() || endOfRunFlag()) {
687  ATH_MSG_INFO( "in procHistograms()" );
688  }
689 
690  return StatusCode::SUCCESS;
691 }
692 
693 
694 /*---------------------------------------------------------*/
695 StatusCode TileCellNoiseMonTool::finalHists() {
696 /*---------------------------------------------------------*/
697 
698  ATH_MSG_INFO( "in finalHists()" );
699  ATH_MSG_INFO( " - m_path = " << m_path );
700 
701  // Call the 2G fit for all Cell energy histograms
702  do2GFit();
703 
704  return StatusCode::SUCCESS;
705 } // finalHists()
706 
707 
708 
709 /*---------------------------------------------------------*/
710 StatusCode TileCellNoiseMonTool::checkHists(bool /* fromFinalize */) {
711 /*---------------------------------------------------------*/
712  ATH_MSG_INFO( "in checkHists()" );
713  return StatusCode::SUCCESS;
714 } // checkHists()
715 
716 
717 
718 
719 // Operations to be done only once at the first event
720 /*---------------------------------------------------------*/
721 void TileCellNoiseMonTool::initFirstEvent() {
722 /*---------------------------------------------------------*/
723  m_isFirstEvent = false; //Set the flag
724 } // FirstEvInit
725 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileCell
Definition: TileCell.h:57
TileFatherMonTool::m_ros2partition
int m_ros2partition[NPartHisto]
Definition: TileFatherMonTool.h:139
CaloDetDescrElement::onl2
IdentifierHash onl2() const
cell online identifier 2
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:408
TilePaterMonTool::book1F
TH1F * book1F(std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
Definition: TilePaterMonTool.cxx:175
TileCellNoiseMonTool::m_xMin
float m_xMin
Definition: TileCellNoiseMonTool.h:69
ManagedMonitorToolBase::m_path
std::string m_path
Definition: ManagedMonitorToolBase.h:915
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
TileCellNoiseMonTool::m_mapRms
TH2F * m_mapRms[4]
Definition: TileCellNoiseMonTool.h:80
TileCellNoiseMonTool::do2GFit
void do2GFit()
Definition: TileCellNoiseMonTool.cxx:300
max
#define max(a, b)
Definition: cfImp.cxx:41
WriteCellNoiseToCool.icell
icell
Definition: WriteCellNoiseToCool.py:339
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
IDTPM::R
float R(const U &p)
Definition: TrackParametersHelper.h:101
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
TileCellNoiseMonTool::~TileCellNoiseMonTool
virtual ~TileCellNoiseMonTool()
Definition: TileCellNoiseMonTool.cxx:83
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
TileCellNoiseMonTool::bookCellNoiseHistos
StatusCode bookCellNoiseHistos()
Definition: TileCellNoiseMonTool.cxx:105
TileFatherMonTool::PartLBA
@ PartLBA
Definition: TileFatherMonTool.h:111
ManagedMonitorToolBase::endOfLumiBlockFlag
bool endOfLumiBlockFlag() const
Definition: ManagedMonitorToolBase.h:858
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
TileCellNoiseMonTool::initialize
virtual StatusCode initialize() final
The initialize will set some navigation variables and retrieve basic services.
Definition: TileCellNoiseMonTool.cxx:89
TileCellNoiseMonTool::m_h2Partition1
TH2F * m_h2Partition1
Definition: TileCellNoiseMonTool.h:86
bin
Definition: BinsDiffFromStripMedian.h:43
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TileCalibUtils.h
TileCellNoiseMonTool::m_h2Partition0
TH2F * m_h2Partition0
Definition: TileCellNoiseMonTool.h:85
TileFatherMonTool
Base class for TileCal online monitoring tools in physics runs.
Definition: TileFatherMonTool.h:33
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileCellNoiseMonTool.h
HWIdentifier
Definition: HWIdentifier.h:13
TileCellNoiseMonTool::m_isFirstEvent
bool m_isFirstEvent
Definition: TileCellNoiseMonTool.h:66
TilePaterMonTool::book2F
TH2F * book2F(std::string dir, std::string nam, std::string tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, std::string trigChain="", std::string mergeAlgo="")
Definition: TilePaterMonTool.cxx:244
TileCellNoiseMonTool::m_mapChi2
TH2F * m_mapChi2[4]
Definition: TileCellNoiseMonTool.h:77
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
CaloDetDescrElement::onl1
IdentifierHash onl1() const
cell online identifier 1
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:404
TileCellNoiseMonTool::TileCellNoiseMonTool
TileCellNoiseMonTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: TileCellNoiseMonTool.cxx:46
CaloGain::INVALIDGAIN
@ INVALIDGAIN
Definition: CaloGain.h:18
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
PlotCalibFromCool.nentries
nentries
Definition: PlotCalibFromCool.py:798
TileFatherMonTool::PartEBA
@ PartEBA
Definition: TileFatherMonTool.h:110
TileFatherMonTool::PartLBC
@ PartLBC
Definition: TileFatherMonTool.h:112
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
TileFatherMonTool::PartEBC
@ PartEBC
Definition: TileFatherMonTool.h:113
Tile_Base_ID::module
int module(const Identifier &id) const
Definition: Tile_Base_ID.cxx:159
TileCellNoiseMonTool::initFirstEvent
void initFirstEvent()
Definition: TileCellNoiseMonTool.cxx:721
lumiFormat.i
int i
Definition: lumiFormat.py:92
xmin
double xmin
Definition: listroot.cxx:60
TileCellNoiseMonTool::procHistograms
StatusCode procHistograms()
An inheriting class should either override this function or finalHists().
Definition: TileCellNoiseMonTool.cxx:683
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
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
CaloCell::caloDDE
const CaloDetDescrElement * caloDDE() const
get pointer to CaloDetDescrElement (data member)
Definition: CaloCell.h:305
TileCellNoiseMonTool::m_hPartition1
TH1F * m_hPartition1
Definition: TileCellNoiseMonTool.h:82
TileCell::badch2
bool badch2(void) const
check if second PMT is in bad channel list and masked
Definition: TileCell.h:218
m_path
std::string m_path
the path being used
Definition: OutputStreamData.cxx:88
TileCell.h
test_pyathena.parent
parent
Definition: test_pyathena.py:15
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
AtlasDetectorID::is_tile
bool is_tile(Identifier id) const
Definition: AtlasDetectorID.h:695
TileCellNoiseMonTool::m_mapChi2prb
TH2F * m_mapChi2prb[4]
Definition: TileCellNoiseMonTool.h:78
TileCellNoiseMonTool::m_mapR
TH2F * m_mapR[4]
Definition: TileCellNoiseMonTool.h:76
TileCellNoiseMonTool::fillHistoPerCell
StatusCode fillHistoPerCell()
Definition: TileCellNoiseMonTool.cxx:442
TileCellNoiseMonTool::m_mapRmsOsig
TH2F * m_mapRmsOsig[4]
Definition: TileCellNoiseMonTool.h:79
TileCellNoiseMonTool::fillHistograms
StatusCode fillHistograms()
An inheriting class should either override this function or fillHists().
Definition: TileCellNoiseMonTool.cxx:667
TileCellNoiseMonTool::m_mapSigma2
TH2F * m_mapSigma2[4]
Definition: TileCellNoiseMonTool.h:75
TileCell::gain1
int gain1(void) const
get gain of first PMT
Definition: TileCell.cxx:182
TileCellNoiseMonTool::checkHists
StatusCode checkHists(bool fromFinalize)
This implementation does nothing; equivalent functionality may be provided by procHists(....
Definition: TileCellNoiseMonTool.cxx:710
TileCellNoiseMonTool::m_h2Partition2
TH2F * m_h2Partition2
Definition: TileCellNoiseMonTool.h:87
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:29
TileHWID::channel_id
HWIdentifier channel_id(int ros, int drawer, int channel) const
channel HWIdentifer
Definition: TileHWID.cxx:198
plotBeamSpotVxVal.bin
int bin
Definition: plotBeamSpotVxVal.py:83
TileFatherMonTool::getPartition
int getPartition(const CaloCell *cell)
Method to navigate from a cell to its Tile partition EBA, LBA, LBC, EBC.
Definition: TileFatherMonTool.cxx:159
CaloCell::ID
Identifier ID() const
get ID (from cached data member) non-virtual and inline for fast access
Definition: CaloCell.h:279
TileFatherMonTool::initialize
virtual StatusCode initialize() override
The initialize will set some navigation variables and retrieve basic services.
Definition: TileFatherMonTool.cxx:101
CaloCellContainer.h
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
TMVAToMVAUtils::convert
std::unique_ptr< MVAUtils::BDT > convert(TMVA::MethodBDT *bdt, bool isRegression=true, bool useYesNoLeaf=false)
Definition: TMVAToMVAUtils.h:114
TileCellNoiseMonTool::cleanHistVec
void cleanHistVec()
Definition: TileCellNoiseMonTool.cxx:284
DataVector::end
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
TileCellNoiseMonTool::m_h2Partition3
TH2F * m_h2Partition3
Definition: TileCellNoiseMonTool.h:88
TileCell::gain2
int gain2(void) const
get gain of second PMT
Definition: TileCell.cxx:189
TileCellNoiseMonTool::m_tileBadChanTool
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Tile Bad Channel tool.
Definition: TileCellNoiseMonTool.h:60
TileHWID::NOT_VALID_HASH
@ NOT_VALID_HASH
Definition: TileHWID.h:314
TileFatherMonTool::getRunNumStr
std::string getRunNumStr()
Method to get the run Number in words:
Definition: TileFatherMonTool.cxx:240
h
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
TH1F
Definition: rootspy.cxx:320
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
ManagedMonitorToolBase::endOfRunFlag
bool endOfRunFlag() const
Definition: ManagedMonitorToolBase.h:859
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DEBUG
#define DEBUG
Definition: page_access.h:11
TileCellNoiseMonTool::m_hPartition2
TH1F * m_hPartition2
Definition: TileCellNoiseMonTool.h:83
generate::GetEntries
double GetEntries(TH1D *h, int ilow, int ihi)
Definition: rmsFrac.cxx:20
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
BchCleanup.modName
modName
Definition: BchCleanup.py:201
TileCellNoiseMonTool::m_mapSigma1
TH2F * m_mapSigma1[4]
Definition: TileCellNoiseMonTool.h:74
xmax
double xmax
Definition: listroot.cxx:61
beamspotnt.rms
rms
Definition: bin/beamspotnt.py:1266
TileCellNoiseMonTool::bookHistograms
StatusCode bookHistograms()
An inheriting class should either override this function or bookHists().
Definition: TileCellNoiseMonTool.cxx:265
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
TileCellNoiseMonTool::finalHists
StatusCode finalHists()
Calls procHists( true, true, true ).
Definition: TileCellNoiseMonTool.cxx:695
PairBuilder.h
TileCellNoiseMonTool::m_xMax
float m_xMax
Definition: TileCellNoiseMonTool.h:70
TileCellNoiseMonTool::m_cellsContName
std::string m_cellsContName
Definition: TileCellNoiseMonTool.h:64
IdentifierHash
Definition: IdentifierHash.h:38
ITileBadChanTool.h
TilePaterMonTool::m_tileHWID
const TileHWID * m_tileHWID
Definition: TilePaterMonTool.h:224
TileFatherMonTool::m_activeTrigs
int m_activeTrigs[9]
this array doesn't simply say if the trigger has ever fired for this run, but it also contains the po...
Definition: TileFatherMonTool.h:152
TilePaterMonTool::m_tileID
const TileID * m_tileID
Definition: TilePaterMonTool.h:223
readCCLHist.float
float
Definition: readCCLHist.py:83
TileCellNoiseMonTool::m_tileCellEne
std::vector< TH1F * > m_tileCellEne[4][64]
Definition: TileCellNoiseMonTool.h:72
DataVector::begin
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
Generated on Tue Jul 2 2024 21:28:48 for ATLAS Offline Software by   doxygen 1.8.18