ATLAS Offline Software
TileRawChannelMonTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 // ********************************************************************
6 //
7 // NAME: TileRawChannelMonTool.cxx
8 // PACKAGE:
9 //
10 // AUTHOR: Alexander Solodkov
11 //
12 //
13 // ********************************************************************
14 
15 #include "TileRawChannelMonTool.h"
16 
17 #include "TileCalibBlobObjs/TileCalibUtils.h"
18 #include "TileConditions/TileCondToolEmscale.h"
19 #include "TileEvent/TileDigitsContainer.h"
20 #include "TileEvent/TileRawChannelContainer.h"
21 #include "TileConditions/TileInfo.h"
22 #include "StoreGate/ReadHandle.h"
23 
24 #include "TH1S.h"
25 #include "TH2S.h"
26 #include "TH1F.h"
27 #include "TProfile.h"
28 #include "TGraphAsymmErrors.h"
29 #include "TVirtualPad.h"
30 #include "TCanvas.h"
31 #include "TStyle.h"
32 #include "TLine.h"
33 #include "TF1.h"
34 
35 #include <iostream>
36 #include <sstream>
37 #include <iomanip>
38 #include <cmath>
39 #include <algorithm>
40 #include <array>
41 
42 
43 /*---------------------------------------------------------*/
44 TileRawChannelMonTool::TileRawChannelMonTool(const std::string & type, const std::string & name, const IInterface* parent)
45  : TilePaterMonTool(type, name, parent)
46  , m_tileToolEmscale("TileCondToolEmscale")
47  , m_cispar(0)
48  , m_nEventsTileMon(0)
49  , m_calibUnit(TileRawChannelUnit::Invalid)
50  , m_drawHists(true)
51  , m_tileInfo(0)
52 
53 /*---------------------------------------------------------*/
54 {
55  declareInterface<IMonitorToolBase>(this);
56 
57  declareProperty("bookAllDrawers", m_bookAll = false);
58  declareProperty("overlaphists", m_overlaphists = false);
59  declareProperty("book2D", m_book2D = true);
60 
61  // run type 1 - phys, 2 - las, 4 - ped, 8 - cis
62  declareProperty("runType", m_runType = 0);
63  declareProperty("bigain", m_bigain = true);
64  declareProperty("TileRawChannelContainer", m_contName = "TileRawChannelOpt2"); //SG RC Container
65  declareProperty("TileRawChannelContainerDSP", m_contNameDSP = "TileRawChannelCnt"); //SG DSP RC Cell Container
66 
67  declareProperty("AmpQ_down_Limit", m_DownLimit = 0.7);
68  declareProperty("AmpQ_up_Limit", m_UpLimit = 1.3);
69  declareProperty("AmpQ_loIntegralLimit", m_lo_IntegralLimit = 0.005);
70  declareProperty("AmpQ_medIntegralLimit", m_med_IntegralLimit = 0.010);
71  declareProperty("AmpQ_hiIntegralLimit", m_hi_IntegralLimit = 0.015);
72  declareProperty("RatioErrorBar", m_useratioerror = true);
73  declareProperty("PlotDSP", m_plotDsp = false);
74  declareProperty("StoreGraph", m_storeGraph = true);
75  m_path = "/Tile/RawChannel"; //ROOT file directory
76  declareProperty("EfitThresh", m_efitThresh = 0.30); //threshold in pC for DSP check
77  declareProperty("TileCondToolEmscale", m_tileToolEmscale);
78  declareProperty("SummaryUpdateFrequency", m_summaryUpdateFrequency = 0);
79  declareProperty("ResetAfterSummaryUpdate", m_resetAfterSummaryUpdate = false);
80  declareProperty("DoLaserSummaryVsPMT", m_doLaserSummaryVsPMT = false);
81  declareProperty("MinAmpForCorrectedTime", m_minAmpForCorrectedTime = 0.5);
82  declareProperty("TileInfoName", m_infoName = "TileInfo");
83  declareProperty("TileDQstatus", m_DQstatusKey = "TileDQstatus");
84  declareProperty("CalibUnit", m_intCalibUnit = (int)TileRawChannelUnit::Invalid);
85 }
86 
87 /*---------------------------------------------------------*/
88 TileRawChannelMonTool::~TileRawChannelMonTool()
89 /*---------------------------------------------------------*/
90 {
91 }
92 
93 /*---------------------------------------------------------*/
94 StatusCode TileRawChannelMonTool::initialize()
95 /*---------------------------------------------------------*/
96 {
97 
98  ATH_MSG_INFO("in initialize()");
99 
100  m_data = std::make_unique<Data>();
101 
102  CHECK(m_tileToolEmscale.retrieve());
103 
104  m_nEventsTileMon = 0;
105 
106  memset(m_data->m_timeCov, 0, sizeof(m_data->m_timeCov));
107  memset(m_data->m_timeCovCorr, 0, sizeof(m_data->m_timeCovCorr));
108 
109  CHECK(TilePaterMonTool::initialize());
110 
111  CHECK( detStore()->retrieve(m_tileInfo, m_infoName) );
112  if (m_tileInfo->ADCmax() == 4095) m_is12bit = true;
113 
114  m_dac2Charge[0] = 100.* 2.0 * 4.096 / double(m_tileInfo->ADCmax()); // 100 pF * 2 for legacy or 200 pF for demonstrator
115  m_dac2Charge[1] = 5.2 * 2.0 * 4.096 / double(m_tileInfo->ADCmax()); // use the same number 5.2 pF as in TileCisDefaultCalibTool
116  m_dac2Charge[2] = 5.2 * 4.096 / double(m_tileInfo->ADCmax()); // effective value of small capacitor is twice smaller for demonstrator
117 
118  CHECK( m_DQstatusKey.initialize() );
119 
120  return StatusCode::SUCCESS;
121 }
122 
123 /*---------------------------------------------------------*/
124 StatusCode TileRawChannelMonTool::bookHists()
125 /*---------------------------------------------------------*/
126 {
127 
128  if (msgLvl(MSG::DEBUG)) {
129  msg(MSG::DEBUG) << "in bookHists()" << endmsg;
130  msg(MSG::DEBUG) << "Using base path " << m_path << endmsg;
131  }
132 
133  if (m_intCalibUnit>=0 && m_intCalibUnit<=3) {
134  m_calibUnit = (TileRawChannelUnit::UNIT)m_intCalibUnit;
135  }
136  if (m_calibUnit == TileRawChannelUnit::Invalid) {
137  if (m_runType == PhysRun) {
138  m_calibUnit = TileRawChannelUnit::CesiumPicoCoulombs;
139  } else {
140  m_calibUnit = TileRawChannelUnit::PicoCoulombs;
141  }
142  }
143 
144  if (m_bookAll) {
145  for (int ros = 1; ros < 5; ++ros) {
146  for (int drawer = 0; drawer < 64; ++drawer) {
147  bookHists(ros, drawer);
148 
149  if (m_plotDsp) bookDsp(ros, drawer);
150 
151  }
152  }
153  }
154 
155  /* float X_axis[48];
156  float X_errors[48];
157  for (int i = 0; i < 48; i++) {
158  X_axis[i] = i+0.5;
159  X_errors[i] = 0.;
160  }
161 
162  TGraph* test = new TGraph(48,X_axis,X_errors);
163  test->SetNameTitle("LFTESTLBC01","LFTESTLBC01");
164  m_rootsvc->regGraph("/HIST1/Tile/RawChannel/Summary/LFTESTBC01", test);
165 
166  TGraph* test2 = new TGraph(48,X_axis,X_errors);
167  test2->SetNameTitle("LFTESTLBC02","LFTESTLBC02");
168  m_rootsvc->regGraph("/HIST1/Tile/RawChannel/Summary/LFTESTBC02", test2);
169  */
170 
171  //SetBookStatus(true);
172 
173 
174  return StatusCode::SUCCESS;
175 }
176 
177 
178 /*---------------------------------------------------------*/
179 void TileRawChannelMonTool::bookHists(int ros, int drawer)
180 /*---------------------------------------------------------*/
181 {
182  const std::array<std::string, 6> gain{ "_lo", "_hi", "", " low gain", " high gain", "" };
183 
184  std::ostringstream sStr;
185  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
186  std::string subDir = moduleName;
187  std::string histName, histTitle;
188 
189  ATH_MSG_DEBUG("in bookHists() for module " << moduleName);
190 
191  // for bigain run book 2 histograms per channel
192  // for monogain run book just one histogram per channel
193  int mingain = (m_bigain) ? 0 : 2;
194  int maxgain = (m_bigain) ? 2 : 3;
195 
196  for (int ch = 0; ch < 48; ++ch) {
197 
198  // int pmt=m_cabling->channel2hole(ros,ch); // 1:48, negative for non-connected channels
199  // int pmt0 = ((pmt > 0)? pmt-1 : pmt+1); // 0:47, negaitve for non-connected channels
200  sStr.str("");
201  sStr << std::setfill('0') << std::setw(2) << ch << std::setfill(' ');
202  // sStr << std::setfill('0') << std::setw(2) << (abs(pmt)-1) << std::setfill(' ');
203  std::string sCh = sStr.str(); // 00:47, always positive
204 
205  for (int gn = mingain; gn < maxgain; ++gn) {
206 
207  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
208 
209  std::string HistName[4] = { "_amp_ratio_100", "_amp_ratio_5", "_time_100", "_time_5" };
210  std::string HistTitle[4] = { " amp to charge ratio for 100 pF", " amp to charge ratio for 5 pF", " time for 100 pF", " time for 5 pF" };
211 
212  for (int type = 0; type < 4; type++) {
213  sStr.str("");
214  sStr << moduleName << "_ch_" << sCh << gain[gn] << HistName[type];
215  histName = sStr.str();
216 
217  sStr.str("");
218  if (gn+3 >= std::ssize(gain)) throw std::out_of_range("Index out of range in TileRawChannelMonTool::bookHists");
219  sStr << moduleName << " CH " << ch << gain[3 + gn] << HistTitle[type];
220  histTitle = sStr.str();
221 
222  if (type < 2)
223  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 101, -0.01, 2.01));
224  else
225  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 101, -101.0, 101.0));
226  }
227 
228  if (m_book2D) {
229  std::string Hist2DName[4] = { "_amp_vs_q_100", "_amp_vs_q_5", "_time_vs_time_100", "_time_vs_time_5" };
230  std::string Hist2DTitle[4] = { " amp vs charge 100 pF", " amp vs charge 5 pF", " time vs time 100 pF", " time vs time 5 pF" };
231  float factor_charge = m_is12bit ? 2. : 1.;
232  float factor_adc = m_is12bit ? 4. : 1.;
233  // Below, static_cast<float> is used to avoid warnings from -Wnarrowing
234  float LowX_low2D[4] = { -4., -0.5, -0.25, -0.25 };
235  float HighX_low2D[4] = { 804., 50.5, 25.25, 25.25 };
236  float LowX_hi2D[4] = { static_cast<float>(-0.0625 * factor_charge), static_cast<float>(-0.0625 * factor_charge), -0.25, -0.25 };
237  float HighX_hi2D[4] = { static_cast<float>(12.5625 * factor_charge), static_cast<float>(12.5625 * factor_charge), 25.25, 25.25 };
238  float LowY_low2D[4] = { -25., -5.3125, -64.0, -64.0 };
239  float HighY_low2D[4] = { 1025., 60.3125, 32.0, 32.0 };
240  float LowY_hi2D[4] = { static_cast<float>(-25. * factor_adc), static_cast<float>(-25. * factor_adc), -64.0, -64.0 };
241  float HighY_hi2D[4] = { static_cast<float>(1025. * factor_adc), static_cast<float>(1025. * factor_adc), 32.0, 32.0 };
242  float LowY_hi2D_pC[4] = { static_cast<float>(-.391 * factor_adc), static_cast<float>(-.391 * factor_adc), -64.0, -64.0 };
243  float HighY_hi2D_pC[4] = { static_cast<float>(16.02 * factor_adc), static_cast<float>(16.02 * factor_adc), 32.0, 32.0 };
244 
245  for (int type = 0; type < 4; type++) {
246 
247  sStr.str("");
248  sStr << moduleName << "_ch_" << sCh << gain[gn] << Hist2DName[type];
249  histName = sStr.str();
250 
251  sStr.str("");
252  if (gn+3 >= std::ssize(gain)) throw std::out_of_range("Index out of range in TileRawChannelMonTool::bookHists");
253  sStr << moduleName << " CH " << ch << gain[3 + gn] << Hist2DTitle[type];
254  histTitle = sStr.str();
255 
256  switch (gn) {
257  case 0: // low gain
258  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
259  book2S(subDir, histName, histTitle, 51, LowX_low2D[type], HighX_low2D[type], 160, LowY_low2D[type], HighY_low2D[type]));
260  break;
261  case 1: // high gain
262  if (m_calibUnit == TileRawChannelUnit::CesiumPicoCoulombs || m_calibUnit == TileRawChannelUnit::PicoCoulombs)
263  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
264  book2S(subDir, histName, histTitle, 51, LowX_hi2D[type], HighX_hi2D[type], 160, LowY_hi2D_pC[type], HighY_hi2D_pC[type]));
265  else
266  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
267  book2S(subDir, histName, histTitle, 51, LowX_hi2D[type], HighX_hi2D[type], 160, LowY_hi2D[type], HighY_hi2D[type]));
268  break;
269  default: // single gain mode
270  if (m_calibUnit == TileRawChannelUnit::CesiumPicoCoulombs)
271  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
272  book2S(subDir, histName, histTitle, 51, LowX_hi2D[type], HighX_hi2D[type], 160, LowY_hi2D_pC[type], HighY_hi2D_pC[type]));
273  else
274  m_data->m_hist2[ros][drawer][ch][gn & 1].push_back(
275  book2S(subDir, histName, histTitle, 51, LowX_hi2D[type], HighX_hi2D[type], 160, LowY_hi2D[type], HighY_hi2D[type]));
276  }
277  } //loop over type hist
278  } // if(book2D)
279 
280  } else { // not CIS run
281 
282  sStr.str("");
283  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_amp";
284  histName = sStr.str();
285 
286  sStr.str("");
287  if (gn+3 >= std::ssize(gain)) throw std::out_of_range("Index out of range in TileRawChannelMonTool::bookHists");
288  sStr << moduleName << " CH " << ch << gain[3 + gn] << " amp";
289  histTitle = sStr.str();
290 
291  if (m_runType == PedRun) {
292  switch (gn) {
293  case 0: // low gain
294  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 101, -10.1, 10.1));
295  break;
296  case 1: // high gain
297  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 101, -0.404, 0.404));
298  break;
299  default: // single gain mode
300  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 101, -10.1, 10.1));
301  }
302  } else {
303  switch (gn) {
304  case 0: // low gain
305  if (m_overlaphists) {
306  const Int_t nlg1 = 49;
307  const Int_t nlg2 = 500;
308  const Int_t nlg3 = 1027;
309  Double_t xlgbin[nlg1 + nlg2 + nlg3 + 1];
310  for(Int_t i = 0; i <= nlg1; ++i)
311  xlgbin[i] = -50.5+1.0*i;
312  for(Int_t i = 1; i <= nlg2; ++i)
313  xlgbin[i + nlg1] = -1.5 + 0.05 * i;
314  for(Int_t i = 1; i <= nlg3; ++i)
315  xlgbin[i + nlg1 + nlg2] = 23.5 + 1.0 * i;
316  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1Sx(subDir, histName, histTitle, nlg1 + nlg2 + nlg3, xlgbin));
317  } else {
318  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 1101, -50.5, 1050.5));
319  }
320  break;
321  case 1: // high gain
322  if (m_overlaphists)
323  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 500, -1.5, 23.5));
324  else
325  m_data->m_hist1[ros][drawer][ch][gn].push_back(book1S(subDir, histName, histTitle, 826, -1.01, 15.51));
326  break;
327  default: // single gain mode
328  if (m_runType == PhysRun) {
329  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 206, -0.55, 20.05));
330  } else {
331  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 801, -0.5, 800.5));
332  }
333  }
334  }
335 
336  sStr.str("");
337  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_time";
338  histName = sStr.str();
339 
340  sStr.str("");
341  if (gn+3 >= std::ssize(gain)) throw std::out_of_range("Index out of range in TileRawChannelMonTool::bookHists");
342  sStr << moduleName << " CH " << ch << gain[3 + gn] << " time";
343  histTitle = sStr.str();
344 
345  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 201, -100.5, 100.5));
346  //Lukas
347  sStr.str("");
348  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_time_corr";
349  histName = sStr.str();
350 
351  sStr.str("");
352  sStr << moduleName << " CH " << ch << gain[3 + gn] << " time_corr";
353  histTitle = sStr.str();
354 
355  m_data->m_hist1[ros][drawer][ch][gn & 1].push_back(book1S(subDir, histName, histTitle, 201, -100.5, 100.5));
356  //Lukas
357  }
358  }
359  }
360 
361  if (m_summaryUpdateFrequency > 0) bookSummaryHistograms(ros, drawer);
362 }
363 
364 /*---------------------------------------------------------*/
365 void TileRawChannelMonTool::bookDsp(int ros, int drawer)
366 /*---------------------------------------------------------*/
367 {
368  const std::array<std::string, 6> gain{ "_lo", "_hi", "", " low gain", " high gain", "" };
369 
370 
371  std::ostringstream sStr;
372 
373  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
374  std::string subDir = moduleName;
375  std::string histName, histTitle;
376 
377  ATH_MSG_DEBUG("in bookDSP() for module " << moduleName);
378 
379  // for bigain run book 2 histograms per channel
380  // for monogain run book just one histogram per channel
381  int mingain = (m_bigain) ? 0 : 2;
382  int maxgain = (m_bigain) ? 2 : 3;
383 
384  for (int gn = mingain; gn < maxgain; ++gn) {
385  std::string finalsubDir = "Summary";
386  sStr.str("");
387  sStr << moduleName << gain[gn] << "_summary_chi2_amp";
388  std::string finalhistName = sStr.str();
389 
390  sStr.str("");
391  if (gn+3 >= std::ssize(gain)) throw std::out_of_range("Index out of range in TileRawChannelMonTool::bookDsp");
392  sStr << moduleName << gain[3 + gn] << " Summary chi2 versus amp";
393  std::string finalhistTitle = sStr.str();
394 
395  switch (gn) {
396  case 0: // low gain
397  m_data->m_finalHistDsp2[ros][drawer][gn].push_back(book2F(finalsubDir, finalhistName, finalhistTitle, 200, -45.1, 855.1, 16, 0., 16.));
398  break;
399  case 1: // high gain
400  m_data->m_finalHistDsp2[ros][drawer][gn].push_back(book2F(finalsubDir, finalhistName, finalhistTitle, 150, -7.0, 12.0, 16, 0., 16.));
401  break;
402  default: // single gain mode
403  if (m_runType == PhysRun) {
404  m_data->m_finalHistDsp2[ros][drawer][gn & 1].push_back(book2F(subDir, finalhistName, finalhistTitle, 150, -7.005, 7.005, 16, 0., 16.));
405 
406  } else {
407  m_data->m_finalHistDsp2[ros][drawer][gn & 1].push_back(book2F(subDir, finalhistName, finalhistTitle, 200, -45.1, 855.1, 16, 0., 16.));
408  }
409  }
410 
411  }
412 
413  for (int ch = 0; ch < 48; ++ch) {
414 
415  // int pmt=m_cabling->channel2hole(ros,ch); // 1:48, negative for non-connected channels
416  // int pmt0 = ((pmt > 0)? pmt-1 : pmt+1); // 0:47, negaitve for non-connected channels
417  sStr.str("");
418  // sStr << std::setfill('0') << std::setw(2) << (abs(pmt)-1) << std::setfill(' ');
419  sStr << std::setfill('0') << std::setw(2) << ch << std::setfill(' ');
420  std::string sCh = sStr.str(); // 00:47, always positive
421 
422  for (int gn = mingain; gn < maxgain; ++gn) {
423 
424  sStr.str("");
425  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp_amp";
426  histName = sStr.str();
427 
428  sStr.str("");
429  if (gn+3 >= std::ssize(gain)) throw std::out_of_range("Index out of range in TileRawChannelMonTool::bookDsp");
430  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp Amp";
431  histTitle = sStr.str();
432 
433  switch (gn) {
434  case 0: // low gain
435  m_data->m_histDsp1[ros][drawer][ch][gn].push_back(book1F(subDir, histName, histTitle, 491, -50.5, 1049.34));
436  break;
437  case 1: // high gain
438  m_data->m_histDsp1[ros][drawer][ch][gn].push_back(book1F(subDir, histName, histTitle, 413, -1.01, 15.51));
439  break;
440  default: // single gain mode
441  if (m_runType == PhysRun) {
442  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 100, -0.55, 20.05));
443  } else {
444  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 200, -0.5, 800.5));
445  }
446  }
447 
448  sStr.str("");
449  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp_time";
450  histName = sStr.str();
451 
452  sStr.str("");
453  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp Time";
454  histTitle = sStr.str();
455 
456  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 101, -100.5, 100.5));
457 
458  sStr.str("");
459  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp_chi2";
460  histName = sStr.str();
461 
462  sStr.str("");
463  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp Chi2";
464  histTitle = sStr.str();
465 
466  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 16, -0.5, 15.5));
467 
468  sStr.str("");
469  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp-fit_amp_diff";
470  histName = sStr.str();
471 
472  sStr.str("");
473  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp-OF Amp difference";
474  histTitle = sStr.str();
475 
476  auto ix = (gn < 2) ? gn : (gn & 1);
477  m_data->m_histDsp1[ros][drawer][ch][ix].push_back(book1F(subDir, histName, histTitle, 404, -1.01, 1.01));
478 
479  sStr.str("");
480  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_dsp-fit_time_diff";
481  histName = sStr.str();
482 
483  sStr.str("");
484  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp-OF Time diff";
485  histTitle = sStr.str();
486 
487  m_data->m_histDsp1[ros][drawer][ch][gn & 1].push_back(book1F(subDir, histName, histTitle, 101, -2.02, 2.02));
488 
489  sStr.str("");
490  sStr << moduleName << "_ch_" << sCh << gain[gn] << "_chi2_amp";
491  histName = sStr.str();
492 
493  sStr.str("");
494  sStr << moduleName << " CH " << ch << gain[3 + gn] << " Dsp Chi2 versus Amp";
495  histTitle = sStr.str();
496 
497  switch (gn) {
498  case 0: // low gain
499  m_data->m_histDsp2[ros][drawer][ch][gn].push_back(book2F(subDir, histName, histTitle, 200, -45.1, 855.1, 16, 0., 16.));
500  break;
501  case 1: // high gain
502  m_data->m_histDsp2[ros][drawer][ch][gn].push_back(book2F(subDir, histName, histTitle, 150, -7.0, 12.0, 16, 0., 16.));
503  break;
504  default: // single gain mode
505  if (m_runType == PhysRun) {
506  m_data->m_histDsp2[ros][drawer][ch][gn & 1].push_back(book2F(subDir, histName, histTitle, 150, -7.005, 7.005, 16, 0., 16.));
507  } else {
508  m_data->m_histDsp2[ros][drawer][ch][gn & 1].push_back(book2F(subDir, histName, histTitle, 200, -45.1, 855.1, 16, 0., 16.));
509  }
510  }
511 
512  } //end for over gains
513  } // end for over chans
514 }
515 
516 /*---------------------------------------------------------*/
517 StatusCode TileRawChannelMonTool::fillHists()
518 /*---------------------------------------------------------*/
519 {
520 
521  ATH_MSG_DEBUG("in fillHists()");
522 
523  if (m_nEventsTileMon % 1000 == 0) ATH_MSG_INFO(m_nEventsTileMon<<" events processed so far");
524  // array of 16 CIS parameters
525  const TileDQstatus* dqStatus = SG::makeHandle (m_DQstatusKey).get();
526  m_cispar = dqStatus->cispar();
527  ++m_nEventsTileMon;
528 
529  m_efitMap.clear();
530  m_tfitMap.clear();
531 
532  //ndulchin: start filter code
533  const TileDigitsContainer* DigitsCnt;
534  CHECK(evtStore()->retrieve(DigitsCnt, "TileDigitsCnt"));
535 
536  TileDigitsContainer::const_iterator collItr2 = DigitsCnt->begin();
537  TileDigitsContainer::const_iterator lastColl2 = DigitsCnt->end();
538 
539  for (; collItr2 != lastColl2; ++collItr2) {
540  TileDigitsCollection::const_iterator digitsItr = (*collItr2)->begin();
541  TileDigitsCollection::const_iterator lastDigits = (*collItr2)->end();
542 
543  if (digitsItr != lastDigits) {
544 
545  HWIdentifier adc_id = (*digitsItr)->adc_HWID();
546  int ros = m_tileHWID->ros(adc_id);
547  int drawer = m_tileHWID->drawer(adc_id);
548  std::vector<uint32_t> headerVec = (*collItr2)->getFragChipHeaderWords();
549  int headsize = headerVec.size();
550  if (headsize > 16) headsize = 16;
551 
552  int fragId = (*collItr2)->identify();
553  if (!std::binary_search(m_fragIDsToIgnoreDMUerrors.begin(), m_fragIDsToIgnoreDMUerrors.end(), fragId)) {
554 
555  for (int dmu = 0; dmu < headsize; dmu++) {
556  m_corrup[ros][drawer][0][dmu] = checkDmuHeader(&headerVec, dmu);
557  m_corrup[ros][drawer][1][dmu] = checkDmuHeader(&headerVec, dmu);
558  }
559 
560  } else {
561  for (int dmu = 0; dmu < headsize; dmu++) {
562  m_corrup[ros][drawer][0][dmu] = false;
563  m_corrup[ros][drawer][1][dmu] = false;
564  }
565  }
566 
567  for (int dmu = headsize; dmu < 16; dmu++) {
568  m_corrup[ros][drawer][0][dmu] = false;
569  m_corrup[ros][drawer][1][dmu] = false;
570  }
571 
572  }
573  }
574 
575  //if (!isErr)
576  //ndulchin: end Filter code
577 
578  const TileRawChannelContainer* RawChannelCnt;
579  CHECK(evtStore()->retrieve(RawChannelCnt, m_contName));
580 
581  TileRawChannelUnit::UNIT RChUnit = RawChannelCnt->get_unit();
582 
583  //Lukas
584  double avgTimePerPart[5], sumTimeCh[5];
585  int nCh[5];
586  for (int iros = 0; iros < 5; iros++) {
587  avgTimePerPart[iros] = 0;
588  sumTimeCh[iros] = 0;
589  nCh[iros] = 0;
590  } //for iros
591  //Lukas
592 
593  for (int k = 0; k < 2; k++) { //Lukas
594 
595  TileRawChannelContainer::const_iterator collItr = RawChannelCnt->begin();
596  TileRawChannelContainer::const_iterator lastColl = RawChannelCnt->end();
597 
598  for (; collItr != lastColl; ++collItr) {
599 
600  int cap = (m_cispar[7] > 10) ? 0 : 1; // 100 pF or 5 pF
601  int cap_index = cap;
602 
603  double hg_small_charge = 1.; // ignore charges below 1 pC in HG
604  double lg_small_charge = (cap) ? 10. : 15.; // ignore charges below 10 pC for small cap and below 15 pC for big cap in LG
605  double hg_charge_cut = 11.5; // ignore charges above 11.5 pC in HG (full range is 12.5 pC)
606  double lg_charge_cut = 750.; // ignore charges above 750. pC in LG (full range is 800. pC)
607 
608  int fragId = (*collItr)->identify();
609  bool demonstrator = (std::binary_search(m_fragIDsDemonstrators.begin(), m_fragIDsDemonstrators.end(), fragId));
610  if (demonstrator) {
611  hg_small_charge *= 2.;
612  hg_charge_cut *= 2;
613  cap_index *= 2;
614  }
615  double charge = (m_cispar[6] < 1024) ? m_cispar[6] * m_dac2Charge[cap_index] : 0;
616  double timeInj = m_cispar[5] * 0.104;
617 
618  TileRawChannelCollection::const_iterator chItr = (*collItr)->begin();
619  TileRawChannelCollection::const_iterator lastCh = (*collItr)->end();
620 
621  if (chItr != lastCh) {
622 
623  HWIdentifier adc_id = (*chItr)->adc_HWID();
624  int ros = m_tileHWID->ros(adc_id);
625  int drawer = m_tileHWID->drawer(adc_id);
626  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
627 
628  if (m_data->m_hist1[ros][drawer][0][0].size() == 0) {
629  // m_bigain = (dqStatus->calibMode() == 1); // true if bi-gain run
630  // we fill both high and low gain plots
631  m_bigain = true;
632  if (k == 0) bookHists(ros, drawer); //Lukas
633  }
634 
635  std::vector<double> efitVec(m_bigain ? 96 : 48, 0.), tfitVec(m_bigain ? 96 : 48, 0.); //I need these variables later for comparison with dsp
636 
637  for (; chItr != lastCh; ++chItr) {
638 
639  const TileRawChannel * rch = (*chItr);
640 
641  adc_id = rch->adc_HWID();
642  unsigned int chan = m_tileHWID->channel(adc_id);
643  int adc = m_tileHWID->adc(adc_id);
644  int gain = (m_bigain) ? adc : 0; // ignore gain in monogain run
645 
646  if ((m_cispar[8] == 0) /* || ( m_cispar[8] == abs(m_cabling->channel2hole(ros,chan)) )*/) { // channel is fired
647 
648  double amp = rch->amplitude();
649  if (RChUnit != m_calibUnit) {
650  //Put everything in PicoCoulomb by default for all run types
651  //For Laser and Physcs calibrate in CesiumPicoCoulomb for all channels,
652  // but the MBTS channels, for which we keep the calibration in PicoCoulombCesium pC for consistency
653  //(no Cs calibration is possible)
654  if (m_calibUnit == TileRawChannelUnit::CesiumPicoCoulombs) {
655  if (ros < 3) //if LB then it's ok CesiumPicoCoulomb
656  {
657  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
658  } else // check that they are not MBTS channel
659  {
660  int index, pmt;
661  /*Identifier cell_id =*/rch->cell_ID_index(index, pmt);
662  if (index < -1) // MBTS channel
663  {
664  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::PicoCoulombs);
665  } else //not MBTS channel
666  {
667  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
668  }
669  }
670  } //close if on CesiumPicoCoulomb units
671  else { //calibrate in PicoCoulomb
672  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, m_calibUnit);
673  }
674  } // no need to calibrate
675 
676  efitVec[chan + gain * 48] = amp;
677  double time = rch->time();
678  double timeCorr = 0; //Lukas
679  tfitVec[chan + gain * 48] = time;
680 
681  if (!m_corrup[ros][drawer][gain][chan / 3]) {
682  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
683  if (k == 0) { //Lukas
684 
685  if (m_book2D) {
686  m_data->m_hist2[ros][drawer][chan][gain][cap]->Fill(charge, amp);
687  }
688 
689  // avoid small signals and overflows in both gains
690  if ( ( (adc == 1) && (charge < hg_charge_cut) && (charge > hg_small_charge) ) ||
691  ( (adc == 0) && (charge < lg_charge_cut) && (charge > lg_small_charge) ) ) {
692 
693  double ratio = amp / charge;
694 
695  m_data->m_hist1[ros][drawer][chan][gain][0 + cap]->Fill(ratio);
696  m_data->m_hist1[ros][drawer][chan][gain][2 + cap]->Fill(time);
697  if (m_book2D) {
698  m_data->m_hist2[ros][drawer][chan][gain][cap + 2]->Fill(timeInj, time);
699  }
700 
701  /*TimeCov[ros][drawer][chan][gain][cap][0] += timeInj;
702  TimeCov[ros][drawer][chan][gain][cap][1] += timeInj*timeInj;
703  TimeCov[ros][drawer][chan][gain][cap][2] += time;
704  TimeCov[ros][drawer][chan][gain][cap][3] += time*time;
705  TimeCov[ros][drawer][chan][gain][cap][4] += timeInj*time;*/
706  ++m_data->m_timeCov[ros][drawer][chan][gain][cap][5];
707  }
708  } //if k==0 //Lukas
709  } else { // not CisRun
710  if (k == 0) { //Lukas
711  m_data->m_hist1[ros][drawer][chan][gain][0]->Fill(amp, 1.0);
712  if (time != 0) { // we don't fill the time when it is exactly 0, which is a conventional value to say that it is not
713  // calculated when the difference between the max(samples)-min(samples)< threshold
714  m_data->m_hist1[ros][drawer][chan][gain][1]->Fill(time, 1.0);
715  }
716 
717  m_data->m_timeCov[ros][drawer][chan][gain][0][0] += amp;
718  m_data->m_timeCov[ros][drawer][chan][gain][0][1] += amp * amp;
719  m_data->m_timeCov[ros][drawer][chan][gain][0][2] += time;
720  m_data->m_timeCov[ros][drawer][chan][gain][0][3] += time * time;
721  //TimeCov[ros][drawer][chan][gain][0][4] += amp*time;
722  ++m_data->m_timeCov[ros][drawer][chan][gain][0][5];
723  /*
724  //Lukas
725  if((ros==3 && drawer==14 && (chan==12 || chan==13 || chan==18 || chan==19))||(ros==4 && drawer==17 && (chan==12 || chan==13 || chan==18 || chan==19))){
726  }else if((ros==3 || ros==4) && (chan==0 || chan==1 || chan==12 || chan==13)){
727  }else{
728  sumTimeCh[ros][gain]+=time;
729  nCh[ros][gain]+=1;
730  }
731  //Lukas
732  */
733  //Lukas
734  if (isDisconnected(ros, drawer, chan) || amp < m_minAmpForCorrectedTime) continue;
735  if ((ros == 3 || ros == 4)
736  && (chan == 0 || chan == 1 || chan == 2 || chan == 3 || chan == 4 || chan == 5 || chan == 12 || chan == 13 || chan == 18
737  || chan == 19)) {
738  } else {
739  sumTimeCh[ros] += time;
740  nCh[ros] += 1;
741  }
742  //Lukas
743 
744  } //if k==0 //Lukas
745  else if (k == 1) { //Lukas
746  if (isDisconnected(ros, drawer, chan) || amp < m_minAmpForCorrectedTime) continue;
747 
748  timeCorr = time - avgTimePerPart[ros]; //Lukas
749  m_data->m_hist1[ros][drawer][chan][gain][2]->Fill(timeCorr, 1.0); //Lukas
750 
751  m_data->m_timeCovCorr[ros][drawer][chan][gain][0][0] += timeCorr; //Lukas
752  m_data->m_timeCovCorr[ros][drawer][chan][gain][0][1] += timeCorr * timeCorr; //Lukas
753  ++m_data->m_timeCovCorr[ros][drawer][chan][gain][0][2]; //Lukas
754 
755  } //k==1 //Lukas
756  } // end of nonCisRun
757  }
758 
759  } else { // if channel is not fired
760  }
761 
762  } // loop over channels
763  if (k == 0) { //Lukas
764  if (m_plotDsp) {
765  m_efitMap.insert(make_pair(ros * 100 + drawer, efitVec)); // needed later for dspreco comparison
766  m_tfitMap.insert(make_pair(ros * 100 + drawer, tfitVec)); // needed later for dspreco comparison
767  }
768  } //if k==0 //Lukas
769  }
770  }
771  //Lukas
772  if (k == 0) {
773  for (int iros = 0; iros < 5; iros++) {
774  if (nCh[iros] != 0) {
775  avgTimePerPart[iros] = sumTimeCh[iros] / nCh[iros];
776  } else {
777  avgTimePerPart[iros] = 0;
778  }
779  sumTimeCh[iros] = 0;
780  nCh[iros] = 0;
781  } //for
782  } //if k==0
783  //Lukas
784  } // loop over k //Lukas
785 
786  if (m_plotDsp) {
787  if (fillDsp(m_efitMap, m_tfitMap).isFailure()) ATH_MSG_WARNING("Error filling DSP histograms");
788  }
789 
790 
791  if ((m_summaryUpdateFrequency > 0) && (m_nEventsTileMon % m_summaryUpdateFrequency == 0)) {
792  m_drawHists = false;
793  CHECK(fillSummaryHistograms());
794  if (m_resetAfterSummaryUpdate) resetSummaryHistograms();
795  }
796 
797 
798 
800  return StatusCode::SUCCESS;
801 }
802 
803 /*---------------------------------------------------------*/
804 StatusCode TileRawChannelMonTool::fillDsp(std::map<int, std::vector<double> > &efitMap, std::map<int, std::vector<double> > &tfitMap)
805 /*---------------------------------------------------------*/
806 {
807 
808  ATH_MSG_DEBUG("in fillDsp()");
809 
810  const TileRawChannelContainer* RawChannelCnt;
811  CHECK(evtStore()->retrieve(RawChannelCnt, m_contNameDSP));
812 
813  TileRawChannelUnit::UNIT RChUnit = RawChannelCnt->get_unit();
814 
815  TileRawChannelContainer::const_iterator collItr = RawChannelCnt->begin();
816  TileRawChannelContainer::const_iterator lastColl = RawChannelCnt->end();
817 
818  for (; collItr != lastColl; ++collItr) {
819 
820  TileRawChannelCollection::const_iterator chItr = (*collItr)->begin();
821  TileRawChannelCollection::const_iterator lastCh = (*collItr)->end();
822 
823  if (chItr != lastCh) {
824 
825  HWIdentifier adc_id = (*chItr)->adc_HWID();
826  int ros = m_tileHWID->ros(adc_id);
827  int drawer = m_tileHWID->drawer(adc_id);
828 
829  if (m_data->m_histDsp1[ros][drawer][0][0].size() == 0) {
830  m_bigain = true;
831  bookDsp(ros, drawer);
832  }
833 
834  for (; chItr != lastCh; ++chItr) {
835 
836  const TileRawChannel * rch = (*chItr);
837 
838  adc_id = rch->adc_HWID();
839  unsigned int chan = m_tileHWID->channel(adc_id);
840  int adc = m_tileHWID->adc(adc_id);
841  int gain = (m_bigain) ? adc : 0; // ignore gain in monogain run
842  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
843 
844  if ((m_cispar[8] == 0) /* || ( m_cispar[8] == abs(m_cabling->channel2hole(ros,chan)) )*/
845  && !m_corrup[ros][drawer][gain][chan / 3]) { // channel is fired and not corrupted
846 
847  double amp = rch->amplitude();
848  if (RChUnit != m_calibUnit) {
849  if (m_calibUnit != TileRawChannelUnit::CesiumPicoCoulombs) { //We put everythin in the same unit
850  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, m_calibUnit);
851  } else { // it is =TileRawChannelUnit::CesiumPicoCoulombs, careful with MBTS channels
852  if (ros < 3) //if LB then it's ok CesiumPicoCoulomb
853  {
854  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
855  //conversion factor if of the order of 1000MeV=1.05pC
856  } else // check that they are not MBTS channel
857  {
858  int index, pmt;
859  /*Identifier cell_id =*/rch->cell_ID_index(index, pmt);
860  if (index < -1) // MBTS channel
861  {
862  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::PicoCoulombs);
863  } else //not MBTS channel
864  {
865  amp = m_tileToolEmscale->channelCalib(drawerIdx, chan, adc, amp, RChUnit, TileRawChannelUnit::CesiumPicoCoulombs);
866  }
867  }
868  } // end if CesiumPicoCouloumb
869  }
870 
871  double time = rch->time();
872  double chi2 = rch->quality();
873 
874  m_data->m_histDsp1[ros][drawer][chan][gain][Edsp]->Fill(amp, 1.0);
875  m_data->m_histDsp1[ros][drawer][chan][gain][Tdsp]->Fill(time, 1.0);
876  m_data->m_histDsp1[ros][drawer][chan][gain][chi2dsp]->Fill(chi2, 1.0);
877  m_data->m_histDsp2[ros][drawer][chan][gain][0]->Fill(amp, chi2, 1.0);
878  m_data->m_finalHistDsp2[ros][drawer][gain][0]->Fill(amp, chi2, 1.0);
879 
880  std::map<int, std::vector<double> >::iterator it = efitMap.find(ros * 100 + drawer);
881  if (it != efitMap.end()) {
882  double efit = (*it).second.at(chan + gain * 48);
883  it = tfitMap.find(ros * 100 + drawer);
884  double tfit = (*it).second.at(chan + gain * 48);
885  //convert from pC to ADC counts
886  if (TMath::Abs(efit) > m_efitThresh) { // fill the histogram only if the efit is above threshold
887  m_data->m_histDsp1[ros][drawer][chan][gain][Edsp_fit]->Fill((amp - efit) / efit, 1.0);
888  }
889 
890  if (tfit != 0.) {
891  m_data->m_histDsp1[ros][drawer][chan][gain][Tdsp_fit]->Fill((time - tfit), 1.0);
892  }
893 
894  }
895  }
896 
897  } // loop over channels
898 
899  }
900  }
901  return StatusCode::SUCCESS;
902 }
903 
904 
905 
906 
907 /*---------------------------------------------------------*/
908 void TileRawChannelMonTool::bookSummaryHistograms(int ros, int drawer)
909 /*---------------------------------------------------------*/
910 {
911 
912 
913  const std::array<std::string, 6> gain = { "_lo", "_hi", "", " low gain", " high gain", "" };
914 
915  // for bigain run book 2 histograms per channel
916  // for monogain run book just one histogram per channel
917  int mingain = (m_bigain) ? 0 : 2;
918  int maxgain = (m_bigain) ? 2 : 3;
919 
920  std::ostringstream sStr;
921 
922  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
923 
924  const char *HistName[6] = { "_tslope", "_toffset", "_qratio", " Time slope", " Time offset", " Amp/Q ratio" };
925  const char *CapName[4] = { "_100", "_5", " 100 pF", " 5 pF" };
926 
927 
928  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
929  std::string subDir = "Summary";
930  std::string histName, histTitle;
931 
932  for (int gn = mingain; gn < maxgain; ++gn) {
933  int adc = gn & 1;
934  for (int cap = 0; cap < 2; ++cap) {
935  for (int type = 0; type < 3; ++type) {
936 
937  sStr.str("");
938  sStr << moduleName << gain[gn] << HistName[type] << CapName[cap];
939  histName = sStr.str();
940  sStr.str("");
941  if (gn+3 >= std::ssize(gain)) throw std::out_of_range("Index out of range in TileRawChannelMonTool::bookSummaryHistograms");
942  sStr << moduleName << gain[3 + gn] << HistName[3 + type] << CapName[2 + cap];
943  histTitle = sStr.str();
944  m_data->m_finalHist1[ros][drawer][adc][cap].push_back(book1F(subDir, histName, histTitle, 48, 0, 48));
945  }
946  } //end of loop over capacitors
947  } //end of loop over gn
948 
949  } else { // not CisRun
950  const char *HistName[10] = { "_amp", "_rms", "_sigma", "_time", "_time_corr", " Amplitude", " RMS of amplitude", " Sigma amp from Gaussian fit",
951  " Average time and RMS", " Average time corr. and RMS" };
952  //Lukas
953 
954  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
955  std::string subDir = "Summary";
956  std::string histName, histTitle;
957 
958  for (int gn = mingain; gn < maxgain; ++gn) {
959 
960  int adc = gn & 1;
961 
962  //for (int type = 0; type < 4; ++type) {
963  for (int type = 0; type < 5; ++type) { //Lukas
964 
965  sStr.str("");
966  sStr << moduleName << gain[gn] << HistName[type];
967  histName = sStr.str();
968  sStr.str("");
969  if (gn+3 >= std::ssize(gain)) throw std::out_of_range("Index out of range in TileRawChannelMonTool::bookSummaryHistograms");
970  sStr << moduleName << gain[3 + gn] << HistName[5 + type]; //Lukas
971  histTitle = sStr.str();
972  m_data->m_finalHist1[ros][drawer][adc][0].push_back(book1F(subDir, histName, histTitle, 48, 0.0, 48.0));
973 
974  std::string hTitle(histTitle);
975 
976  if (m_doLaserSummaryVsPMT && m_runType == LasRun) {
977 
978  hTitle += " (Even PMTs)";
979  m_data->m_summaryPmts[ros][drawer][adc][0].push_back(book1F(subDir + "/pmt", histName + "_pmt_even", hTitle, 49, -0.5, 48.5));
980  m_data->m_summaryPmts[ros][drawer][adc][0].back()->SetMarkerStyle(22);
981  m_data->m_summaryPmts[ros][drawer][adc][0].back()->SetMarkerColor(2);
982  m_data->m_summaryPmts[ros][drawer][adc][0].back()->SetMarkerSize(0.75);
983 
984  hTitle = histTitle;
985  hTitle += " (Odd PMTs)";
986  m_data->m_summaryPmts[ros][drawer][adc][1].push_back(book1F(subDir + "/pmt", histName + "_pmt_odd", hTitle, 49, -0.5, 48.5));
987  m_data->m_summaryPmts[ros][drawer][adc][1].back()->SetMarkerStyle(23);
988  m_data->m_summaryPmts[ros][drawer][adc][1].back()->SetMarkerColor(4);
989  m_data->m_summaryPmts[ros][drawer][adc][1].back()->SetMarkerSize(0.75);
990 
991  if (ros < 3 && m_data->m_summaryPmts[0][drawer][adc][0].size() < (unsigned int)(type + 1)) {
992 
993  histName.replace(histName.begin(), histName.begin() + 3, "LB");
994  histTitle.replace(histTitle.begin(), histTitle.begin() + 3, "LB");
995  hTitle = histTitle;
996 
997  hTitle += " (LBA even PMTs + LBC odd PMTs: negative)";
998  m_data->m_summaryPmts[0][drawer][adc][0].push_back(book1F(subDir + "/pmt", histName + "_pmt_LBA-even_LBC-odd", hTitle, 97, -48.5, 48.5));
999  m_data->m_summaryPmts[0][drawer][adc][0].back()->SetMarkerStyle(22);
1000  m_data->m_summaryPmts[0][drawer][adc][0].back()->SetMarkerColor(2);
1001  m_data->m_summaryPmts[0][drawer][adc][0].back()->SetMarkerSize(0.75);
1002 
1003  hTitle = histTitle;
1004  hTitle += " (LBA odd PMTs + LBC even PMTs: negative)";
1005  m_data->m_summaryPmts[0][drawer][adc][1].push_back(book1F(subDir + "/pmt", histName + "_pmt_LBA-odd_LBC-even", hTitle, 97, -48.5, 48.5));
1006  m_data->m_summaryPmts[0][drawer][adc][1].back()->SetMarkerStyle(23);
1007  m_data->m_summaryPmts[0][drawer][adc][1].back()->SetMarkerColor(4);
1008  m_data->m_summaryPmts[0][drawer][adc][1].back()->SetMarkerSize(0.75);
1009  }
1010  }
1011  }
1012 
1013  } //end of loop over gn
1014  }
1015 
1016 }
1017 
1018 
1019 /*---------------------------------------------------------*/
1020 void TileRawChannelMonTool::resetSummaryHistograms()
1021 /*---------------------------------------------------------*/
1022 {
1023 
1024  memset(m_data->m_timeCov, 0, sizeof(m_data->m_timeCov));
1025  memset(m_data->m_timeCovCorr, 0, sizeof(m_data->m_timeCovCorr));
1026 
1027  int mingain = (m_bigain) ? 0 : 2;
1028  int maxgain = (m_bigain) ? 2 : 3;
1029 
1030  for (int ros = 1; ros < 5; ++ros) {
1031  for (int drawer = 0; drawer < 64; ++drawer) {
1032  if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1033  for (int ch = 0; ch < 48; ++ch) {
1034  for (int gn = mingain; gn < maxgain; ++gn) {
1035  for (auto h : m_data->m_hist1[ros][drawer][ch][gn]) h->Reset();
1036  for (auto h : m_data->m_hist2[ros][drawer][ch][gn]) h->Reset();
1037  }
1038  }
1039  }
1040  }
1041  }
1042 }
1043 
1044 
1045 /*---------------------------------------------------------*/
1046 StatusCode TileRawChannelMonTool::fillSummaryHistograms()
1047 /*---------------------------------------------------------*/
1048 {
1049 
1050  ATH_MSG_INFO("in fillFfinalHiststograms()");
1051 
1052  memset(m_data->m_rangeQ, 0, sizeof(m_data->m_rangeQ));
1053 
1054  TF1 * fit_gaus = new TF1("g", "gaus");
1055 
1056  // for bigain run book 2 histograms per channel
1057  // for monogain run book just one histogram per channel
1058  int mingain = (m_bigain) ? 0 : 2;
1059  int maxgain = (m_bigain) ? 2 : 3;
1060 
1061  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
1062  for (int ros = 1; ros < 5; ++ros) {
1063  for (int drawer = 0; drawer < 64; ++drawer) {
1064  if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1065  for (int gn = mingain; gn < maxgain; ++gn) {
1066 
1067  int adc = gn & 1;
1068  for (int cap = 0; cap < 2; ++cap) {
1069  for (int ch = 0; ch < 48; ++ch) {
1070 
1071  // int pmt = abs(m_cabling->channel2hole(ros,ch)); // number in range [1,48]
1072 
1073  TF1* polyfunc = 0;
1074  if (m_book2D) polyfunc = GetTimeFitFunc(m_data->m_hist2[ros][drawer][ch][adc][cap + 2]);
1075  if (polyfunc) {
1076  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinContent(ch + 1, polyfunc->GetParameter(1));
1077  if (polyfunc->GetParError(1) > 5) {
1078  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinError(ch + 1, 5.);
1079  } else {
1080  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinError(ch + 1, polyfunc->GetParError(1));
1081  }
1082  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinContent(ch + 1, polyfunc->GetParameter(0));
1083  if (polyfunc->GetParError(0) > 5) {
1084  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinError(ch + 1, 5.);
1085  } else {
1086  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinError(ch + 1, polyfunc->GetParError(0));
1087  }
1088 
1089  delete polyfunc; //important!
1090  }
1091 
1092  else {
1093  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinContent(ch + 1, 0.);
1094  m_data->m_finalHist1[ros][drawer][adc][cap][0]->SetBinError(ch + 1, 0.);
1095  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinContent(ch + 1, 0.);
1096  m_data->m_finalHist1[ros][drawer][adc][cap][1]->SetBinError(ch + 1, 0.);
1097  }
1098 
1099  TH1S * hist = m_data->m_hist1[ros][drawer][ch][adc][cap];
1100  int nbins = hist->GetNbinsX();
1101  int minbin = 1;
1102  for (; minbin < nbins; ++minbin) {
1103  if (hist->GetBinContent(minbin) > 0.0) {
1104  break;
1105  }
1106  }
1107  int maxbin = nbins;
1108  for (; maxbin > 1; --maxbin) {
1109  if (hist->GetBinContent(maxbin) > 0.0) {
1110  break;
1111  }
1112  }
1113 
1114  double mean = hist->GetMean();
1115  double xmin = hist->GetBinCenter(minbin);
1116  double xmax = hist->GetBinCenter(maxbin);
1117 
1118  //rangeErrorBar(xmin,xmax,mean);
1119  if (m_useratioerror) { // /use ratioerror bar or rangeerror bar ?
1120  ratioErrorBar(hist, xmin, xmax, mean);
1121  } else {
1122  rangeErrorBar(xmin, xmax, mean);
1123  }
1124 
1125  //std::cout << hist->GetName() <<" mean-xmin= "<< mean-xmin <<"\n";
1126  m_data->m_rangeQ[adc][cap][0][ch] = mean;
1127  m_data->m_rangeQ[adc][cap][1][ch] = std::max(0.0, mean - xmin);
1128  m_data->m_rangeQ[adc][cap][2][ch] = std::max(0.0, xmax - mean);
1129 
1130  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetBinContent(ch + 1, mean);
1131  }
1132  } //end of loop over capacitors
1133  } //end of loop over gn
1134 
1135  if(m_drawHists) {
1136  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
1137  drawHists(ros, drawer, moduleName);
1138  }
1139  }
1140  } //end of loop over drawer
1141  } //end of loop over ros
1142 
1143  } else { // not CisRun
1144 
1145  for (int ros = 1; ros < 5; ++ros) {
1146  for (int drawer = 0; drawer < 64; ++drawer) {
1147  if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1148  for (int gn = mingain; gn < maxgain; ++gn) {
1149 
1150  int adc = gn & 1;
1151  for (int ch = 0; ch < 48; ++ch) {
1152 
1153  // int pmt = abs(m_cabling->channel2hole(ros,ch)); // number in range [1,48]
1154 
1155  double Amp = 0.0, ErrA = 0.0, RMS = 0.0, ErrR = 0.0;
1156  double Time = 0.0, RMST = 0.0, Sigma = 0.0, ErrS = 0.0;
1157  double NEvents = m_data->m_timeCov[ros][drawer][ch][adc][0][5];
1158 
1159  double TimeCorr = 0.0, RMSTCorr = 0.0; //Lukas
1160  double NEventsCorr = m_data->m_timeCovCorr[ros][drawer][ch][adc][0][2]; //Lukas
1161 
1162  if (NEvents > 0.0) {
1163 
1164  Amp = m_data->m_timeCov[ros][drawer][ch][adc][0][0] / NEvents;
1165  RMS = m_data->m_timeCov[ros][drawer][ch][adc][0][1] / NEvents - Amp * Amp;
1166  if (RMS > 0.0) {
1167  RMS = sqrt(RMS);
1168  ErrA = RMS / sqrt(NEvents);
1169  ErrR = RMS / sqrt(2 * NEvents);
1170  } else {
1171  RMS = 0.0;
1172  }
1173 
1174  Time = m_data->m_timeCov[ros][drawer][ch][adc][0][2] / NEvents;
1175  RMST = m_data->m_timeCov[ros][drawer][ch][adc][0][3] / NEvents - Time * Time;
1176  if (RMST > 0.0) {
1177  RMST = sqrt(RMST);
1178  } else {
1179  RMST = 0.0;
1180  }
1181  }
1182 
1183  //Lukas
1184  if (NEventsCorr > 0.0) {
1185  TimeCorr = m_data->m_timeCovCorr[ros][drawer][ch][adc][0][0] / NEventsCorr;
1186  RMSTCorr = m_data->m_timeCovCorr[ros][drawer][ch][adc][0][1] / NEventsCorr - TimeCorr * TimeCorr;
1187  if (RMSTCorr > 0.0) {
1188  RMSTCorr = sqrt(RMSTCorr);
1189  } else {
1190  RMSTCorr = 0.0;
1191  }
1192  }
1193  //Lukas
1194 
1195  if (m_data->m_hist1[ros][drawer][ch][adc][0]->GetEntries() > 0) {
1196  if (adc == 0 && m_overlaphists) { // We have for LB histograms with variable-width bins, not suitable for a fit
1197  TH1S *h4fit=new TH1S(*(m_data->m_hist1[ros][drawer][ch][adc][0]));
1198  h4fit->Scale(1,"width");
1199  h4fit->Fit("g", "NQ");
1200  delete(h4fit);
1201  } else {
1202  m_data->m_hist1[ros][drawer][ch][adc][0]->Fit("g", "NQ");
1203  }
1204  Sigma = fit_gaus->GetParameter(2);
1205  ErrS = fit_gaus->GetParError(2);
1206  }
1207 
1208  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetBinContent(ch + 1, Amp);
1209  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetBinError(ch + 1, ErrA);
1210  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetBinContent(ch + 1, RMS);
1211  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetBinError(ch + 1, ErrR);
1212  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetBinContent(ch + 1, Sigma);
1213  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetBinError(ch + 1, ErrS);
1214  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetBinContent(ch + 1, Time);
1215  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetBinError(ch + 1, RMST);
1216  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetBinContent(ch + 1, TimeCorr); //Lukas
1217  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetBinError(ch + 1, RMSTCorr); //Lukas
1218 
1219  if (m_doLaserSummaryVsPMT && m_runType == LasRun) {
1220 
1221  int pmt = m_cabling->channel2hole(ros, ch);
1222  if (pmt < 0) continue;
1223 
1224  int fiber = (pmt % 2);
1225 
1226  m_data->m_summaryPmts[ros][drawer][adc][fiber][0]->SetBinContent(pmt + 1, Amp);
1227  m_data->m_summaryPmts[ros][drawer][adc][fiber][0]->SetBinError(pmt + 1, ErrA);
1228  m_data->m_summaryPmts[ros][drawer][adc][fiber][1]->SetBinContent(pmt + 1, RMS);
1229  m_data->m_summaryPmts[ros][drawer][adc][fiber][1]->SetBinError(pmt + 1, ErrR);
1230  m_data->m_summaryPmts[ros][drawer][adc][fiber][2]->SetBinContent(pmt + 1, Sigma);
1231  m_data->m_summaryPmts[ros][drawer][adc][fiber][2]->SetBinError(pmt + 1, ErrS);
1232  m_data->m_summaryPmts[ros][drawer][adc][fiber][3]->SetBinContent(pmt + 1, Time);
1233  m_data->m_summaryPmts[ros][drawer][adc][fiber][3]->SetBinError(pmt + 1, RMST);
1234  m_data->m_summaryPmts[ros][drawer][adc][fiber][4]->SetBinContent(pmt + 1, TimeCorr); //Lukas
1235  m_data->m_summaryPmts[ros][drawer][adc][fiber][4]->SetBinError(pmt + 1, RMSTCorr); //Lukas
1236 
1237  if (ros == 1) {
1238 
1239  int bin = m_data->m_summaryPmts[0][drawer][adc][fiber][0]->FindBin(pmt);
1240 
1241  m_data->m_summaryPmts[0][drawer][adc][fiber][0]->SetBinContent(bin, Amp);
1242  m_data->m_summaryPmts[0][drawer][adc][fiber][0]->SetBinError(bin, ErrA);
1243  m_data->m_summaryPmts[0][drawer][adc][fiber][1]->SetBinContent(bin, RMS);
1244  m_data->m_summaryPmts[0][drawer][adc][fiber][1]->SetBinError(bin, ErrR);
1245  m_data->m_summaryPmts[0][drawer][adc][fiber][2]->SetBinContent(bin, Sigma);
1246  m_data->m_summaryPmts[0][drawer][adc][fiber][2]->SetBinError(bin, ErrS);
1247  m_data->m_summaryPmts[0][drawer][adc][fiber][3]->SetBinContent(bin, Time);
1248  m_data->m_summaryPmts[0][drawer][adc][fiber][3]->SetBinError(bin, RMST);
1249  m_data->m_summaryPmts[0][drawer][adc][fiber][4]->SetBinContent(bin, TimeCorr); //Lukas
1250  m_data->m_summaryPmts[0][drawer][adc][fiber][4]->SetBinError(bin, RMSTCorr); //Lukas
1251 
1252  }
1253 
1254  if (ros == 2) {
1255 
1256  int bin = m_data->m_summaryPmts[0][drawer][adc][1 - fiber][0]->FindBin(-pmt);
1257 
1258  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][0]->SetBinContent(bin, Amp);
1259  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][0]->SetBinError(bin, ErrA);
1260  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][1]->SetBinContent(bin, RMS);
1261  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][1]->SetBinError(bin, ErrR);
1262  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][2]->SetBinContent(bin, Sigma);
1263  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][2]->SetBinError(bin, ErrS);
1264  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][3]->SetBinContent(bin, Time);
1265  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][3]->SetBinError(bin, RMST);
1266  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][4]->SetBinContent(bin, TimeCorr); //Lukas
1267  m_data->m_summaryPmts[0][drawer][adc][1 - fiber][4]->SetBinError(bin, RMSTCorr); //Lukas
1268 
1269  }
1270  }
1271 
1272  }
1273  } //end of loop over gn
1274 
1275  if(m_drawHists){
1276  std::string moduleName = TileCalibUtils::getDrawerString(ros, drawer);
1277  drawHists(ros, drawer, moduleName);
1278  if (m_plotDsp) {
1279  if (finalDsp(ros, drawer).isFailure()) ATH_MSG_WARNING("Error finalizing DSP histograms");
1280  }
1281  }
1282 
1283  }
1284  } //loop over drawer
1285  } //loop over ros
1286  }
1287 
1288  delete fit_gaus;
1289 
1290  return StatusCode::SUCCESS;
1291 }
1292 
1293 
1294 
1295 
1296 /*---------------------------------------------------------*/
1297 StatusCode TileRawChannelMonTool::finalHists()
1298 /*---------------------------------------------------------*/
1299 {
1300  ATH_MSG_INFO("in finalHists()");
1301 
1302  if (m_summaryUpdateFrequency == 0) {
1303  for (int ros = 1; ros < 5; ++ros) {
1304  for (int drawer = 0; drawer < 64; ++drawer) {
1305  if (m_data->m_hist1[ros][drawer][0][0].size() != 0) {
1306  bookSummaryHistograms(ros, drawer);
1307  }
1308  }
1309  }
1310  }
1311 
1312  m_drawHists = true;
1313  CHECK(fillSummaryHistograms());
1314 
1315 
1316  return StatusCode::SUCCESS;
1317 }
1318 
1319 /*---------------------------------------------------------*/
1320 StatusCode TileRawChannelMonTool::finalDsp(int ros, int drawer)
1321 /*---------------------------------------------------------*/
1322 {
1323 
1324  if (m_data->m_histDsp1[ros][drawer][0][0].size() != 0) {
1325 
1327  const TileRawChannelContainer* RawChannelCntDsp;
1328 
1329  unsigned int iteration = 0u;
1330  unsigned int algorithm = 0u;
1331  if (evtStore()->retrieve(RawChannelCntDsp, m_contNameDSP).isSuccess()) {
1332  uint32_t info = RawChannelCntDsp->get_bsflags() >> 24u;
1333  iteration = info & 3u;
1334  algorithm = (info >> 2u) & 1u;
1335 
1336  // iteration: "NI", "I1", "I2", "I3"
1337  // algorithm: "OF1", "OF2"
1338  }
1339 
1340  const char *alg_name[2] = { "OF1", "OF2" };
1341  const char * iter_name[4] = { "NI", "I1", "I2", "I3" };
1342 
1343  const char *part[5] = { "AUX", "LBA", "LBC", "EBA", "EBC" };
1344  const char *gain[4] = { "_lo", "_hi", " low gain", " high gain" };
1345 
1346  int mingain = 0;
1347  int maxgain = 2;
1348 
1349 // const char *HistName[9] = {"_dspfit_ampdiff","_dspfit_timediff","_dspamp",
1350 // " Average (DSP-"," Average DSP-", " Average DSP-",
1351 // " - OFF-OF2-I) divided by OFF-OF2-I Amplitudes and RMS"," - OFF-OF2-I Time and RMS", " Amplitudes and RMS"};
1352  const char *HistName[9] = { "_dspfit_ampdiff", "_dspfit_timediff", "_dspamp", " Avg. (DSP-", " Average DSP-", " Average DSP-",
1353  " - OFF-OF2-I) / OFF Amplitudes and RMS", " - OFF-OF2-I Time and RMS", " Amplitudes and RMS" };
1354 
1355  std::ostringstream sStr;
1356  sStr << part[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ');
1357  std::string moduleName = sStr.str();
1358  std::string subDir = "Summary";
1359  std::string histName, histTitle;
1360 
1361  for (int gn = mingain; gn < maxgain; ++gn) {
1362 
1363  int adc = gn & 1;
1364 
1365  for (int type = sumEdsp_fit; type < NsumDsp; ++type) {
1366  sStr.str("");
1367  sStr << moduleName << gain[gn] << HistName[type];
1368  histName = sStr.str();
1369  sStr.str("");
1370  sStr << moduleName << gain[2 + gn] << HistName[3 + type] << alg_name[algorithm] << "-" << iter_name[iteration] << HistName[6 + type];
1371  histTitle = sStr.str();
1372  m_data->m_finalHistDsp1[ros][drawer][adc].push_back(book1F(subDir, histName, histTitle, 48, 0.0, 48.0));
1373  }
1374 
1375  //Create hbar histograms to be used in drawDsp
1376  sStr.str("");
1377  sStr << moduleName << gain[gn] << "_dspfit_amphbar";
1378  histName = sStr.str();
1379  sStr.str("");
1380  sStr << moduleName << gain[2 + gn] << " (DSP-" << alg_name[algorithm] << "-" << iter_name[iteration]
1381  << " - OFF-OF2-I) divided by OFF Amplitudes for all chans";
1382  histTitle = sStr.str();
1383  m_data->m_hBarDsp1[ros][drawer][adc].push_back(book1F(subDir, histName, histTitle, 404, -1.01, 1.01));
1384 
1385  sStr.str("");
1386  sStr << moduleName << gain[gn] << "_dspfit_timehbar";
1387  histName = sStr.str();
1388  sStr.str("");
1389  sStr << moduleName << gain[2 + gn] << " (DSP-" << alg_name[algorithm] << "-" << iter_name[iteration] << " - OFF-OF2-I) Time for all chans";
1390  histTitle = sStr.str();
1391  m_data->m_hBarDsp1[ros][drawer][adc].push_back(book1F(subDir, histName, histTitle, 101, -2.02, 2.02));
1392 
1393  for (int ch = 0; ch < 48; ++ch) {
1394  // int pmt = abs(m_cabling->channel2hole(ros,ch)); // number in range [1,48]
1395 
1396  if (m_data->m_histDsp1[ros][drawer][ch][adc][Edsp_fit]->GetEntries() > 0) {
1397  double dspmean = m_data->m_histDsp1[ros][drawer][ch][adc][Edsp]->GetMean();
1398  double dsprms = m_data->m_histDsp1[ros][drawer][ch][adc][Edsp]->GetRMS();
1399  double emean = m_data->m_histDsp1[ros][drawer][ch][adc][Edsp_fit]->GetMean();
1400  double erms = m_data->m_histDsp1[ros][drawer][ch][adc][Edsp_fit]->GetRMS();
1401  double tmean = m_data->m_histDsp1[ros][drawer][ch][adc][Tdsp_fit]->GetMean();
1402  double trms = m_data->m_histDsp1[ros][drawer][ch][adc][Tdsp_fit]->GetRMS();
1403 
1404  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp]->SetBinContent(ch + 1, dspmean);
1405  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp]->SetBinError(ch + 1, dsprms);
1406  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetBinContent(ch + 1, emean);
1407  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetBinError(ch + 1, erms);
1408  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetBinContent(ch + 1, tmean);
1409  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetBinError(ch + 1, trms);
1410 
1411  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->Add(m_data->m_histDsp1[ros][drawer][ch][adc][Edsp_fit]);
1412  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->Add(m_data->m_histDsp1[ros][drawer][ch][adc][Tdsp_fit]);
1413 
1414  }
1415  }
1416  } // close loops over chans, gain
1417 
1418  // log << MSG::WARNING << "LUCA Calling drawDsp" << endreq;
1419  drawDsp(ros, drawer, moduleName);
1420 
1421  } //close if there are histograms for this Module
1422 
1423  return StatusCode::SUCCESS;
1424 }
1425 
1426 /*---------------------------------------------------------*/
1427 StatusCode TileRawChannelMonTool::checkHists(bool /* fromFinalize */)
1428 /*---------------------------------------------------------*/
1429 {
1430 
1431  ATH_MSG_INFO("in checkHists()");
1432 
1433  return StatusCode::SUCCESS;
1434 }
1435 
1436 /*---------------------------------------------------------*/
1437 void TileRawChannelMonTool::drawHists(int ros, int drawer, const std::string& moduleName)
1438 /*---------------------------------------------------------*/
1439 {
1440 
1441  ATH_MSG_DEBUG("in drawHists()");
1442 
1443  int maxgain = (m_bigain) ? 2 : 1;
1444  double ms = (m_bigain) ? 0.75 : 1.0; // marker size
1445 
1446  bool do_plots = m_savePng || m_savePs || m_saveSvg;
1447 
1448  if ((m_runType == CisRun) || (m_runType == CisRamp)) {
1449 
1450  float X_axis[48];
1451  float X_errors[48];
1452  for (int i = 0; i < 48; i++) {
1453  X_axis[i] = i + 0.5;
1454  X_errors[i] = 0.;
1455  }
1456 
1457  const char *gain[6] = { "_lo", "_hi", "", " low gain", " high gain", "" };
1458  const char *CapName[4] = { "_100", "_5", " 100 pF", " 5 pF" };
1459  if (maxgain == 1) gain[0] = gain[1] = gain[2] = gain[3] = gain[4] = gain[5];
1460 
1461  /* TGraph* test = new TGraph(48,X_errors,X_errors);
1462  test->SetName(("/HIST1/Tile/RawChannel/Summary/LFTEST"+moduleName).c_str());
1463  m_rootsvc->regGraph("/HIST1/Tile/RawChannel/Summary/LFTEST"+moduleName, test);
1464  */
1465 
1466  TCanvas * Can = NULL;
1467  if (do_plots) {
1468  Can = new TCanvas("amp_ratio", "amp_ratio", 402 * maxgain, 588);
1469  Can->Divide(maxgain, 2);
1470  gStyle->SetOptStat(0);
1471  gStyle->SetTitleFontSize(0.1);
1472  }
1473 
1474  TLine line(0., 1., 48., 1.); //Draw a green line to guide the sight
1475  line.SetLineColor(3);
1476 
1477  std::string subDir = "Summary";
1478  std::vector<TGraphAsymmErrors*> grapherrVec;
1479 
1480  for (int adc = 0; adc < maxgain; ++adc) {
1481  for (int cap = 0; cap < 2; ++cap) {
1482 
1483  std::ostringstream sStr;
1484  sStr << moduleName << gain[adc] << "_tails" << CapName[cap];
1485  std::string graphName = sStr.str();
1486  sStr.str("");
1487  sStr << moduleName << gain[adc + 3] << " Mean Amp/Q ratio and up/down tails " << CapName[2 + cap];
1488  std::string graphTitle = sStr.str();
1489 
1490  TVirtualPad * pad;
1491  if (do_plots) {
1492  pad = Can->cd(cap * maxgain + adc + 1);
1493  pad->SetTopMargin(0.15);
1494  pad->SetGridx();
1495  }
1496 
1497  TGraphAsymmErrors * final_Egraph = bookGraphAsymmErrors(subDir, graphName, graphTitle, 48, X_axis, m_data->m_rangeQ[adc][cap][0], X_errors, X_errors,
1498  m_data->m_rangeQ[adc][cap][1], m_data->m_rangeQ[adc][cap][2]);
1499  grapherrVec.push_back(final_Egraph);
1500 
1501  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetStats(kFALSE);
1502  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetMarkerStyle(21);
1503  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetMarkerSize(ms);
1504  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetLabelSize(0.06, "X");
1505  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetLabelSize(0.06, "Y");
1506  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetMaximum(2.2);
1507  m_data->m_finalHist1[ros][drawer][adc][cap][2]->SetMinimum(-0.2);
1508  if (do_plots) m_data->m_finalHist1[ros][drawer][adc][cap][2]->Draw("P0");
1509 
1510  final_Egraph->SetMarkerStyle(21);
1511  final_Egraph->SetMarkerSize(ms);
1512  final_Egraph->SetMaximum(2.2);
1513  final_Egraph->SetMinimum(-0.2);
1514  final_Egraph->GetXaxis()->SetRangeUser(0, 48);
1515  if (do_plots) {
1516  final_Egraph->Draw("P0");
1517  line.Draw();
1518  }
1519 
1520  }
1521  }
1522 
1523  if (m_savePng) {
1524  Can->Print(TString(moduleName + "_amp_ratio.png"), "png");
1525  }
1526  if (m_savePs) {
1527  Can->Print(TString(moduleName + "_amp_ratio.ps"), "ps");
1528  }
1529  if (m_saveSvg) {
1530  Can->Print(TString(moduleName + "_amp_ratio.svg"), "svg");
1531  }
1532  if (do_plots) delete Can;
1533 
1534 // we have to remove TGraphAsymmErrors in 13.0.10, because THistSvc doesn't handle them well
1535  if (!m_storeGraph) {
1536  std::vector<TGraphAsymmErrors*>::const_iterator it = grapherrVec.begin();
1537  std::vector<TGraphAsymmErrors *>::const_iterator itend = grapherrVec.end();
1538  for (; it != itend; ++it) {
1539  if ((removeTObj(*it)).isFailure()) ATH_MSG_WARNING("Problems removing TObj");
1540  }
1541  }
1542 
1543  if (do_plots) {
1544  Can = new TCanvas("fit_time", "fit_time", 402 * maxgain, 588);
1545  Can->Divide(maxgain, 4);
1546  gStyle->SetOptStat(0);
1547  gStyle->SetTitleFontSize(0.1);
1548  }
1549 
1550  double maxy[2] = { 1.4, 15.0 };
1551  double miny[2] = { -0.1, -15.0 };
1552 
1553  for (int adc = 0; adc < maxgain; ++adc) {
1554  for (int cap = 0; cap < 2; ++cap) {
1555  for (int type = 0; type < 2; ++type) {
1556 
1557  TVirtualPad * pad;
1558  if (do_plots) {
1559  pad = Can->cd((type + cap * 2) * maxgain + adc + 1);
1560  pad->SetTopMargin(0.15);
1561  pad->SetGridx();
1562  }
1563 
1564  if (m_data->m_finalHist1[ros][drawer][adc][cap][type]->GetMaximum() < 0.9 * maxy[type])
1565  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetMaximum(maxy[type]);
1566  if (m_data->m_finalHist1[ros][drawer][adc][cap][type]->GetMinimum() > (miny[type] + 0.1 * TMath::Abs(miny[type])))
1567  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetMinimum(miny[type]);
1568 
1569  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetMarkerStyle(21);
1570  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetMarkerSize(ms);
1571  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetLabelSize(0.10, "X");
1572  m_data->m_finalHist1[ros][drawer][adc][cap][type]->SetLabelSize(0.10, "Y");
1573  if (do_plots) {
1574  m_data->m_finalHist1[ros][drawer][adc][cap][type]->Draw("P0");
1575 
1576  line.SetLineColor(3);
1577  line.Draw();
1578  }
1579  }
1580  }
1581  }
1582 
1583  if (m_savePng) {
1584  Can->Print(TString(moduleName + "_fit_time.png"), "png");
1585  }
1586  if (m_savePs) {
1587  Can->Print(TString(moduleName + "_fit_time.ps"), "ps");
1588  }
1589  if (m_saveSvg) {
1590  Can->Print(TString(moduleName + "_fit_time.svg"), "svg");
1591  }
1592  if (do_plots) delete Can;
1593 
1594  } else {
1595  if ((m_runType == LasRun) || (m_runType == LedRun)) { //same stuff but with Laser fancy colors
1596  LaserFancyPlotting(ros, drawer, maxgain, moduleName);
1597  } else {
1598 
1599  TCanvas * Can = NULL;
1600  if (do_plots) {
1601  Can = new TCanvas("fit_amp", "fit_amp", 402 * maxgain, 588);
1602  Can->Divide(maxgain, 3);
1603  gStyle->SetOptStat(0);
1604  gStyle->SetTitleFontSize(0.1);
1605  }
1606 
1607  double maxy[6] = { 1.0, 0.05, 1.0, 0.05, 25.0, 25.0 };
1608  double miny[6] = { -1.0, -0.05, 0.0, 0.0, -25.0, -25.0 };
1609 
1610  for (int adc = 0; adc < maxgain; ++adc) {
1611 
1612  double max0 = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetMaximum();
1613  double max1 = m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMaximum();
1614  double max2 = m_data->m_finalHist1[ros][drawer][adc][0][2]->GetMaximum();
1615  double max3 = m_data->m_finalHist1[ros][drawer][adc][0][3]->GetMaximum();
1616  double min0 = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetMinimum();
1617  double min1 = m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMinimum();
1618  double min2 = m_data->m_finalHist1[ros][drawer][adc][0][2]->GetMinimum();
1619  double min3 = m_data->m_finalHist1[ros][drawer][adc][0][3]->GetMinimum();
1620 
1621  TVirtualPad * pad;
1622  if (do_plots) {
1623  pad = Can->cd(adc + 1);
1624  pad->SetTopMargin(0.15);
1625  pad->SetGridx();
1626  }
1627 
1628  if (max0 < 0.9 * maxy[adc]) m_data->m_finalHist1[ros][drawer][adc][0][0]->SetMaximum(maxy[adc]);
1629  if (min0 > (miny[adc] + 0.1 * TMath::Abs(miny[adc]))) m_data->m_finalHist1[ros][drawer][adc][0][0]->SetMinimum(miny[adc]);
1630 
1631  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetMarkerStyle(21);
1632  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetMarkerSize(ms);
1633  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetLabelSize(0.08, "X");
1634  m_data->m_finalHist1[ros][drawer][adc][0][0]->SetLabelSize(0.08, "Y");
1635  if (do_plots) {
1636  m_data->m_finalHist1[ros][drawer][adc][0][0]->Draw("E0");
1637  }
1638 
1639  if (do_plots) {
1640  pad = Can->cd(maxgain + adc + 1);
1641  pad->SetTopMargin(0.15);
1642  pad->SetGridx();
1643  }
1644 
1645  // if (max2 > 5 * max1) max2 = 2 * max1; // don't put crazy fit results on plot
1646  if (max1 < maxy[2 + adc]) {
1647  if (max2 < maxy[2 + adc])
1648  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMaximum(maxy[2 + adc]);
1649  else
1650  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMaximum(max2);
1651  } else {
1652  if (max1 < max2) m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMaximum(max2);
1653  }
1654 
1655  if (min1 > miny[2 + adc]) {
1656  if (min2 > miny[2 + adc])
1657  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMinimum(miny[2 + adc]);
1658  else
1659  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMinimum(min2);
1660  } else {
1661  if (min1 > min2) m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMinimum(min2);
1662  }
1663 
1664  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMarkerStyle(21);
1665  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMarkerSize(ms);
1666  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetLabelSize(0.08, "X");
1667  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetLabelSize(0.08, "Y");
1668  if (do_plots) {
1669  m_data->m_finalHist1[ros][drawer][adc][0][1]->Draw("P0");
1670  }
1671 
1672  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMaximum(m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMaximum());
1673  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMinimum(m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMinimum());
1674  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerStyle(25);
1675  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerSize(ms);
1676  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerColor(4);
1677  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetLabelSize(0.08, "X");
1678  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetLabelSize(0.08, "Y");
1679  if (do_plots) {
1680  m_data->m_finalHist1[ros][drawer][adc][0][2]->Draw("sameP0");
1681  }
1682 
1683  if (do_plots) {
1684  pad = Can->cd(2 * maxgain + adc + 1);
1685  pad->SetTopMargin(0.15);
1686  pad->SetGridx();
1687  }
1688 
1689  if (max3 < 0.9 * maxy[4 + adc]) m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMaximum(maxy[4 + adc]);
1690  if (min3 > (miny[4 + adc] + 0.1 * TMath::Abs(miny[4 + adc]))) m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMinimum(miny[4 + adc]);
1691 
1692  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMarkerStyle(21);
1693  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMarkerSize(ms);
1694  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetLabelSize(0.08, "X");
1695  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetLabelSize(0.08, "Y");
1696  if (do_plots) {
1697  m_data->m_finalHist1[ros][drawer][adc][0][3]->Draw("E0");
1698  }
1699 
1700  } //end of loop over gain
1701 
1702  if (m_savePng) {
1703  Can->Print(TString(moduleName + "_fit_amp.png"), "png");
1704  }
1705  if (m_savePs) {
1706  Can->Print(TString(moduleName + "_fit_amp.ps"), "ps");
1707  }
1708  if (m_saveSvg) {
1709  Can->Print(TString(moduleName + "_fit_amp.svg"), "svg");
1710  }
1711  if (do_plots) delete Can;
1712  }
1713  }
1714 }
1715 
1716 /*---------------------------------------------------------*/
1717 void TileRawChannelMonTool::drawDsp(int ros, int drawer, const std::string& moduleName)
1718 /*---------------------------------------------------------*/
1719 {
1720  MsgStream log(msgSvc(), name());
1721  int maxgain = (m_bigain) ? 2 : 1;
1722  double ms = (m_bigain) ? 0.75 : 1.0; // marker size
1723  bool do_plots = m_savePng || m_savePs || m_saveSvg;
1724 
1725  TCanvas * Can = NULL; // for -Wmaybe-uninitialized
1726  if (do_plots) {
1727  Can = new TCanvas("dsp_amp", "dsp_amp", 402 * maxgain, 588);
1728  Can->Divide(maxgain, 3);
1729  gStyle->SetOptStat(0);
1730  gStyle->SetTitleFontSize(0.1);
1731  }
1732 
1733  TLine line(0., 0., 48., 0.); //Draw a green line to guide the sight
1734  line.SetLineColor(3);
1735 
1736  double maxy[6] = { 0.05, 0.05, 0.5, 0.5, 10.0, 10.0 };
1737  double miny[6] = { -0.05, -0.05, -0.5, -0.5, -0.05, -0.05 };
1738  double norm[2] = { 1., 1 };
1739  for (int adc = 0; adc < maxgain; ++adc) {
1740 
1741  double maxEdsp = m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->GetMaximum();
1742  double minEdsp = m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->GetMinimum();
1743  double maxTdsp = m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->GetMaximum();
1744  double minTdsp = m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->GetMinimum();
1745  double maxchidsp = m_data->m_finalHistDsp2[ros][drawer][adc][0]->GetMaximum();
1746  double minchidsp = m_data->m_finalHistDsp2[ros][drawer][adc][0]->GetMinimum();
1747 
1748  TVirtualPad * pad;
1749  if (do_plots) {
1750  pad = Can->cd(adc + 1);
1751  pad->SetTopMargin(0.15);
1752  pad->SetGridx();
1753  }
1754 
1755  if (maxEdsp < 0.9 * maxy[adc]) m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetMaximum(maxy[adc]);
1756  if (minEdsp > miny[adc] + 0.1 * TMath::Abs(miny[adc])) m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetMinimum(miny[adc]);
1757 
1758  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetMarkerStyle(21);
1759  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetMarkerSize(ms);
1760  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetLabelSize(0.08, "X");
1761  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->SetLabelSize(0.08, "Y");
1762  if (do_plots) m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->Draw("");
1763 
1764  //Now we add the 1d histogram on the y-axis
1765  if (m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->GetMaximum() > 0.1) { //normalize the scale to get into the frame
1766  norm[sumEdsp_fit] = 47. / m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->GetMaximum();
1767  }
1768  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->Scale(norm[sumEdsp_fit]);
1769  //hbardsp1[ros][drawer][adc][sumEdsp_fit]->SetFillStyle(3350);
1770  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->SetFillColor(38);
1771  if (do_plots) {
1772  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->Draw("hbar,same");
1773 
1774  m_data->m_finalHistDsp1[ros][drawer][adc][sumEdsp_fit]->Draw("E0,same");
1775 
1776  line.Draw();
1777 
1778  pad = Can->cd(maxgain + adc + 1);
1779  pad->SetTopMargin(0.15);
1780  pad->SetGridx();
1781  }
1782 
1783  if (maxTdsp < 0.9 * maxy[2 + adc]) m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetMaximum(maxy[2 + adc]);
1784  if (minTdsp > miny[2 + adc] + 0.1 * TMath::Abs(miny[2 + adc])) m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetMinimum(miny[2 + adc]);
1785 
1786  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetMarkerStyle(21);
1787  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetMarkerSize(ms);
1788  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetLabelSize(0.08, "X");
1789  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->SetLabelSize(0.08, "Y");
1790  if (do_plots) m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->Draw("");
1791 
1792  if (m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->GetMaximum() > 0.1) { //normalize the scale to get into the frame
1793  norm[sumTdsp_fit] = 47. / m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->GetMaximum();
1794  }
1795  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->Scale(norm[sumTdsp_fit]);
1796  // hbardsp1[ros][drawer][adc][sumTdsp_fit]->SetFillStyle(3350);
1797  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->SetFillColor(38);
1798  if (do_plots) {
1799  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->Draw("hbar,same");
1800 
1801  m_data->m_finalHistDsp1[ros][drawer][adc][sumTdsp_fit]->Draw("E0,same");
1802 
1803  line.Draw();
1804 
1805  pad = Can->cd(2 * maxgain + adc + 1);
1806  pad->SetTopMargin(0.15);
1807  pad->SetGridx();
1808  pad->SetGridy();
1809  }
1810 
1811  if (maxchidsp < 0.9 * maxy[4 + adc]) m_data->m_finalHistDsp2[ros][drawer][adc][0]->SetMaximum(maxy[4 + adc]);
1812  if (minchidsp > miny[4 + adc] + 0.1 * TMath::Abs(miny[4 + adc])) m_data->m_finalHistDsp2[ros][drawer][adc][0]->SetMinimum(miny[4 + adc]);
1813 
1814  m_data->m_finalHistDsp2[ros][drawer][adc][0]->SetLabelSize(0.08, "X");
1815  m_data->m_finalHistDsp2[ros][drawer][adc][0]->SetLabelSize(0.08, "Y");
1816  if (do_plots) {
1817  gStyle->SetPalette(1);
1818  m_data->m_finalHistDsp2[ros][drawer][adc][0]->Draw("zcol");
1819  }
1820 
1821  } //end of loop over gain
1822 
1823  if (m_savePng) {
1824  Can->Print(TString(moduleName + "_dsp_amp.png"), "png");
1825  }
1826  if (m_savePs) {
1827  Can->Print(TString(moduleName + "_dsp_amp.ps"), "ps");
1828  }
1829  if (m_saveSvg) {
1830  Can->Print(TString(moduleName + "_dsp_amp.svg"), "svg");
1831  }
1832  if (do_plots) delete Can;
1833 
1834  for (int adc = 0; adc < maxgain; ++adc) {
1835  m_data->m_hBarDsp1[ros][drawer][adc][sumEdsp_fit]->Scale(1 / norm[sumEdsp_fit]); //back to normal
1836  m_data->m_hBarDsp1[ros][drawer][adc][sumTdsp_fit]->Scale(1 / norm[sumTdsp_fit]); //back to normal
1837  }
1838 }
1839 
1840 /*---------------------------------------------------------*/
1841 void TileRawChannelMonTool::rangeErrorBar(double& xmin, double& xmax, double mean) {
1842  /*---------------------------------------------------------*/
1849  if (m_DownLimit < mean && mean < m_UpLimit) {
1850  if (xmin > m_DownLimit) xmin = mean;
1851  if (xmax < m_UpLimit) xmax = mean;
1852  }
1853 
1854 }
1855 
1856 /*---------------------------------------------------------*/
1857 void TileRawChannelMonTool::ratioErrorBar(TH1S* hist, double& xmin, double& xmax, double mean) {
1858  /*---------------------------------------------------------*/
1869  if (m_DownLimit < mean && mean < m_UpLimit) {
1870 
1871  if (xmin > m_DownLimit) {
1872  xmin = mean;
1873  } else {
1874  int lo_thrbin = hist->FindBin(m_DownLimit); //
1875  double integral = hist->Integral(0, lo_thrbin); // we also want underflow, in case... Integral() is calculated including the contents of both limiting bins. As 0.7 falls in the middle of a bin, we are calculating the integral by excess
1876  double ratio = integral / (hist->GetEntries());
1877  if (ratio > m_hi_IntegralLimit) {
1878  xmin = mean - 1.05;
1879  } //larger error bar
1880  else if (ratio > m_med_IntegralLimit) {
1881  xmin = mean - 0.7;
1882  } //intermediate error bar
1883  else if (ratio > m_lo_IntegralLimit) {
1884  xmin = mean - 0.35;
1885  } //small error bar
1886  else {
1887  xmin = mean;
1888  }
1889  }
1890 
1891  if (xmax < m_UpLimit) {
1892  xmax = mean;
1893  } else {
1894  int hi_thrbin = hist->FindBin(m_UpLimit);
1895  double integral = hist->Integral(hi_thrbin, (hist->GetNbinsX() + 1)); //we also want overflow, in case... Integral() is calculated including the contents of both limiting bins. As 1.3 falls in the middle of a bin, we are calculating the integral by excess.
1896  double ratio = integral / (hist->GetEntries());
1897  if (ratio > m_hi_IntegralLimit) {
1898  xmax = mean + 1.05;
1899  } //larger error bar
1900  else if (ratio > m_med_IntegralLimit) {
1901  xmax = mean + 0.7;
1902  } //intermediate error bar
1903  else if (ratio > m_lo_IntegralLimit) {
1904  xmax = mean + 0.35;
1905  } //small error bar
1906  else {
1907  xmax = mean;
1908  }
1909  }
1910  }
1912 }
1913 
1916 /*---------------------------------------------------------*/
1917 TF1* TileRawChannelMonTool::GetTimeFitFunc(TH2S* hist2d) {
1918  /*---------------------------------------------------------*/
1919 //the TF1 pointer is created with new, please use a delete after the parameters have been extracted!
1920  if (hist2d) {
1921  TProfile* prof = hist2d->ProfileX();
1922 
1923  if (prof) {
1924  TH1S hist("hist", "TMP Histo", prof->GetNbinsX(), prof->GetBinLowEdge(1), prof->GetBinLowEdge(prof->GetNbinsX() + 1));
1925  float lastbin = -99.;
1926  float lasti = 0.;
1927  float shift = 0.;
1928  for (int i = 1; i < prof->GetNbinsX() + 1; i++) {
1929  if (prof->GetBinError(i) > 1e-7) {
1930  if ((shift < 1.) && ((prof->GetBinContent(i) - (lastbin + (i - lasti))) < -10.)) { //allow only 1 shift and only of negative sign
1931  shift = 25.;
1932  }
1933  lasti = i;
1934  lastbin = prof->GetBinContent(i);
1935  hist.SetBinContent(i, prof->GetBinContent(i) + shift);
1936  hist.SetBinError(i, prof->GetBinError(i));
1937  }
1938  } // end for loop on the histogram bins
1939  TF1* polfun = new TF1("polfun", "pol1", 0., 25.); //remember to delete!
1940  hist.Fit("polfun", "NQ");
1941 
1942  polfun->SetParameter(0, polfun->GetParameter(0) - 25.); // shift by -25 ns to be consistent with previous definition
1943  delete prof; //not needed, but these profiles appears in the root files, even if they are not booked
1944  return polfun; //rember to delete!
1945  }
1946  }
1947  return 0;
1948 }
1949 /*---------------------------------------------------------*/
1950 bool TileRawChannelMonTool::checkDmuHeader(std::vector<uint32_t>* headerVec, int dmu)
1951 /*---------------------------------------------------------*/
1952 {
1953  bool err = false;
1954 
1955  if (checkDmuHeaderFormat((*headerVec)[dmu])) {
1956  err = true;
1957 
1958  }
1959  if (checkDmuHeaderParity((*headerVec)[dmu])) {
1960  err = true;
1961 
1962  }
1963  if (((*headerVec)[dmu] >> 25) & 0x1) {
1964  //Memory Parity Error
1965  err = true;
1966 
1967  }
1968  if (((*headerVec)[dmu] >> 24) & 0x1) {
1969  //Single Strobe Error
1970  err = true;
1971 
1972  }
1973  if (((*headerVec)[dmu] >> 23) & 0x1) {
1974  //Double Strobe Error
1975  err = true;
1976 
1977  }
1978 
1979  return err;
1980 }
1981 /*---------------------------------------------------------*/
1982 void TileRawChannelMonTool::LaserFancyPlotting(int ros, int drawer, int maxgain, const std::string& moduleName) {
1983  /*---------------------------------------------------------*/
1984 
1985  ATH_MSG_DEBUG("in LaserFancyPlotting...");
1986 
1987  //TCanvas * Can = new TCanvas("fit_amp","fit_amp",402*maxgain,588);
1988  bool do_plots = m_savePng || m_savePs || m_saveSvg;
1989  TCanvas * Can = NULL;
1990  if (do_plots) {
1991  Can = new TCanvas("fit_amp", "fit_amp", 402 * maxgain, 735); //Lukas
1992  //Can->Divide(maxgain, 4);
1993  Can->Divide(maxgain, 5); //Lukas
1994  gStyle->SetOptStat(0);
1995  gStyle->SetTitleFontSize(0.1);
1996  }
1997  TLine *line = new TLine();
1998  line->SetLineWidth(2);
1999  line->SetLineStyle(7);
2000  line->SetLineColor(3);
2001 
2002  float ms = (m_bigain) ? 0.75 : 1.0; // marker size
2003 
2004  double maxy[6] = { 5.0, 0.5, 1.0, 0.05, 25.0, 25.0 };
2005  double miny[6] = { -5.0, -0.5, 0.0, 0.0, -25.0, -25.0 };
2006 
2007  // Mean value
2008  TH1F* final_empty[2]; //adc, type
2009  TH1F* final_odd[2]; //adc, type
2010  TH1F* final_even[2]; //adc, type
2011 
2012  // define TH1 that will contain the plots of variance/mean
2013  TH1F* pmtGain_empty[2];
2014  TH1F* pmtGain_odd[2];
2015  TH1F* pmtGain_even[2];
2016 
2017  for (int g = 0; g < 2; g++) {
2018 
2019  std::ostringstream hn;
2020  hn << "empty_" << g;
2021  final_empty[g] = new TH1F(hn.str().c_str(), m_data->m_finalHist1[ros][drawer][g][0][0]->GetTitle(), 48, 0, 48);
2022  hn.str("");
2023  hn << "odd_" << g;
2024  final_odd[g] = new TH1F(hn.str().c_str(), m_data->m_finalHist1[ros][drawer][g][0][0]->GetTitle(), 48, 0, 48);
2025  hn.str("");
2026  hn << "even_" << g;
2027  final_even[g] = new TH1F(hn.str().c_str(), m_data->m_finalHist1[ros][drawer][g][0][0]->GetTitle(), 48, 0, 48);
2028 
2029  //---- Histograms for the ratio Var/Mean
2030  // titles...
2031  std::string title;
2032  const char* gain[2] = { "low", "high" };
2033  const char* moduleNames[5] = { "AUX", "LBA", "LBC", "EBA", "EBC" };
2034  if (drawer < 10)
2035  title = Form("%s0%i %s gain, Variance/Mean", moduleNames[ros], drawer + 1, gain[g]);
2036  else
2037  title = Form("%s%i %s gain, Variance/Mean", moduleNames[ros], drawer + 1, gain[g]);
2038 
2039  std::ostringstream sStr;
2040  std::string subDir = "Summary";
2041  sStr.str("");
2042  sStr << moduleNames[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ') << gain[g] << "_pmtGain_empty";
2043  std::string histName = sStr.str();
2044  pmtGain_empty[g] = book1F(subDir, histName, title, 48, 0.0, 48.0);
2045  // pmtGain_empty[g]= new TH1F(Form("pmtGain_empty_%i", g),title.c_str(), 48,0,48);
2046 
2047  sStr.str("");
2048  sStr << moduleNames[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ') << gain[g] << "_pmtGain_odd";
2049  histName = sStr.str();
2050  pmtGain_odd[g] = book1F(subDir, histName, title, 48, 0.0, 48.0);
2051  // pmtGain_odd[g] = new TH1F(Form("pmtGain_odd_%i", g), title.c_str(), 48,0,48);
2052 
2053  sStr.str("");
2054  sStr << moduleNames[ros] << std::setfill('0') << std::setw(2) << drawer + 1 << std::setfill(' ') << gain[g] << "_pmtGain_even";
2055  histName = sStr.str();
2056  pmtGain_even[g] = book1F(subDir, histName, title, 48, 0.0, 48.0);
2057  //pmtGain_even[g] = new TH1F(Form("pmtGain_even_%i", g), title.c_str(), 48,0,48);
2058  }
2059 
2060  // loop over the 2 gains values
2061  for (int adc = 0; adc < maxgain; ++adc) {
2062 
2063  double max0 = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetMaximum();
2064  //double max1 = final_hist1[ros][drawer][adc][0][1]->GetMaximum();
2065  //double max2 = final_hist1[ros][drawer][adc][0][2]->GetMaximum();
2066  double max3 = m_data->m_finalHist1[ros][drawer][adc][0][3]->GetMaximum();
2067  double max4 = m_data->m_finalHist1[ros][drawer][adc][0][4]->GetMaximum(); //Lukas
2068  double min0 = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetMinimum();
2069  //double min1 = final_hist1[ros][drawer][adc][0][1]->GetMinimum();
2070  //double min2 = final_hist1[ros][drawer][adc][0][2]->GetMinimum();
2071  double min3 = m_data->m_finalHist1[ros][drawer][adc][0][3]->GetMinimum();
2072  double min4 = m_data->m_finalHist1[ros][drawer][adc][0][4]->GetMinimum(); //Lukas
2073 
2074  if (max0 > 0.) {
2075  final_empty[adc]->SetMaximum(1.05 * max0);
2076  } else {
2077  final_empty[adc]->SetMaximum(0.);
2078  }
2079 
2080  if ((max0 - min0) > 0) {
2081  final_empty[adc]->SetMinimum(max0 - 1.05 * (max0 - min0));
2082  }
2083 
2084  // Select pad 1 and 2
2085  TVirtualPad * pad;
2086  if (do_plots) {
2087  pad = Can->cd(adc + 1);
2088  pad->SetTopMargin(0.15);
2089  pad->SetGridx();
2090  }
2091 
2092  // bin=1 corresponds to the first pmt (#0)
2093  double Kapa = 1.30e-3;
2094  for (int ch = 0; ch < 48; ++ch) {
2095  if (isDisconnected(ros, drawer, ch)) {
2096  final_empty[adc]->SetBinContent(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinContent(ch + 1) + 0.01);
2097  final_empty[adc]->SetBinError(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinError(ch + 1) + 0.01);
2098  pmtGain_empty[adc]->SetBinContent(ch + 1, 0.01);
2099  pmtGain_empty[adc]->SetBinError(ch + 1, 0.01);
2100  }
2101  // connected channels
2102  else {
2103  double mean = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinContent(ch + 1);
2104  double rms = m_data->m_finalHist1[ros][drawer][adc][0][1]->GetBinContent(ch + 1);
2105  double dmean = m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinError(ch + 1);
2106  double drms = m_data->m_finalHist1[ros][drawer][adc][0][1]->GetBinError(ch + 1);
2107  // even pmts
2108  int pmt = abs(m_cabling->channel2hole(ros, ch)); //extra safe: abs should not be necessary, because channels are connected.
2109  if (pmt % 2 == 0) {
2110  final_even[adc]->SetBinContent(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinContent(ch + 1) + 0.001);
2111  final_even[adc]->SetBinError(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinError(ch + 1) + 0.001);
2112 
2113  // if (bin!=0)
2114  // log<<MSG::DEBUG<<"["<<ros<<"]["<<drawer+1<<"]["<<adc<<"]["<< bin <<"] : mean="
2115  // << mean <<", var="<< rms*rms<<"\tVar/mean(corrected)="<< (rms*rms/mean) - Kapa*mean <<endreq;
2116  if (mean > 10e-3) {
2117  pmtGain_even[adc]->SetBinContent(ch + 1, (rms * rms / mean) - Kapa * mean);
2118  pmtGain_even[adc]->SetBinError(ch + 1, (rms * rms / mean) * sqrt((2 * drms / rms) * (2 * drms / rms) + (dmean / mean) * (dmean / mean)));
2119  } else {
2120  pmtGain_even[adc]->SetBinContent(ch + 1, -0.5);
2121  pmtGain_even[adc]->SetBinError(ch + 1, 0.001);
2122  }
2123  }
2124  // odd pmts
2125  else {
2126  final_odd[adc]->SetBinContent(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinContent(ch + 1) + 0.001);
2127  final_odd[adc]->SetBinError(ch + 1, m_data->m_finalHist1[ros][drawer][adc][0][0]->GetBinError(ch + 1) + 0.001);
2128 
2129  // log<<MSG::DEBUG<<"["<<ros<<"]["<<drawer+1<<"]["<<adc<<"]["<< bin <<"] : mean="
2130  // << mean <<", var="<< rms*rms<<"\tVar/mean(corrected)="<< (rms*rms/mean) - Kapa*mean <<endreq;
2131  if (mean > 10e-3) {
2132  pmtGain_odd[adc]->SetBinContent(ch + 1, (rms * rms / mean) - Kapa * mean);
2133  pmtGain_odd[adc]->SetBinError(ch + 1, (rms * rms / mean) * sqrt((2 * drms / rms) * (2 * drms / rms) + (dmean / mean) * (dmean / mean)));
2134  } else {
2135  pmtGain_odd[adc]->SetBinContent(ch + 1, -0.5);
2136  pmtGain_odd[adc]->SetBinError(ch + 1, 0.001);
2137  }
2138  }
2139  }
2140  }
2141 
2142  // we are in pads 1 and 2
2143  // retrieve the max and min of the plots
2144  double max = pmtGain_odd[adc]->GetMaximum();
2145  if (pmtGain_even[adc]->GetMaximum() > max) max = 1.05 * pmtGain_even[adc]->GetMaximum();
2146  double min = pmtGain_odd[adc]->GetMinimum();
2147  if (pmtGain_even[adc]->GetMinimum() < min) min = pmtGain_even[adc]->GetMinimum() - 0.05 * fabs(pmtGain_even[adc]->GetMinimum());
2148  if (max < 0.20) max = 0.20;
2149  if (min > -0.10) min = -0.10;
2150  //log<<MSG::INFO<<"Min and Max : "<< min <<"; "<< max <<enreq;
2151  pmtGain_empty[adc]->SetMarkerStyle(21);
2152  pmtGain_even[adc]->SetMarkerStyle(22);
2153  pmtGain_odd[adc]->SetMarkerStyle(23);
2154  pmtGain_empty[adc]->SetMarkerSize(ms);
2155  pmtGain_even[adc]->SetMarkerSize(ms);
2156  pmtGain_odd[adc]->SetMarkerSize(ms);
2157  pmtGain_empty[adc]->SetLabelSize(0.08, "X");
2158  pmtGain_empty[adc]->SetLabelSize(0.08, "Y");
2159  pmtGain_even[adc]->SetMarkerColor(2);
2160  pmtGain_odd[adc]->SetMarkerColor(4);
2161  pmtGain_empty[adc]->GetYaxis()->SetRangeUser(min, max);
2162  if (do_plots) {
2163  pmtGain_empty[adc]->Draw("e");
2164  pmtGain_even[adc]->Draw("same,e");
2165  pmtGain_odd[adc]->Draw("same,e");
2166  line->DrawLine(0, -0.01, 48, -0.01);
2167  line->DrawLine(0, 0.15, 48, 0.15);
2168 
2169  // Select pads 3 and 4
2170  pad = Can->cd(maxgain + adc + 1);
2171  pad->SetTopMargin(0.15);
2172  pad->SetGridx();
2173  }
2174 
2175  // Plot the evolution of the mean vs #pmt number (with different colours for odd and even pmts)
2176  if (max0 < 0.9 * maxy[adc]) final_empty[adc]->SetMaximum(maxy[adc]);
2177  if (min0 > miny[adc] + 0.1 * TMath::Abs(miny[adc])) final_empty[adc]->SetMinimum(miny[adc]);
2178 
2179  final_empty[adc]->SetMarkerStyle(21);
2180  final_even[adc]->SetMarkerStyle(22);
2181  final_odd[adc]->SetMarkerStyle(23);
2182  final_empty[adc]->SetMarkerSize(ms);
2183  final_even[adc]->SetMarkerSize(ms);
2184  final_odd[adc]->SetMarkerSize(ms);
2185  final_empty[adc]->SetLabelSize(0.08, "X");
2186  final_empty[adc]->SetLabelSize(0.08, "Y");
2187  final_even[adc]->SetMarkerColor(2);
2188  final_odd[adc]->SetMarkerColor(4);
2189  if (do_plots) {
2190  final_empty[adc]->Draw("e");
2191  final_even[adc]->Draw("same,e");
2192  final_odd[adc]->Draw("same,e");
2193 
2194  // Select pads 5 and 6 and plot the RMS for each pmt
2195  pad = Can->cd(2 * maxgain + adc + 1);
2196  pad->SetTopMargin(0.15);
2197  pad->SetGridx();
2198  }
2199 
2200  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMarkerStyle(21);
2201  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetMarkerSize(ms);
2202  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetLabelSize(0.08, "X");
2203  m_data->m_finalHist1[ros][drawer][adc][0][1]->SetLabelSize(0.08, "Y");
2204  if (do_plots) m_data->m_finalHist1[ros][drawer][adc][0][1]->Draw("P0");
2205 
2206  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMaximum(m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMaximum());
2207  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMinimum(m_data->m_finalHist1[ros][drawer][adc][0][1]->GetMinimum());
2208  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerStyle(25);
2209  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerSize(ms);
2210  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetMarkerColor(4);
2211  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetLabelSize(0.08, "X");
2212  m_data->m_finalHist1[ros][drawer][adc][0][2]->SetLabelSize(0.08, "Y");
2213  if (do_plots) m_data->m_finalHist1[ros][drawer][adc][0][2]->Draw("sameP0");
2214 
2215  // Select pads 7 and 8
2216  if (do_plots) {
2217  pad = Can->cd(3 * maxgain + adc + 1);
2218  pad->SetTopMargin(0.15);
2219  pad->SetGridx();
2220  }
2221 
2222  if (max3 < 0.9 * maxy[4 + adc]) m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMaximum(maxy[4 + adc]);
2223  if (min3 > miny[4 + adc] + 0.1 * TMath::Abs(miny[4 + adc])) m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMinimum(miny[4 + adc]);
2224 
2225  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMarkerStyle(21);
2226  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetMarkerSize(ms);
2227  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetLabelSize(0.08, "X");
2228  m_data->m_finalHist1[ros][drawer][adc][0][3]->SetLabelSize(0.08, "Y");
2229  m_data->m_finalHist1[ros][drawer][adc][0][3]->Draw("E0");
2230 
2231  //Lukas
2232  // Select pads 9 and 10
2233  if (do_plots) {
2234  pad = Can->cd(4 * maxgain + adc + 1);
2235  pad->SetTopMargin(0.15);
2236  pad->SetGridx();
2237  }
2238 
2239  if (max4 < 0.9 * maxy[4 + adc]) m_data->m_finalHist1[ros][drawer][adc][0][4]->SetMaximum(maxy[4 + adc]);
2240  if (min4 > miny[4 + adc] + 0.1 * TMath::Abs(miny[4 + adc])) m_data->m_finalHist1[ros][drawer][adc][0][4]->SetMinimum(miny[4 + adc]);
2241 
2242  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetMarkerStyle(21);
2243  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetMarkerSize(ms);
2244  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetLabelSize(0.08, "X");
2245  m_data->m_finalHist1[ros][drawer][adc][0][4]->SetLabelSize(0.08, "Y");
2246  if (do_plots) m_data->m_finalHist1[ros][drawer][adc][0][4]->Draw("E0");
2247  //Lukas
2248 
2249  } //end of loop over gain
2250 
2251  if (m_savePng) {
2252  Can->Print(TString(moduleName + "_fit_amp.png"), "png");
2253  }
2254  if (m_savePs) {
2255  Can->Print(TString(moduleName + "_fit_amp.ps"), "ps");
2256  }
2257  if (m_saveSvg) {
2258  Can->Print(TString(moduleName + "_fit_amp.svg"), "svg");
2259  }
2260  //Can->Print(TString(moduleName+"_fit_amp.cxx"),"cxx");
2261  if (do_plots) delete Can;
2262  delete line;
2263  for (int g = 0; g < 2; g++) {
2264  delete final_empty[g];
2265  delete final_odd[g];
2266  delete final_even[g];
2267  //delete pmtGain_empty[g];
2268  //delete pmtGain_odd[g];
2269  //delete pmtGain_even[g];
2270  }
2271 }
grepfile.info
info
Definition: grepfile.py:38
TileRawChannelMonTool::m_contNameDSP
std::string m_contNameDSP
Definition: TileRawChannelMonTool.h:74
LArG4FSStartPointFilter.part
part
Definition: LArG4FSStartPointFilter.py:21
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
TileRawChannelMonTool::~TileRawChannelMonTool
virtual ~TileRawChannelMonTool()
Definition: TileRawChannelMonTool.cxx:88
TileRawChannelContainer
Definition: TileRawChannelContainer.h:13
TileRawChannelMonTool::m_med_IntegralLimit
double m_med_IntegralLimit
Definition: TileRawChannelMonTool.h:79
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
TilePaterMonTool::removeTObj
StatusCode removeTObj(TObject *obj)
Definition: TilePaterMonTool.cxx:429
plotBeamSpotCompare.x1
x1
Definition: plotBeamSpotCompare.py:216
TileRawChannelUnit
Definition: TileRawChannelUnit.h:13
TileRawChannelMonTool::m_tfitMap
std::map< int, std::vector< double > > m_tfitMap
Definition: TileRawChannelMonTool.h:86
TileRawChannelMonTool::checkDmuHeaderFormat
bool checkDmuHeaderFormat(uint32_t header)
Function to check that the DMU header format is correct bit_31 of the DMU header must be 1 and bit_17...
Definition: TileRawChannelMonTool.h:103
TileRawChannelMonTool::chi2dsp
@ chi2dsp
Definition: TileRawChannelMonTool.h:134
TileRawChannelMonTool::m_drawHists
bool m_drawHists
Definition: TileRawChannelMonTool.h:171
TileRawChannelMonTool::m_lo_IntegralLimit
double m_lo_IntegralLimit
Definition: TileRawChannelMonTool.h:78
TileRawChannelMonTool::checkDmuHeader
bool checkDmuHeader(std::vector< uint32_t > *headerVec, int dmu)
The following three functions are implemented to filter data corruption, copied from TileDigitsMonToo...
Definition: TileRawChannelMonTool.cxx:1950
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
ManagedMonitorToolBase::m_path
std::string m_path
Definition: ManagedMonitorToolBase.h:852
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
checkFileSG.line
line
Definition: checkFileSG.py:75
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
algorithm
std::string algorithm
Definition: hcg.cxx:82
mean
void mean(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
Definition: dependence.cxx:254
TileDCSDataPlotter.max1
max1
Definition: TileDCSDataPlotter.py:884
max
#define max(a, b)
Definition: cfImp.cxx:41
TileRawChannelMonTool::NsumDsp
@ NsumDsp
Definition: TileRawChannelMonTool.h:138
AddEmptyComponent.histName
string histName
Definition: AddEmptyComponent.py:64
TilePaterMonTool::initialize
virtual StatusCode initialize() override
Definition: TilePaterMonTool.cxx:101
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
TileRawChannelMonTool::m_bigain
bool m_bigain
Definition: TileRawChannelMonTool.h:143
TileRawChannelMonTool::m_data
std::unique_ptr< Data > m_data
Definition: TileRawChannelMonTool.h:164
integral
double integral(TH1 *h)
Definition: computils.cxx:57
TilePaterMonTool::bookGraphAsymmErrors
TGraphAsymmErrors * bookGraphAsymmErrors(const std::string &dir, const std::string &nam, const std::string &tit, int N, float *X, float *Y, float *X_errors1, float *X_errors2, float *Y_errors1, float *Y_errors2)
Definition: TilePaterMonTool.cxx:476
TileRawChannelMonTool::bookHists
virtual StatusCode bookHists() override
Calls bookHists( true, true, true ) and initializes lumiBlock and run numbers.
Definition: TileRawChannelMonTool.cxx:124
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileRawChannelMonTool::m_runType
int m_runType
Definition: TileRawChannelMonTool.h:72
TilePaterMonTool::m_fragIDsDemonstrators
std::vector< int > m_fragIDsDemonstrators
Definition: TilePaterMonTool.h:211
index
Definition: index.py:1
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TilePaterMonTool::m_savePng
bool m_savePng
Definition: TilePaterMonTool.h:206
TileRawChannelMonTool::sumEdsp
@ sumEdsp
Definition: TileRawChannelMonTool.h:138
ReadBchFromCool.pmt
pmt
Definition: ReadBchFromCool.py:62
plotmaker.hist
hist
Definition: plotmaker.py:148
run_gep.alg_name
alg_name
Definition: run_gep.py:298
TilePaterMonTool::m_savePs
bool m_savePs
Definition: TilePaterMonTool.h:207
TileRawChannelMonTool::fillSummaryHistograms
StatusCode fillSummaryHistograms()
Definition: TileRawChannelMonTool.cxx:1046
TileRawChannelUnit::CesiumPicoCoulombs
@ CesiumPicoCoulombs
Definition: TileRawChannelUnit.h:19
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
skel.it
it
Definition: skel.GENtoEVGEN.py:396
TileRawChannelMonTool::CisRun
@ CisRun
Definition: TileRawChannelMonTool.h:128
bin
Definition: BinsDiffFromStripMedian.h:43
TileRawChannelMonTool::m_bookAll
bool m_bookAll
Definition: TileRawChannelMonTool.h:69
AthCommonMsg< AlgTool >::msgLvl
bool msgLvl(const MSG::Level lvl) const
Definition: AthCommonMsg.h:30
TileInfo.h
TileRawChannelMonTool::drawDsp
void drawDsp(int ros, int drawer, const std::string &moduleName)
Definition: TileRawChannelMonTool.cxx:1717
TileCalibUtils.h
TileRawChannelMonTool::ratioErrorBar
void ratioErrorBar(TH1S *hist, double &xmin, double &xmax, double mean)
Definition: TileRawChannelMonTool.cxx:1857
TilePaterMonTool
Base class for tilecal calibration monitoring tools.
Definition: TilePaterMonTool.h:50
TileDigitsContainer
Definition: TileDigitsContainer.h:13
TileRawChannelMonTool::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition: TileRawChannelMonTool.h:87
TileRawChannelMonTool::m_calibUnit
TileRawChannelUnit::UNIT m_calibUnit
Definition: TileRawChannelMonTool.h:166
TileRawChannelUnit::PicoCoulombs
@ PicoCoulombs
Definition: TileRawChannelUnit.h:18
TileRawData::adc_HWID
HWIdentifier adc_HWID(void) const
Definition: TileRawData.h:53
HWIdentifier
Definition: HWIdentifier.h:13
python.SystemOfUnits.ms
int ms
Definition: SystemOfUnits.py:132
SCT_CalibAlgs::nbins
@ nbins
Definition: SCT_CalibNumbers.h:10
TileRawChannel::time
float time(int ind=0) const
Definition: TileRawChannel.h:103
TileRawChannelMonTool::fillHists
virtual StatusCode fillHists() override
Calls fillHists( bool, bool, bool ); if an eventBlock,lumiBlock, or run has turned over,...
Definition: TileRawChannelMonTool.cxx:517
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
TileRawChannelMonTool::m_cispar
const uint32_t * m_cispar
Definition: TileRawChannelMonTool.h:141
TileRawChannelMonTool::initialize
virtual StatusCode initialize() override
Definition: TileRawChannelMonTool.cxx:94
TileHWID::channel
int channel(const HWIdentifier &id) const
extract channel field from HW identifier
Definition: TileHWID.h:189
TileRawChannelMonTool::m_doLaserSummaryVsPMT
bool m_doLaserSummaryVsPMT
Definition: TileRawChannelMonTool.h:170
AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TileRawChannelMonTool::bookSummaryHistograms
void bookSummaryHistograms(int ros, int drawer)
Definition: TileRawChannelMonTool.cxx:908
TileHWID::ros
int ros(const HWIdentifier &id) const
extract ros field from HW identifier
Definition: TileHWID.h:167
AthExHiveOpts.Time
Time
Definition: AthExHiveOpts.py:63
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
TileRawChannelContainer.h
TileRawChannel::quality
float quality(int ind=0) const
Definition: TileRawChannel.h:105
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
TileRawChannelMonTool::m_storeGraph
bool m_storeGraph
Definition: TileRawChannelMonTool.h:84
TileRawChannelMonTool::m_minAmpForCorrectedTime
float m_minAmpForCorrectedTime
Definition: TileRawChannelMonTool.h:172
WriteCellNoiseToCool.gn
gn
Definition: WriteCellNoiseToCool.py:531
AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
TileRawChannelMonTool::m_plotDsp
bool m_plotDsp
Definition: TileRawChannelMonTool.h:83
TilePaterMonTool::m_saveSvg
bool m_saveSvg
Definition: TilePaterMonTool.h:208
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TilePaterMonTool::book1Sx
TH1S * book1Sx(const std::string &dir, const std::string &nam, const std::string &tit, int nx, const Double_t *xlgbins, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
Definition: TilePaterMonTool.cxx:203
TileRawChannelMonTool::checkDmuHeaderParity
bool checkDmuHeaderParity(uint32_t header)
Function to check that the DMU header parity is correct Parity of the DMU header should be odd Return...
Definition: TileRawChannelMonTool.h:113
TileHWID::adc
int adc(const HWIdentifier &id) const
extract adc field from HW identifier
Definition: TileHWID.h:193
TileRawChannelMonTool::GetTimeFitFunc
TF1 * GetTimeFitFunc(TH2S *hist2d)
Time Slope parameters for CIS runs.
Definition: TileRawChannelMonTool.cxx:1917
TilePaterMonTool::book1F
TH1F * book1F(const std::string &dir, const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
Definition: TilePaterMonTool.cxx:170
TileRawChannelMonTool::m_useratioerror
bool m_useratioerror
Definition: TileRawChannelMonTool.h:81
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition: TileRawChannel.h:101
TileRawChannelMonTool::m_intCalibUnit
int m_intCalibUnit
Definition: TileRawChannelMonTool.h:178
TileRawChannelMonTool::PhysRun
@ PhysRun
Definition: TileRawChannelMonTool.h:124
dqt_zlumi_pandas.err
err
Definition: dqt_zlumi_pandas.py:182
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
lumiFormat.i
int i
Definition: lumiFormat.py:85
xmin
double xmin
Definition: listroot.cxx:60
python.TrigEgammaMonitorHelper.TProfile
def TProfile(*args, **kwargs)
Definition: TrigEgammaMonitorHelper.py:81
TileCondToolEmscale.h
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
TileDigitsContainer.h
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
TileRawChannelMonTool::m_contName
std::string m_contName
Definition: TileRawChannelMonTool.h:73
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
TileRawDataContainer::get_bsflags
uint32_t get_bsflags() const
Definition: TileRawDataContainer.h:64
TilePaterMonTool::book2S
TH2S * book2S(const std::string &dir, const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
Definition: TilePaterMonTool.cxx:274
TileRawChannelUnit::Invalid
@ Invalid
Definition: TileRawChannelUnit.h:26
TileRawChannelMonTool::m_dac2Charge
double m_dac2Charge[3]
Definition: TileRawChannelMonTool.h:179
covarianceTool.title
title
Definition: covarianceTool.py:542
TileRawChannelMonTool::m_tileInfo
const TileInfo * m_tileInfo
Definition: TileRawChannelMonTool.h:175
TileRawChannelMonTool::resetSummaryHistograms
void resetSummaryHistograms()
Definition: TileRawChannelMonTool.cxx:1020
chi2
double chi2(TH1 *h0, TH1 *h1)
Definition: comparitor.cxx:522
TileRawChannel
Definition: TileRawChannel.h:35
test_pyathena.parent
parent
Definition: test_pyathena.py:15
TileRawChannelMonTool::m_UpLimit
double m_UpLimit
Definition: TileRawChannelMonTool.h:77
IdentifiableContainerMT::end
const_iterator end() const
return const_iterator for end of container
Definition: IdentifiableContainerMT.h:242
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
TileRawChannelMonTool::finalDsp
StatusCode finalDsp(int ros, int drawer)
Definition: TileRawChannelMonTool.cxx:1320
IdentifiableContainerMT::begin
const_iterator begin() const
return const_iterator for first entry
Definition: IdentifiableContainerMT.h:236
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
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
TileRawChannelMonTool::m_DQstatusKey
SG::ReadHandleKey< TileDQstatus > m_DQstatusKey
Definition: TileRawChannelMonTool.h:177
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
TileRawChannelMonTool::m_is12bit
bool m_is12bit
Definition: TileRawChannelMonTool.h:176
TileRawChannelMonTool::drawHists
void drawHists(int ros, int drawer, const std::string &moduleName)
Definition: TileRawChannelMonTool.cxx:1437
TileRawChannelMonTool::Edsp
@ Edsp
Definition: TileRawChannelMonTool.h:134
min
#define min(a, b)
Definition: cfImp.cxx:40
TileRawChannelMonTool::Tdsp
@ Tdsp
Definition: TileRawChannelMonTool.h:134
TilePaterMonTool::book2F
TH2F * book2F(const std::string &dir, const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, int ny, double ymin, double ymax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
Definition: TilePaterMonTool.cxx:239
TileRawChannelMonTool::LaserFancyPlotting
void LaserFancyPlotting(int ros, int drawer, int maxgain, const std::string &moduleName)
Definition: TileRawChannelMonTool.cxx:1982
TileRawChannelMonTool::bookDsp
void bookDsp(int ros, int drawer)
Definition: TileRawChannelMonTool.cxx:365
TileRawChannelMonTool::Edsp_fit
@ Edsp_fit
Definition: TileRawChannelMonTool.h:134
DiTauMassTools::HistInfo::RMS
@ RMS
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:35
TileRawChannelMonTool::m_summaryUpdateFrequency
int m_summaryUpdateFrequency
Definition: TileRawChannelMonTool.h:168
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
TileRawChannelMonTool::sumTdsp_fit
@ sumTdsp_fit
Definition: TileRawChannelMonTool.h:138
charge
double charge(const T &p)
Definition: AtlasPID.h:538
TileRawChannelMonTool::m_book2D
bool m_book2D
Definition: TileRawChannelMonTool.h:70
TileRawChannelMonTool::Tdsp_fit
@ Tdsp_fit
Definition: TileRawChannelMonTool.h:134
TilePaterMonTool::m_fragIDsToIgnoreDMUerrors
std::vector< int > m_fragIDsToIgnoreDMUerrors
Definition: TilePaterMonTool.h:210
TileRawChannelMonTool::checkHists
virtual StatusCode checkHists(bool fromFinalize) override
This implementation does nothing; equivalent functionality may be provided by procHists(....
Definition: TileRawChannelMonTool.cxx:1427
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition: TileDQstatus.h:152
TileRawChannelMonTool::m_efitThresh
double m_efitThresh
Definition: TileRawChannelMonTool.h:88
TilePaterMonTool::isDisconnected
bool isDisconnected(int ros, int drawer, int ch)
Definition: TilePaterMonTool.h:259
TileRawChannelMonTool::fillDsp
StatusCode fillDsp(std::map< int, std::vector< double > > &efitMap, std::map< int, std::vector< double > > &tfitMap)
Definition: TileRawChannelMonTool.cxx:804
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition: TileCalibUtils.cxx:145
TileRawChannelMonTool::m_DownLimit
double m_DownLimit
Definition: TileRawChannelMonTool.h:76
TileRawChannelMonTool::LasRun
@ LasRun
Definition: TileRawChannelMonTool.h:125
TileRawChannelMonTool::m_overlaphists
bool m_overlaphists
Definition: TileRawChannelMonTool.h:71
DeMoScan.index
string index
Definition: DeMoScan.py:364
TilePaterMonTool::m_cabling
const TileCablingService * m_cabling
Definition: TilePaterMonTool.h:204
TileRawData::cell_ID_index
Identifier cell_ID_index(int &index, int &pmt) const
Definition: TileRawData.cxx:65
h
TileHWID::drawer
int drawer(const HWIdentifier &id) const
extract drawer field from HW identifier
Definition: TileHWID.h:171
python.compareTCTs.ratio
ratio
Definition: compareTCTs.py:295
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ReadFloatFromCool.adc
adc
Definition: ReadFloatFromCool.py:48
TileRawDataContainer::get_unit
UNIT get_unit() const
Definition: TileRawDataContainer.h:60
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
TileCablingService::channel2hole
static int channel2hole(int ros, int channel)
Definition: TileCablingService.cxx:1946
TileRawChannelMonTool::finalHists
virtual StatusCode finalHists() override
Calls procHists( true, true, true ).
Definition: TileRawChannelMonTool.cxx:1297
DEBUG
#define DEBUG
Definition: page_access.h:11
AthCommonMsg< AlgTool >::msg
MsgStream & msg() const
Definition: AthCommonMsg.h:24
TileRawChannelMonTool::PedRun
@ PedRun
Definition: TileRawChannelMonTool.h:127
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
xmax
double xmax
Definition: listroot.cxx:61
beamspotnt.rms
rms
Definition: bin/beamspotnt.py:1266
TileRawChannelMonTool::m_nEventsTileMon
int m_nEventsTileMon
Definition: TileRawChannelMonTool.h:144
TileRawChannelMonTool::sumEdsp_fit
@ sumEdsp_fit
Definition: TileRawChannelMonTool.h:138
TileRawChannelMonTool::m_infoName
std::string m_infoName
Definition: TileRawChannelMonTool.h:174
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
TileRawChannelMonTool::m_corrup
bool m_corrup[5][64][2][16]
Definition: TileRawChannelMonTool.h:97
ReadHandle.h
Handle class for reading from StoreGate.
TilePaterMonTool::m_tileHWID
const TileHWID * m_tileHWID
Definition: TilePaterMonTool.h:202
TileRawChannelMonTool::rangeErrorBar
void rangeErrorBar(double &xmin, double &max, double mean)
Definition: TileRawChannelMonTool.cxx:1841
TileRawChannelMonTool::TileRawChannelMonTool
TileRawChannelMonTool(const std::string &type, const std::string &name, const IInterface *parent)
Definition: TileRawChannelMonTool.cxx:44
TileRawChannelMonTool::m_efitMap
std::map< int, std::vector< double > > m_efitMap
Definition: TileRawChannelMonTool.h:85
TileInfo::ADCmax
int ADCmax() const
Returns the maximum ADC output (10 bits --> 1023)
Definition: TileInfo.h:71
TilePaterMonTool::book1S
TH1S * book1S(const std::string &dir, const std::string &nam, const std::string &tit, int nx, double xmin, double xmax, Interval_t interval=run, MgmtAttr_t attribute=ATTRIB_MANAGED, const std::string &trigChain="", const std::string &mergeAlgo="")
Definition: TilePaterMonTool.cxx:192
TileRawChannelMonTool::CisRamp
@ CisRamp
Definition: TileRawChannelMonTool.h:130
TileRawChannelMonTool::m_hi_IntegralLimit
double m_hi_IntegralLimit
Definition: TileRawChannelMonTool.h:80
TileRawChannelMonTool.h
fitman.k
k
Definition: fitman.py:528
TileRawChannelMonTool::m_resetAfterSummaryUpdate
bool m_resetAfterSummaryUpdate
Definition: TileRawChannelMonTool.h:169
TileRawChannelMonTool::LedRun
@ LedRun
Definition: TileRawChannelMonTool.h:126
Generated on Thu Nov 7 2024 21:28:24 for ATLAS Offline Software by   doxygen 1.8.18