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