ATLAS Offline Software
Loading...
Searching...
No Matches
TileRawChNoiseCalibAlg.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: TileRawChNoiseCalib.cxx
8// PACKAGE: TileCalib
9//
10// AUTHOR: Luca Fiorini (Luca.Fiorini@cern.ch)
11//
12// April 2008
13// ********************************************************************
14
15
16
17#include "GaudiKernel/ISvcLocator.h"
18
19//Event info
20#include "xAODEventInfo/EventInfo.h"
21#include "AthenaKernel/errorcheck.h"
22#include "StoreGate/ReadHandle.h"
23
24// Tile includes
25#include "TileRawChNoiseCalibAlg.h"
26#include "TileEvent/TileRawChannelContainer.h"
27#include "CaloIdentifier/TileID.h"
28#include "TileIdentifier/TileHWID.h"
29#include "TileEvent/TileDigitsContainer.h"
30#include "TileEvent/TileBeamElemContainer.h"
31#include "TileByteStream/TileBeamElemContByteStreamCnv.h"
32#include "TileCalibBlobObjs/TileCalibUtils.h"
33#include "CxxUtils/FPControl.h"
34
35
36#include "TFile.h"
37#include "TTree.h"
38#include "TH1F.h"
39#include "TF1.h"
40#include "TFitResult.h"
41#include "TFitResultPtr.h"
42#include "TMatrixDSym.h"
43#include "TGraphErrors.h"
44#include "TClonesArray.h"
45
46#include <cmath>
47#include <ctime>
48#include <iostream>
49
50
51TileRawChNoiseCalibAlg::TileRawChNoiseCalibAlg(const std::string& name, ISvcLocator* pSvcLocator)
52 : AthAlgorithm(name,pSvcLocator)
53 , m_beamCnv(nullptr)
54 , m_cabling(nullptr)
55 , m_tileID(nullptr)
56 , m_tileHWID(nullptr)
57 , m_cispar(nullptr)
58 //, m_nDrawers(0)
59 , m_time(0)
60 , m_year(0)
61 , m_month(0)
62 , m_day(0)
63 , m_yday(0)
64 , m_hour(0)
65 , m_min(0)
66 , m_run(0)
67 , m_trigType(0)
68{
69
70 declareProperty("TileDigitsContainer", m_digitsContainer = "TileDigitsCnt");
71 declareProperty("TileBeamElemContainer", m_beamElemContainer = "TileBeamElemCnt");
72 declareProperty("doFit" , m_doFit = true);
73 declareProperty("doFixed", m_doFixed = true);
74 declareProperty("doOpt" , m_doOpt = true);
75 declareProperty("doDsp" , m_doDsp = true);
76 declareProperty("doOF1" , m_doOF1 = true);
77 declareProperty("doMF" , m_doMF = true);
78 declareProperty("SaveHist", m_saveHist = false); // write all histograms to output file
79 declareProperty("InvertChanRatio", m_invertChanRatio = true); // swap two sigmas and invert ratio if it is above 1.0 (channel fit only)
80 declareProperty("MaskBadChannels",m_maskBadChannels = true);
81 declareProperty("UseforCells" , m_UseforCells = 2); // Fit=0, Fixed=1, Opt=2, Dsp=3, OF1=4, MF=5
82 declareProperty("CalibMode", m_calibMode = true);
83 declareProperty("UsePMT", m_usePMT = false);
84 declareProperty("RunNumber", m_run=0);
85 declareProperty("FileNamePrefix", m_file="RawCh_NoiseCalib");
86 declareProperty("NtupleID", m_ntupleID="RawCh_NoiseCalib");
87 declareProperty("TreeSize", m_treeSize = 16000000000LL);
88 declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
89
90 m_evtNr=-1;
91
92 m_fillidx=false;
93
94 m_histAmp = new TH1F*[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
95 m_histCellAmp = new TH1F*[2][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
96 m_evt = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
97 m_ros = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
98 m_drawer = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
99 m_channel = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
100 m_gain = new bool[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
101 m_rc_mean = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
102 m_rc_sigma = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
103 m_rc_av = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
104 m_rc_rms = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
105 m_rc_skewness = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
106 m_rc_kurtosis = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
107 m_rc_mean_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
108 m_rc_sigma_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
109 m_rc_chi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
110 m_rc_ndf = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
111 m_rc_probC2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
112 m_rc_ggpar = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]();
113 m_rc_gsigma1 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
114 m_rc_gsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
115 m_rc_gnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
116 m_rc_gchi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
117 m_rc_gerrsigma1= new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
118 m_rc_gerrsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
119 m_rc_gerrnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
120 m_rc_gcorrsigma1sigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
121
122 m_side = new bool[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
123 m_phi = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
124 m_sample = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
125 m_tower = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
126 m_gg = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
127 m_ecell_av = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
128 m_ecell_rms= new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
129 m_ecell_hash= new uint32_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS]();
130
131 m_cell_nch = new int[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
132 m_ecell_ene = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
133 m_ggpar = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]();
134 m_gsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
135 m_gsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
136 m_gnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
137 m_gchi2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
138 m_gerrsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
139 m_gerrsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
140 m_gerrnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
141 m_gcorrsigma1sigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
142}
143
144TileRawChNoiseCalibAlg::~TileRawChNoiseCalibAlg()
145{
146 delete[] m_histAmp;
147 delete[] m_histCellAmp;
148 delete[] m_evt;
149 delete[] m_ros;
150 delete[] m_drawer;
151 delete[] m_channel;
152 delete[] m_gain;
153 delete[] m_rc_mean;
154 delete[] m_rc_sigma;
155 delete[] m_rc_av;
156 delete[] m_rc_rms;
157 delete[] m_rc_skewness;
158 delete[] m_rc_kurtosis;
159 delete[] m_rc_mean_err;
160 delete[] m_rc_sigma_err;
161 delete[] m_rc_chi2;
162 delete[] m_rc_ndf;
163 delete[] m_rc_probC2;
164 delete[] m_rc_ggpar;
165 delete[] m_rc_gsigma1;
166 delete[] m_rc_gsigma2;
167 delete[] m_rc_gnorm;
168 delete[] m_rc_gchi2;
169 delete[] m_rc_gerrsigma1;
170 delete[] m_rc_gerrsigma2;
171 delete[] m_rc_gerrnorm;
172 delete[] m_rc_gcorrsigma1sigma2;
173
174 delete[] m_side;
175 delete[] m_phi;
176 delete[] m_sample;
177 delete[] m_tower;
178 delete[] m_gg;
179 delete[] m_ecell_av;
180 delete[] m_ecell_rms;
181 delete[] m_ecell_hash;
182
183 delete[] m_cell_nch;
184 delete[] m_ecell_ene;
185 delete[] m_ggpar;
186 delete[] m_gsigma1;
187 delete[] m_gsigma2;
188 delete[] m_gnorm;
189 delete[] m_gchi2;
190 delete[] m_gerrsigma1;
191 delete[] m_gerrsigma2;
192 delete[] m_gerrnorm;
193 delete[] m_gcorrsigma1sigma2;
194}
195
198StatusCode TileRawChNoiseCalibAlg::initialize() {
199
200 int nbin = 151;
201 float binwidth[2] = { 0.125, 0.25 }; // in ADC
202 float xmax[2] = { (float) nbin * binwidth[0] / 2.F, (float) nbin * binwidth[1] / 2.F }; // in ADC
203
204 std::ostringstream sStr;
205 std::string nam;
206
207 for (int rc = 0; rc < RCnum; ++rc) {
208 for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
209 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
210 for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
211 for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
212 sStr.str("");
213 sStr << "Amplitudes_RC_" << rc << "_Part_" << ros << "_Drawer_" << drawer << "_Ch_" << ch << "_Gain_" << g;
214 nam = sStr.str();
215 m_histAmp[rc][ros][drawer][ch][g] = new TH1F(nam.c_str(), nam.c_str(), nbin, -xmax[g], xmax[g]);
216 m_histAmp[rc][ros][drawer][ch][g]->SetCanExtend(TH1::kAllAxes); //in case some entries are outside the initial limits
217 m_histAmp[rc][ros][drawer][ch][g]->SetDirectory(nullptr);
218 }
219 }
220 }
221 }
222 }
223
224 nbin = 301;
225 float cellbin[2] = { 80., 2.5 }; //in MeV
226 float xcellmax[2] = { (float) nbin * cellbin[0] / 2.F, (float) nbin * cellbin[1] / 2.F }; //in MeV
227
228 for (int side = 0; side < NSIDES; side++) {
229 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
230 for (int sample = 0; sample < NSAMPLES; sample++) {
231 for (int tower = 0; tower < NTOWERS; tower++) {
232 for (int gg = 0; gg < NCELLGAINS; gg++) {
233 sStr.str("");
234 sStr << "CellAmplitude_Side_" << side << "_Drawer_" << drawer << "_Sample_" << sample << "_Tower_" << tower << "_Gains_" << gg;
235 nam = sStr.str();
236 m_histCellAmp[side][drawer][sample][tower][gg] = new TH1F(nam.c_str(), nam.c_str(), nbin, -xcellmax[gg / 3], xcellmax[gg / 3]); // cell limits should be at least sqrt(2)*channel limits
237 m_histCellAmp[side][drawer][sample][tower][gg]->SetCanExtend(TH1::kAllAxes); //in case some entries are outside the initial limits
238 m_histCellAmp[side][drawer][sample][tower][gg]->SetDirectory(nullptr);
239 }
240 }
241 }
242 }
243 }
244
245
246 //=== get TileCondToolEmscale
247 CHECK( m_tileToolEmscale.retrieve() );
248
249 //=== get TileBadChanTool
250 CHECK( m_tileBadChanTool.retrieve() );
251
252 //=== get TileCondIdTransforms
253 CHECK( m_tileIdTrans.retrieve() );
254
255 CHECK( m_dqStatusKey.initialize() );
256
257 ATH_CHECK( m_rawChannelContainerFitKey.initialize(m_doFit) );
258 ATH_CHECK( m_rawChannelContainerFixedKey.initialize(m_doFixed) );
259 ATH_CHECK( m_rawChannelContainerOptKey.initialize(m_doOpt) );
260 ATH_CHECK( m_rawChannelContainerDspKey.initialize(m_doDsp) );
261 ATH_CHECK( m_rawChannelContainerOF1Key.initialize(m_doOF1) );
262 ATH_CHECK( m_rawChannelContainerMFKey.initialize(m_doMF) );
263
264 if (!m_eventInfoKey.key().empty()) {
265 ATH_CHECK( m_eventInfoKey.initialize() );
266 }
267
268 return StatusCode::SUCCESS;
269}
270
273StatusCode TileRawChNoiseCalibAlg::FirstEvt_initialize() {
274
275
276 // find TileCablingService
277 m_cabling = TileCablingService::getInstance();
278
279 // retrieve TileID helper from det store
280 CHECK( detStore()->retrieve(m_tileID) );
281
282 CHECK( detStore()->retrieve(m_tileHWID) );
283
284 ATH_MSG_INFO( "calibMode " << m_calibMode );
285
286
287 // set event number to 0 before first event
288
289 if ( m_evtNr < 0 ) {
290 m_evtNr = 0;
291 if (m_beamElemContainer.length() > 0) {
292 ServiceHandle<IConversionSvc> cnvSvc("ByteStreamCnvSvc","");
293 if (cnvSvc.retrieve().isFailure()) {
294 ATH_MSG_ERROR( " Can't get ByteStreamCnvSvc " );
295 m_beamCnv = nullptr;
296
297 } else {
298
299 m_beamCnv = dynamic_cast<TileBeamElemContByteStreamCnv *> ( cnvSvc->converter( ClassID_traits<TileBeamElemContainer>::ID() ) );
300
301 if ( m_beamCnv == nullptr ) {
302 ATH_MSG_ERROR( " Can't get TileBeamElemContByteStreamCnv " );
303 }
304 }
305 } else {
306 m_beamCnv = nullptr;
307 }
308 }
309
310 ATH_MSG_INFO( "initialization completed" );
311
312 return StatusCode::SUCCESS;
313
314}
315
317StatusCode TileRawChNoiseCalibAlg::execute(const EventContext& ctx) {
318
319 const TileDQstatus* dqStatus = SG::makeHandle (m_dqStatusKey, ctx).get();
320
321 bool empty(false); // to add all StatusCodes
322
323 if (m_evtNr < 0) {
324
325 if (FirstEvt_initialize().isFailure()) { ATH_MSG_ERROR( "FirstEvt_initialize failed" ); }
326
327 bool calibMode = (dqStatus->calibMode() == 1);
328 if ( calibMode != m_calibMode ) {
329 ATH_MSG_INFO( "Overwriting calib mode [" << m_calibMode << "] by one from data: " << calibMode );
330 m_calibMode = calibMode;
331 }
332
333 m_cispar = dqStatus->cispar();
334 StoreRunInfo(dqStatus); // done only once
335 }
336
337 memset(m_ecell_ene ,0, 2 * sizeof( *m_ecell_ene ));
338 memset(m_cell_nch ,0, 2 * sizeof( *m_cell_nch ));
339
340 m_cispar = dqStatus->cispar();
341 if (m_evtNr % 1000 == 0) ATH_MSG_INFO( " events processed so far " << m_evtNr );
342
343
344 if (m_doFit) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerFitKey, Fit).isFailure());}
345 if (m_doFixed) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerFixedKey, Fixed).isFailure());}
346 if (m_doOpt) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerOptKey, Opt).isFailure());}
347 if (m_doDsp) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerDspKey, Dsp).isFailure());}
348 if (m_doOF1) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerOF1Key, OF1).isFailure());}
349 if (m_doMF) {empty &= (fillRawChannels(dqStatus, m_rawChannelContainerMFKey, MF).isFailure());}
350
351
352 if (empty) {ATH_MSG_ERROR( "Error in execute " ); }
353 ++m_evtNr;
354
355 return StatusCode::SUCCESS;
356}
357
358
360StatusCode TileRawChNoiseCalibAlg::finalize() {
361
362 ATH_MSG_INFO( "Finalizing TileRawChNoiseCalibAlg" );
363
364 if (m_doFit) finalRawCh(Fit);
365 if (m_doFixed) finalRawCh(Fixed);
366 if (m_doOpt) finalRawCh(Opt);
367 if (m_doDsp) finalRawCh(Dsp);
368 if (m_doOF1) finalRawCh(OF1);
369 if (m_doMF) finalRawCh(MF);
370
371 if (m_UseforCells == 0) {
372 if (m_doFit) finalCell();
373 } else if (m_UseforCells == 1) {
374 if (m_doFixed) finalCell();
375 } else if (m_UseforCells == 2) {
376 if (m_doOpt) finalCell();
377 } else if (m_UseforCells == 3) {
378 if (m_doDsp) finalCell();
379 } else if (m_UseforCells == 4) {
380 if (m_doOF1) finalCell();
381 } else if (m_UseforCells == 5) {
382 if (m_doMF) finalCell();
383 } else {
384 ATH_MSG_WARNING( "unknown rawchannel type used for cells" << m_UseforCells );
385 }
386
387 std::ostringstream sStr;
388 std::string trig_str;
389
390 if (m_trigType == Phys) trig_str = "Phys";
391 else if (m_trigType == Las) trig_str = "Las";
392 else if (m_trigType == Ped) trig_str = "Ped";
393 else if (m_trigType == Cis) trig_str = "Cis";
394 else {
395 ATH_MSG_WARNING( "Unknown trigger type " << m_trigType );
396 trig_str = "Unk";
397 }
398
399 sStr << m_file << "_" << m_run << "_" << trig_str << ".root";
400 m_file = sStr.str();
401 ATH_MSG_INFO( "Writing calibrations to file " << m_file );
402
403 // Create output file: for now creating file for just this
404 // algorithm; want to add to ntuple file eventually??
405 TFile* fout = new TFile(m_file.c_str(), "recreate");
406
407 // Create tree with branches
408 TTree* t = new TTree(m_ntupleID.c_str(), "Tile_RC_NoiseCalib-Ntuple");
409
410 t->Branch("RunNumber", &m_run, "RunNumber/I");
411 t->Branch("TrigType", &m_trigType, "TrigType/I");
412 t->Branch("Time", &m_time, "Time/I");
413 t->Branch("Year", &m_year, "Year/I");
414 t->Branch("Month", &m_month, "Month/I");
415 t->Branch("Day", &m_day, "Day/I");
416 t->Branch("YDay", &m_yday, "YDay/I");
417 t->Branch("Hour", &m_hour, "Hour/I");
418 t->Branch("Min", &m_min, "Min/I");
419 t->Branch("nEvt", &m_evtNr, "nEvt/I"); // events processed
420 t->Branch("EvtNr", &m_evtNr, "EvtNr/I");
421 t->Branch("EvtGood", *m_evt, "Evt[5][64][48][2]/I"); // events used in the noise calculation for every channel
422
423
424 t->Branch("ros", *m_ros, "ros[5][64][48][2]/b");
425 t->Branch("drawer", *m_drawer, "drawer[5][64][48][2]/b");
426 t->Branch("channel", *m_channel, "channel[5][64][48][2]/b");
427 t->Branch("gain", *m_gain, "gain[5][64][48][2]/O");
428
429 t->Branch("efit_mean",*(m_rc_mean[Fit]),"efit_mean[5][64][48][2]/F");
430 t->Branch("efit_av",*(m_rc_av[Fit]),"efit_av[5][64][48][2]/F");
431 t->Branch("efit_rms",*(m_rc_rms[Fit]),"efit_rms[5][64][48][2]/F");
432 t->Branch("efit_sigma",*(m_rc_sigma[Fit]),"efit_sigma[5][64][48][2]/F");
433 t->Branch("efit_mean_err",*(m_rc_mean_err[Fit]),"efit_mean_err[5][64][48][2]/F");
434 t->Branch("efit_sigma_err",*(m_rc_sigma_err[Fit]),"efit_sigma_err[5][64][48][2]/F");
435 t->Branch("efit_kurtosis",*(m_rc_kurtosis[Fit]),"efit_kurtosis[5][64][48][2]/F");
436 t->Branch("efit_skewness",*(m_rc_skewness[Fit]),"efit_skewness[5][64][48][2]/F");
437 t->Branch("efit_chi2",*(m_rc_chi2[Fit]),"efit_chi2[5][64][48][2]/F");
438 t->Branch("efit_ndf",*(m_rc_ndf[Fit]),"efit_ndf[5][64][48][2]/F");
439 t->Branch("efit_probC2",*(m_rc_probC2[Fit]),"efit_probC2[5][64][48][2]/F");
440
441 t->Branch("efit_gsigma1",*(m_rc_gsigma1[Fit]),"efit_gsigma1[5][64][48][2]/F");
442 t->Branch("efit_gsigma2",*(m_rc_gsigma2[Fit]),"efit_gsigma2[5][64][48][2]/F");
443 t->Branch("efit_gnorm",*(m_rc_gnorm[Fit]),"efit_gnorm[5][64][48][2]/F");
444 t->Branch("efit_gchi2",*(m_rc_gchi2[Fit]),"efit_gchi2[5][64][48][2]/F");
445 t->Branch("efit_gerrsigma1",*(m_rc_gerrsigma1[Fit]),"efit_gerrsigma1[5][64][48][2]/F");
446 t->Branch("efit_gerrnorm",*(m_rc_gerrnorm[Fit]),"efit_gerrnorm[5][64][48][2]/F");
447 t->Branch("efit_gerrsigma2",*(m_rc_gerrsigma2[Fit]),"efit_gerrsigma2[5][64][48][2]/F");
448 t->Branch("efit_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Fit]),"efit_gcorrsigma1sigma2[5][64][48][2]/F");
449
450
451 t->Branch("efixed_mean",*(m_rc_mean[Fixed]),"efixed_mean[5][64][48][2]/F");
452 t->Branch("efixed_av",*(m_rc_av[Fixed]),"efixed_av[5][64][48][2]/F");
453 t->Branch("efixed_rms",*(m_rc_rms[Fixed]),"efixed_rms[5][64][48][2]/F");
454 t->Branch("efixed_sigma",*(m_rc_sigma[Fixed]),"efixed_sigma[5][64][48][2]/F");
455 t->Branch("efixed_mean_err",*(m_rc_mean_err[Fixed]),"efixed_mean_err[5][64][48][2]/F");
456 t->Branch("efixed_sigma_err",*(m_rc_sigma_err[Fixed]),"efixed_sigma_err[5][64][48][2]/F");
457 t->Branch("efixed_kurtosis",*(m_rc_kurtosis[Fixed]),"efixed_kurtosis[5][64][48][2]/F");
458 t->Branch("efixed_skewness",*(m_rc_skewness[Fixed]),"efixed_skewness[5][64][48][2]/F");
459 t->Branch("efixed_chi2",*(m_rc_chi2[Fixed]),"efixed_chi2[5][64][48][2]/F");
460 t->Branch("efixed_ndf",*(m_rc_ndf[Fixed]),"efixed_ndf[5][64][48][2]/F");
461 t->Branch("efixed_probC2",*(m_rc_probC2[Fixed]),"efixed_probC2[5][64][48][2]/F");
462
463 t->Branch("efixed_gsigma1",*(m_rc_gsigma1[Fixed]),"efixed_gsigma1[5][64][48][2]/F");
464 t->Branch("efixed_gsigma2",*(m_rc_gsigma2[Fixed]),"efixed_gsigma2[5][64][48][2]/F");
465 t->Branch("efixed_gnorm",*(m_rc_gnorm[Fixed]),"efixed_gnorm[5][64][48][2]/F");
466 t->Branch("efixed_gchi2",*(m_rc_gchi2[Fixed]),"efixed_gchi2[5][64][48][2]/F");
467 t->Branch("efixed_gerrsigma1",*(m_rc_gerrsigma1[Fixed]),"efixed_gerrsigma1[5][64][48][2]/F");
468 t->Branch("efixed_gerrnorm",*(m_rc_gerrnorm[Fixed]),"efixed_gerrnorm[5][64][48][2]/F");
469 t->Branch("efixed_gerrsigma2",*(m_rc_gerrsigma2[Fixed]),"efixed_gerrsigma2[5][64][48][2]/F");
470 t->Branch("efixed_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Fixed]),"efixed_gcorrsigma1sigma2[5][64][48][2]/F");
471
472
473 t->Branch("eopt_mean",*(m_rc_mean[Opt]),"eopt_mean[5][64][48][2]/F");
474 t->Branch("eopt_av",*(m_rc_av[Opt]),"eopt_av[5][64][48][2]/F");
475 t->Branch("eopt_rms",*(m_rc_rms[Opt]),"eopt_rms[5][64][48][2]/F");
476 t->Branch("eopt_sigma",*(m_rc_sigma[Opt]),"eopt_sigma[5][64][48][2]/F");
477 t->Branch("eopt_mean_err",*(m_rc_mean_err[Opt]),"eopt_mean_err[5][64][48][2]/F");
478 t->Branch("eopt_sigma_err",*(m_rc_sigma_err[Opt]),"eopt_sigma_err[5][64][48][2]/F");
479 t->Branch("eopt_kurtosis",*(m_rc_kurtosis[Opt]),"eopt_kurtosis[5][64][48][2]/F");
480 t->Branch("eopt_skewness",*(m_rc_skewness[Opt]),"eopt_skewness[5][64][48][2]/F");
481 t->Branch("eopt_chi2",*(m_rc_chi2[Opt]),"eopt_chi2[5][64][48][2]/F");
482 t->Branch("eopt_ndf",*(m_rc_ndf[Opt]),"eopt_ndf[5][64][48][2]/F");
483 t->Branch("eopt_probC2",*(m_rc_probC2[Opt]),"eopt_probC2[5][64][48][2]/F");
484
485 t->Branch("eopt_gsigma1",*(m_rc_gsigma1[Opt]),"eopt_gsigma1[5][64][48][2]/F");
486 t->Branch("eopt_gsigma2",*(m_rc_gsigma2[Opt]),"eopt_gsigma2[5][64][48][2]/F");
487 t->Branch("eopt_gnorm",*(m_rc_gnorm[Opt]),"eopt_gnorm[5][64][48][2]/F");
488 t->Branch("eopt_gchi2",*(m_rc_gchi2[Opt]),"eopt_gchi2[5][64][48][2]/F");
489 t->Branch("eopt_gerrsigma1",*(m_rc_gerrsigma1[Opt]),"eopt_gerrsigma1[5][64][48][2]/F");
490 t->Branch("eopt_gerrnorm",*(m_rc_gerrnorm[Opt]),"eopt_gerrnorm[5][64][48][2]/F");
491 t->Branch("eopt_gerrsigma2",*(m_rc_gerrsigma2[Opt]),"eopt_gerrsigma2[5][64][48][2]/F");
492 t->Branch("eopt_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Opt]),"eopt_gcorrsigma1sigma2[5][64][48][2]/F");
493
494
495 t->Branch("edsp_mean",*(m_rc_mean[Dsp]),"edsp_mean[5][64][48][2]/F");
496 t->Branch("edsp_av",*(m_rc_av[Dsp]),"edsp_av[5][64][48][2]/F");
497 t->Branch("edsp_rms",*(m_rc_rms[Dsp]),"edsp_rms[5][64][48][2]/F");
498 t->Branch("edsp_sigma",*(m_rc_sigma[Dsp]),"edsp_sigma[5][64][48][2]/F");
499 t->Branch("edsp_mean_err",*(m_rc_mean_err[Dsp]),"edsp_mean_err[5][64][48][2]/F");
500 t->Branch("edsp_sigma_err",*(m_rc_sigma_err[Dsp]),"edsp_sigma_err[5][64][48][2]/F");
501 t->Branch("edsp_kurtosis",*(m_rc_kurtosis[Dsp]),"edsp_kurtosis[5][64][48][2]/F");
502 t->Branch("edsp_skewness",*(m_rc_skewness[Dsp]),"edsp_skewness[5][64][48][2]/F");
503 t->Branch("edsp_chi2",*(m_rc_chi2[Dsp]),"edsp_chi2[5][64][48][2]/F");
504 t->Branch("edsp_ndf",*(m_rc_ndf[Dsp]),"edsp_ndf[5][64][48][2]/F");
505 t->Branch("edsp_probC2",*(m_rc_probC2[Dsp]),"edsp_probC2[5][64][48][2]/F");
506
507 t->Branch("edsp_gsigma1",*(m_rc_gsigma1[Dsp]),"edsp_gsigma1[5][64][48][2]/F");
508 t->Branch("edsp_gsigma2",*(m_rc_gsigma2[Dsp]),"edsp_gsigma2[5][64][48][2]/F");
509 t->Branch("edsp_gnorm",*(m_rc_gnorm[Dsp]),"edsp_gnorm[5][64][48][2]/F");
510 t->Branch("edsp_gchi2",*(m_rc_gchi2[Dsp]),"edsp_gchi2[5][64][48][2]/F");
511 t->Branch("edsp_gerrsigma1",*(m_rc_gerrsigma1[Dsp]),"edsp_gerrsigma1[5][64][48][2]/F");
512 t->Branch("edsp_gerrnorm",*(m_rc_gerrnorm[Dsp]),"edsp_gerrnorm[5][64][48][2]/F");
513 t->Branch("edsp_gerrsigma2",*(m_rc_gerrsigma2[Dsp]),"edsp_gerrsigma2[5][64][48][2]/F");
514 t->Branch("edsp_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[Dsp]),"edsp_gcorrsigma1sigma2[5][64][48][2]/F");
515
516
517 t->Branch("eOF1_mean",*(m_rc_mean[OF1]),"eOF1_mean[5][64][48][2]/F");
518 t->Branch("eOF1_av",*(m_rc_av[OF1]),"eOF1_av[5][64][48][2]/F");
519 t->Branch("eOF1_rms",*(m_rc_rms[OF1]),"eOF1_rms[5][64][48][2]/F");
520 t->Branch("eOF1_sigma",*(m_rc_sigma[OF1]),"eOF1_sigma[5][64][48][2]/F");
521 t->Branch("eOF1_mean_err",*(m_rc_mean_err[OF1]),"eOF1_mean_err[5][64][48][2]/F");
522 t->Branch("eOF1_sigma_err",*(m_rc_sigma_err[OF1]),"eOF1_sigma_err[5][64][48][2]/F");
523 t->Branch("eOF1_kurtosis",*(m_rc_kurtosis[OF1]),"eOF1_kurtosis[5][64][48][2]/F");
524 t->Branch("eOF1_skewness",*(m_rc_skewness[OF1]),"eOF1_skewness[5][64][48][2]/F");
525 t->Branch("eOF1_chi2",*(m_rc_chi2[OF1]),"eOF1_chi2[5][64][48][2]/F");
526 t->Branch("eOF1_ndf",*(m_rc_ndf[OF1]),"eOF1_ndf[5][64][48][2]/F");
527 t->Branch("eOF1_probC2",*(m_rc_probC2[OF1]),"eOF1_probC2[5][64][48][2]/F");
528
529 t->Branch("eOF1_gsigma1",*(m_rc_gsigma1[OF1]),"eOF1_gsigma1[5][64][48][2]/F");
530 t->Branch("eOF1_gsigma2",*(m_rc_gsigma2[OF1]),"eOF1_gsigma2[5][64][48][2]/F");
531 t->Branch("eOF1_gnorm",*(m_rc_gnorm[OF1]),"eOF1_gnorm[5][64][48][2]/F");
532 t->Branch("eOF1_gchi2",*(m_rc_gchi2[OF1]),"eOF1_gchi2[5][64][48][2]/F");
533 t->Branch("eOF1_gerrsigma1",*(m_rc_gerrsigma1[OF1]),"eOF1_gerrsigma1[5][64][48][2]/F");
534 t->Branch("eOF1_gerrnorm",*(m_rc_gerrnorm[OF1]),"eOF1_gerrnorm[5][64][48][2]/F");
535 t->Branch("eOF1_gerrsigma2",*(m_rc_gerrsigma2[OF1]),"eOF1_gerrsigma2[5][64][48][2]/F");
536 t->Branch("eOF1_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[OF1]),"eOF1_gcorrsigma1sigma2[5][64][48][2]/F");
537
538
539 t->Branch("eMF_mean",*(m_rc_mean[MF]),"eMF_mean[5][64][48][2]/F");
540 t->Branch("eMF_av",*(m_rc_av[MF]),"eMF_av[5][64][48][2]/F");
541 t->Branch("eMF_rms",*(m_rc_rms[MF]),"eMF_rms[5][64][48][2]/F");
542 t->Branch("eMF_sigma",*(m_rc_sigma[MF]),"eMF_sigma[5][64][48][2]/F");
543 t->Branch("eMF_mean_err",*(m_rc_mean_err[MF]),"eMF_mean_err[5][64][48][2]/F");
544 t->Branch("eMF_sigma_err",*(m_rc_sigma_err[MF]),"eMF_sigma_err[5][64][48][2]/F");
545 t->Branch("eMF_kurtosis",*(m_rc_kurtosis[MF]),"eMF_kurtosis[5][64][48][2]/F");
546 t->Branch("eMF_skewness",*(m_rc_skewness[MF]),"eMF_skewness[5][64][48][2]/F");
547 t->Branch("eMF_chi2",*(m_rc_chi2[MF]),"eMF_chi2[5][64][48][2]/F");
548 t->Branch("eMF_ndf",*(m_rc_ndf[MF]),"eMF_ndf[5][64][48][2]/F");
549 t->Branch("eMF_probC2",*(m_rc_probC2[MF]),"eMF_probC2[5][64][48][2]/F");
550
551 t->Branch("eMF_gsigma1",*(m_rc_gsigma1[MF]),"eMF_gsigma1[5][64][48][2]/F");
552 t->Branch("eMF_gsigma2",*(m_rc_gsigma2[MF]),"eMF_gsigma2[5][64][48][2]/F");
553 t->Branch("eMF_gnorm",*(m_rc_gnorm[MF]),"eMF_gnorm[5][64][48][2]/F");
554 t->Branch("eMF_gchi2",*(m_rc_gchi2[MF]),"eMF_gchi2[5][64][48][2]/F");
555 t->Branch("eMF_gerrsigma1",*(m_rc_gerrsigma1[MF]),"eMF_gerrsigma1[5][64][48][2]/F");
556 t->Branch("eMF_gerrnorm",*(m_rc_gerrnorm[MF]),"eMF_gerrnorm[5][64][48][2]/F");
557 t->Branch("eMF_gerrsigma2",*(m_rc_gerrsigma2[MF]),"eMF_gerrsigma2[5][64][48][2]/F");
558 t->Branch("eMF_gcorrsigma1sigma2",*(m_rc_gcorrsigma1sigma2[MF]),"eMF_gcorrsigma1sigma2[5][64][48][2]/F");
559
560
561 t->Branch("ecell_av",*(m_ecell_av),"ecell_av[2][64][4][17][6]/F");
562 t->Branch("ecell_rms",*(m_ecell_rms),"ecell_rms[2][64][4][17][6]/F");
563 t->Branch("ecell_hash",*(m_ecell_hash),"ecell_hash[2][64][4][17]/i");
564 t->Branch("ecell_gsigma1",*(m_gsigma1),"ecell_gsigma1[2][64][4][17][6]/F");
565 t->Branch("ecell_gsigma2",*(m_gsigma2),"ecell_gsigma2[2][64][4][17][6]/F");
566 t->Branch("ecell_gnorm",*(m_gnorm),"ecell_gnorm[2][64][4][17][6]/F");
567 t->Branch("ecell_gchi2",*(m_gchi2),"ecell_gchi2[2][64][4][17][6]/F");
568 t->Branch("ecell_gerrsigma1",*(m_gerrsigma1),"ecell_gerrsigma1[2][64][4][17][6]/F");
569 t->Branch("ecell_gerrnorm",*(m_gerrnorm),"ecell_gerrnorm[2][64][4][17][6]/F");
570 t->Branch("ecell_gerrsigma2",*(m_gerrsigma2),"ecell_gerrsigma2[2][64][4][17][6]/F");
571 t->Branch("ecell_gcorrsigma1sigma2",*(m_gcorrsigma1sigma2),"ecell_gcorrsigma1sigma2[2][64][4][17][6]/F");
572// t->Branch("ecell_gcorrsigma1norm",*(gcorrsigma1norm),"ecell_gcorrsigma1norm[2][64][4][17][6]/F");
573// t->Branch("ecell_gcorrsigma2norm",*(gcorrsigma2norm),"ecell_gcorrsigma2norm[2][64][4][17][6]/F");
574 t->Branch("side", *m_side, "side[2][64][4][17][6]/O");
575 t->Branch("phi", *m_phi, "phi[2][64][4][17][6]/b");
576 t->Branch("sample", *m_sample, "sample[2][64][4][17][6]/b");
577 t->Branch("tower", *m_tower, "tower[2][64][4][17][6]/b");
578 t->Branch("gaingain", *m_gg, "gaingain[2][64][4][17][6]/b");
579
580 // Fill with current values (i.e. tree will have only one entry for this whole run)
581
582 t->Fill();
583 t->Write();
584
585 if (m_saveHist) {
586
587 for (int rc = 0; rc < RCnum; ++rc) {
588
589 if ((m_doFit && rc == Fit)
590 || (m_doFixed && rc == Fixed)
591 || (m_doOpt && rc == Opt)
592 || (m_doDsp && rc == Dsp)
593 || (m_doOF1 && rc == OF1)
594 || (m_doMF && rc == MF)) {
595
596 for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
597 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
598 for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
599 for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
600 m_histAmp[rc][ros][drawer][ch][g]->Write();
601 }
602 }
603 }
604 }
605 }
606 }
607
608 for (int side = 0; side < NSIDES; side++) {
609 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
610 for (int sample = 0; sample < NSAMPLES; ++sample) {
611 for (int tower = 0; tower < NTOWERS; ++tower) {
612 for (int gg = 0; gg < NCELLGAINS; ++gg) {
613 m_histCellAmp[side][drawer][sample][tower][gg]->Write();
614 }
615 }
616 }
617 }
618 }
619 }
620
621 fout->Close();
622
623
624 deleteHist();
625
626 return StatusCode::SUCCESS;
627}
628
630void TileRawChNoiseCalibAlg::StoreRunInfo(const TileDQstatus* dqStatus) {
631 if (not dqStatus){
632 m_time = 0;
633 m_year = 0;
634 m_month = 0;
635 m_day = 0;
636 m_yday = 0;
637 m_hour = 0;
638 m_min = 0;
639 m_trigType = 0;
640 ATH_MSG_WARNING("TileRawChNoiseCalibAlg::StoreRunInfo : dqStatus pointer is null");
641 return;
642 }
643 MsgStream log(msgSvc(), name());
644
645 if (dqStatus->calibMode() == 1 && m_beamElemContainer.length() > 0) {// Bigain can use cispar
646
647 if (m_beamCnv) {
648
649 if (m_beamCnv->validBeamFrag()) {
650 m_run = m_beamCnv->robFragment()->rod_run_no(); // take it from beam ROD header
651 } else {
652 m_run = 0;
653 }
654 } else
655 m_run = 0;
656
657 if (m_cispar) {
658 m_time = m_cispar[10]; //time in sc from 1970
659 m_trigType = m_cispar[12];
660 } else {
661 m_time = 0;
662 m_year = 0;
663 m_month = 0;
664 m_day = 0;
665 m_yday = 0;
666 m_hour = 0;
667 m_min = 0;
668 m_trigType = 0;
669 }
670 } else { // monogain can use eventinfo
671
672 SG::ReadHandle<xAOD::EventInfo> eventInfo(m_eventInfoKey);
673 if ( !eventInfo.isValid() ) {
674 ATH_MSG_ERROR( "No EventInfo object found! Can't read run number!" );
675 m_run = 0;
676 m_time = 0;
677 m_trigType = 0;
678 } else {
679 m_run = eventInfo->runNumber();
680 m_time = eventInfo->timeStamp();
681 if (!(eventInfo->eventType(xAOD::EventInfo::IS_CALIBRATION))) // if not calibration, physics
682 m_trigType = 1;
683 else
684 m_trigType = 0;
685 }
686 }
687
688 if (m_time != 0) {
689 struct tm t;
690 time_t t_time = m_time;
691 localtime_r(&t_time, &t);
692 m_year = t.tm_year + 1900;
693 m_month = t.tm_mon + 1;
694 m_day = t.tm_mday;
695 m_yday = t.tm_yday + 1;
696 m_hour = t.tm_hour;
697 m_min = t.tm_min;
698 } else {
699 m_year = 0;
700 m_month = 0;
701 m_day = 0;
702 m_yday = 0;
703 m_hour = 0;
704 m_min = 0;
705 }
706}
707
708// fillRawChannels is called at every events.
709// Statistics is summed for Average, RMS calculations
710/*---------------------------------------------------------*/
711StatusCode TileRawChNoiseCalibAlg::fillRawChannels(const TileDQstatus* dqStatus,
712 const SG::ReadHandleKey<TileRawChannelContainer>& rawChannelContainerKey,
713 RCtype rctype) {
714/*---------------------------------------------------------*/
715
716 SG::ReadHandle<TileRawChannelContainer> rawChannelContainer(rawChannelContainerKey);
717 ATH_CHECK( rawChannelContainer.isValid() );
718
719 if ((rctype == Dsp) && (m_trigType != Phys)) {
720 ATH_MSG_ERROR( "Removing DSP RawChannelContainer for non Phys run. TrigType is: " << m_trigType );
721 return StatusCode::FAILURE;
722 }
723
724 TileRawChannelUnit::UNIT RChUnit = rawChannelContainer->get_unit();
725
726 TileRawChannelContainer::const_iterator collItr = rawChannelContainer->begin();
727 TileRawChannelContainer::const_iterator lastColl = rawChannelContainer->end();
728
729 for (; collItr != lastColl; ++collItr) {
730
731 TileRawChannelCollection::const_iterator chItr = (*collItr)->begin();
732 TileRawChannelCollection::const_iterator lastCh = (*collItr)->end();
733
734 for (; chItr != lastCh; ++chItr) {
735
736 const TileRawChannel* rch = (*chItr);
737
738 HWIdentifier adc_id = (*chItr)->adc_HWID();
739 unsigned int ros(0), drawer(0), channel(0), gain(0);
740 m_tileIdTrans->getIndices(adc_id, ros, drawer, channel, gain);
741 unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
742
743 if (dqStatus->isChEmpty(ros, drawer, channel)) continue;
744
745 // If DQ problem, do not fill calib ntuple
746 if (m_calibMode == 1) { // Bigain: check indivual adc's
747
748 if (!(dqStatus->isAdcDQgood(ros, drawer, channel, gain))) {
749 ATH_MSG_VERBOSE( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
750 << " channel: " << channel
751 << " ADC: " << gain << " due to DQ error found." );
752
753 continue;
754 }
755 } else { // monogain, just check channel
756
757 if (!(dqStatus->isChanDQgood(ros, drawer, channel))) {
758 ATH_MSG_VERBOSE( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
759 << " channel: " << channel << " due to DQ error found." );
760
761 continue;
762 }
763 }
764
765 // we fill the cell information now for selected method
766 // note that fillCell is called only for good channels
767 if (rctype == m_UseforCells) fillCell(RChUnit, rch);
768
769 double amp = rch->amplitude();
770 if (RChUnit > TileRawChannelUnit::OnlineADCcounts) {
771 // go from online units to ADC counts
772 amp = m_tileToolEmscale->undoOnlCalib(drawerIdx, channel, gain, amp, RChUnit);
773 } else if (RChUnit == TileRawChannelUnit::OnlineADCcounts) {
774 // nothing to do
775 } else if (RChUnit > TileRawChannelUnit::ADCcounts) {
776 // go from offline units to ADC counts
777 amp /= m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, 1.0, TileRawChannelUnit::ADCcounts, RChUnit);
778 }
779
780 // PMT-1 or channel index depending on jobOptions
781 unsigned int chan = (m_usePMT) ? digiChannel2PMT(ros, channel) : channel;
782
783 m_evt[ros][drawer][chan][gain]++;
784 m_histAmp[rctype][ros][drawer][chan][gain]->Fill(amp);
785 }
786 }
787
788 if (rctype == m_UseforCells) fillCellHist(); //we fill the cell histograms only at the end of the loop over the channels,
789 //when all the cells have been built
790
791 return StatusCode::SUCCESS;
792}
793
796/*---------------------------------------------------------*/
797void TileRawChNoiseCalibAlg::finalRawCh(int rctype) {
798 /*---------------------------------------------------------*/
799
800 // Some of the ROOT histogram/fitting code is not protected against FPEs.
801 // Just disable the detection of FPEs for this function.
802 CxxUtils::FPControl ctl;
803 ctl.disable (CxxUtils::FPControl::Exc::divbyzero |
804 CxxUtils::FPControl::Exc::invalid);
805
806 TF1 * fit_gaus = new TF1("g", "gaus");
807
808 for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
809 ATH_MSG_INFO( "Fitting RCh container " << rctype << " ROS " << ros );
810
811 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
812 for (unsigned int gain = 0; gain < TileCalibUtils::MAX_GAIN; ++gain) {
813 for (unsigned int chan = 0; chan < TileCalibUtils::MAX_CHAN; ++chan) {
814
815 if (!m_fillidx) {
816 m_fillidx = true;
817 m_ros[ros][drawer][chan][gain] = ros;
818 m_drawer[ros][drawer][chan][gain] = drawer;
819 m_channel[ros][drawer][chan][gain] = chan;
820 m_gain[ros][drawer][chan][gain] = gain;
821 }
822
823 if (m_evt[ros][drawer][chan][gain] > 0) {
824
825 TH1F& histAmp = *m_histAmp[rctype][ros][drawer][chan][gain];
826 histAmp.Fit("g", "NQ");
827
828 m_rc_av[rctype][ros][drawer][chan][gain] = histAmp.GetMean();
829 m_rc_rms[rctype][ros][drawer][chan][gain] = histAmp.GetRMS();
830
831 if (TMath::Abs(histAmp.GetSkewness()) < 1000.)
832 m_rc_skewness[rctype][ros][drawer][chan][gain] = histAmp.GetSkewness();
833 if (TMath::Abs(histAmp.GetKurtosis()) < 1000.)
834 m_rc_kurtosis[rctype][ros][drawer][chan][gain] = histAmp.GetKurtosis();
835
836 m_rc_mean[rctype][ros][drawer][chan][gain] = fit_gaus->GetParameter(1);
837 m_rc_mean_err[rctype][ros][drawer][chan][gain] = fit_gaus->GetParError(1);
838 m_rc_sigma[rctype][ros][drawer][chan][gain] = fit_gaus->GetParameter(2);
839 m_rc_sigma_err[rctype][ros][drawer][chan][gain] = fit_gaus->GetParError(2);
840 m_rc_chi2[rctype][ros][drawer][chan][gain] = fit_gaus->GetChisquare();
841 m_rc_ndf[rctype][ros][drawer][chan][gain] = fit_gaus->GetNDF();
842 m_rc_probC2[rctype][ros][drawer][chan][gain] = fit_gaus->GetProb();
843
844 doFit(&histAmp, m_rc_ggpar[rctype][ros][drawer][chan][gain], m_invertChanRatio);
845
846 m_rc_gsigma1[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][0];
847 m_rc_gsigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][2];
848 m_rc_gnorm[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][1];
849 m_rc_gchi2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][3];
850 m_rc_gerrsigma1[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][4];
851 m_rc_gerrnorm[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][5];
852 m_rc_gerrsigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][6];
853 m_rc_gcorrsigma1sigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][7];
854
855 } // end if evt>0
856
857 }
858 }
859 }
860 } // end if ros
861
862 delete fit_gaus;
863
864}
865
866
867// fillCell is called at every events.
868// Statistics is summed for Average, RMS calculations
869/*---------------------------------------------------------*/
870void TileRawChNoiseCalibAlg::fillCell(TileRawChannelUnit::UNIT RChUnit, const TileRawChannel * rch) {
871 /*---------------------------------------------------------*/
872
873 int index, pmt;
874 Identifier cell_id = rch->cell_ID_index(index, pmt);
875 if (index > -1) { //disconnect channel index is -1/ MBTS cell index is -2 and they don't have an idhash
876 unsigned int ros(0), drawer(0), channel(0), gain(0);
877 m_tileIdTrans->getIndices(rch->adc_HWID(), ros, drawer, channel, gain);
878 unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
879
880 if (m_maskBadChannels && m_tileBadChanTool->getAdcStatus(drawerIdx, channel, gain).isBad()) {
881 ATH_MSG_VERBOSE( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
882 << " channel: " << channel
883 << " ADC: " << gain
884 << " in fillCell() because channel is bad in DB." );
885 return;
886 }
887
888 int sample = m_tileID->sample(cell_id);
889 int tower = m_tileID->tower(cell_id);
890 int side = m_tileID->side(cell_id);
891
892 if (side == 1) side = 0; //A side
893 else if (side == -1) side = 1; //C side
894 else side = 0; //D0 cell? we put it in LBA
895
896 if (m_evtNr < 1) { //first event
897 m_ecell_hash[side][drawer][sample][tower] = m_tileID->cell_hash(cell_id);
898 }
899
900 int g, gg;
901 if (gain == 0) {
902 gg = 0;
903 if (pmt == 0) g = 1; //in most cases even channels on side A AND odd channels on side C
904 else g = 2; //are the first channels of the cells
905 } else {
906 gg = 3;
907 if (pmt == 0) g = 4; //pmt tells us which is the first and second channel of the cells!!
908 else g = 5;
909 }
910
911 //not needed anymore if (channel==0 && ros==2) g++; //D0 second channel is special : move from first to second channel
912
913 double amp = rch->amplitude();
914 amp = m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, amp, RChUnit, TileRawChannelUnit::MegaElectronVolts);
915 int nch = 1;
916
917 if (m_cabling->isRun2PlusCabling() && (ros > 2)) { // Ext.barrel modules
918
919 if (channel == E1_CHANNEL) { // Raw channel -> E1 cell.
920 int drawer2 = m_cabling->E1_merged_with_run2plus(ros, drawer);
921 if (drawer2 != 0) { // Raw channel splitted into two E1 cells for Run 2.
922 amp /= 2.0F;
923 m_ecell_ene[side][drawer2][sample][tower][gg / 3] += amp;
924 ++m_cell_nch[side][drawer2][sample][tower][gg / 3];
925
926 if (TMath::Abs(amp) > 1.e-5) {
927 m_histCellAmp[side][drawer2][sample][tower][g]->Fill(amp);
928 }
929 }
930
931 } else if (!TileCablingService::C10_connected(drawer)) { // modules with special C10
932 if (channel == OUTER_MBTS_CHANNEL) {
933 amp = 0.0; // ignore MBTS completely
934 nch = 0;
935 } else if (channel == SPECIAL_C10_CHANNEL) {
936 nch = 2; // count this channel twice - needed for correct bad-channel masking
937 }
938 }
939 }
940
941 m_ecell_ene[side][drawer][sample][tower][gg / 3] += amp;
942 m_cell_nch[side][drawer][sample][tower][gg / 3] += nch;
943
944 if (TMath::Abs(amp) > 1.e-5) {
945 m_histCellAmp[side][drawer][sample][tower][g]->Fill(amp);
946 }
947
948 } // is a connected channel
949}
950
951
954/*---------------------------------------------------------*/
955void TileRawChNoiseCalibAlg::finalCell() {
956 /*---------------------------------------------------------*/
957
958 for (int side = 0; side < 2; ++side) {
959 ATH_MSG_INFO( "Fitting cells side " << side );
960 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
961 for (int sample = 0; sample < 4; ++sample) {
962 for (int tower = 0; tower < 17; ++tower) {
963 for (int gg = 0; gg < 6; ++gg) {
964
965 m_side[side][drawer][sample][tower][gg] = side;
966 m_phi[side][drawer][sample][tower][gg] = drawer;
967 m_sample[side][drawer][sample][tower][gg] = sample;
968 m_tower[side][drawer][sample][tower][gg] = tower;
969 m_gg[side][drawer][sample][tower][gg] = gg;
970
971 if (m_histCellAmp[side][drawer][sample][tower][gg]->GetEntries() > 0) {
972
973 m_ecell_av[side][drawer][sample][tower][gg] = m_histCellAmp[side][drawer][sample][tower][gg]->GetMean();
974 m_ecell_rms[side][drawer][sample][tower][gg] = m_histCellAmp[side][drawer][sample][tower][gg]->GetRMS();
975 doFit(m_histCellAmp[side][drawer][sample][tower][gg], m_ggpar[side][drawer][sample][tower][gg]);
976 m_gsigma1[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][0];
977 m_gsigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][2];
978 m_gnorm[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][1];
979 m_gchi2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][3];
980 m_gerrsigma1[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][4];
981 m_gerrnorm[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][5];
982 m_gerrsigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][6];
983 m_gcorrsigma1sigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][7];
984// gcorrsigma1norm[side][drawer][sample][tower][gg]=m_ggpar[side][drawer][sample][tower][gg][8];
985// gcorrsigma2norm[side][drawer][sample][tower][gg]=m_ggpar[side][drawer][sample][tower][gg][9];
986
987 }
988
989 }
990 }
991 }
992 }
993 }
994
995}
996
998/*---------------------------------------------------------*/
999void TileRawChNoiseCalibAlg::doFit(TH1F* h, float* gp, bool invert) {
1000/*---------------------------------------------------------*/
1001 Double_t par[6];
1002
1003 float xmin = h->GetBinCenter(1);
1004 float xmax = h->GetBinCenter(h->GetNbinsX());
1005 TF1 total("total", "gaus(0)+gaus(3)", xmin, xmax);
1006 total.SetLineColor(2);
1007
1008 float nentries = h->GetEntries();
1009
1010 if (nentries == 0) {
1011 // Protect against empty histogram.
1012 std::fill (gp, gp+8, 0);
1013 return;
1014 }
1015
1016 float rms = h->GetRMS();
1017 float bin = h->GetBinWidth(0);
1018
1019 par[0] = 0.1 * nentries;
1020 par[1] = 0.;
1021 par[2] = 0.7 * std::max(rms, bin);
1022
1023 par[3] = 0.15 * par[0];
1024 par[4] = 0.;
1025 par[5] = 5. * par[2];
1026
1027 total.SetParameters(par);
1028
1029 float lim1 = bin / 2.;
1030 float lim2 = std::max(rms * 1.05, bin * 2.0);
1031 float lim3 = std::max(rms * 10.0, bin * 20.);
1032
1033 float limN1 = nentries;
1034 if (lim1 < 0.5) limN1 /= (2. * lim1); // a bit more than Nentries / ( sqrt(2*pi) * sigma1 )
1035 float limN2 = nentries;
1036 if (lim2 < 0.5) limN2 /= (2. * lim2); // a bit more than Nentries / ( sqrt(2*pi) * sigma2 )
1037
1038 total.SetParLimits(0, 0., limN1);
1039 total.FixParameter(1, 0.);
1040 total.SetParLimits(2, lim1, lim2);
1041 total.SetParLimits(3, 0., limN2);
1042 total.FixParameter(4, 0.);
1043 total.SetParLimits(5, lim2, lim3);
1044
1045 TFitResultPtr resfit = h->Fit(&total, "BLQRS");
1046
1047 float par0 = total.GetParameter(0);
1048 float par3 = total.GetParameter(3);
1049
1050 float sigma1 = total.GetParameter(2); //sigma gauss1
1051 float sigma2 = total.GetParameter(5); //sigma gauss1
1052
1053 //Get errors
1054 float errpar0 = total.GetParError(0);
1055 float errpar3 = total.GetParError(3);
1056
1057 float errsigma1 = total.GetParError(2);
1058 float errsigma2 = total.GetParError(5);
1059
1060 float norm = par0 != 0 ? par3 / par0 : 0; //rel normalization of the gaussians
1061
1062 if (invert && norm > 1.) { //invert the 2 gaussians if normalization is greater than 1
1063
1064 gp[0] = sigma2;
1065 gp[1] = 1. / norm;
1066 gp[2] = sigma1;
1067
1068 gp[4] = errsigma2;
1069 gp[5] = sqrt((errpar0 * errpar0) + (errpar3 * errpar3) * (par0 * par0) / (par3 * par3)) / par3;
1070 gp[6] = errsigma1;
1071
1072 } else {
1073
1074 gp[0] = sigma1;
1075 gp[1] = norm;
1076 gp[2] = sigma2;
1077
1078 gp[4] = errsigma1;
1079 gp[5] = par0 != 0 ? sqrt((errpar3 * errpar3) + (errpar0 * errpar0) * (par3 * par3) / (par0 * par0)) / par0 : 0;
1080 gp[6] = errsigma2;
1081
1082 }
1083
1084 if (total.GetNDF() > 0) {
1085 gp[3] = total.GetChisquare() / total.GetNDF(); //chi2/ndf
1086 } else {
1087 gp[3] = 0.;
1088 }
1089
1090 // Get correlation sigma1, sigma2
1091 if (resfit->CovMatrixStatus()) {
1092 TMatrixDSym corr = resfit->GetCorrelationMatrix();
1093 gp[7] = corr(2, 5);
1094 }
1095 else {
1096 // May happen if the input histogram is empty.
1097 gp[7] = 0;
1098 }
1099}
1100
1101
1104/*---------------------------------------------------------*/
1105void TileRawChNoiseCalibAlg::fillCellHist() {
1106/*---------------------------------------------------------*/
1107
1108 for (int side = 0; side < 2; ++side) {
1109 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
1110 for (int sample = 0; sample < 4; ++sample) {
1111 for (int tower = 0; tower < 17; ++tower) {
1112 for (unsigned int gg = 0; gg < TileCalibUtils::MAX_GAIN; ++gg) {
1113
1114 float ene = m_ecell_ene[side][drawer][sample][tower][gg];
1115 if (m_cell_nch[side][drawer][sample][tower][gg] == 1 && sample != 3) ene *= 2; // one good channel in normal cell - multiply energy by 2
1116
1117 if (TMath::Abs(ene) > 1.e-5) {
1118 m_histCellAmp[side][drawer][sample][tower][gg * 3]->Fill(ene);
1119 }
1120
1121 }
1122 }
1123 }
1124 }
1125 }
1126
1127}
1128
1129
1130
1134/*---------------------------------------------------------*/
1135void TileRawChNoiseCalibAlg::deleteHist() {
1136/*---------------------------------------------------------*/
1137
1138 for (int rc = 0; rc < RCnum; ++rc) {
1139 for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
1140 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
1141
1142 for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
1143 for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
1144 delete m_histAmp[rc][ros][drawer][ch][g];
1145 }
1146 }
1147 }
1148 }
1149 }
1150
1151 for (int side = 0; side < 2; side++) {
1152 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
1153 for (int sample = 0; sample < 4; ++sample) {
1154 for (int tower = 0; tower < 17; ++tower) {
1155 for (int gg = 0; gg < 6; gg++) {
1156 delete m_histCellAmp[side][drawer][sample][tower][gg];
1157 }
1158 }
1159 }
1160 }
1161 }
1162
1163}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
errorcheck.h
Helpers for checking error return status codes and reporting errors.
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition Control/AthenaKernel/AthenaKernel/errorcheck.h:422
FPControl.h
Helper to control FP exceptions.
rc
static Double_t rc
Definition LArPhysWaveHECTool.cxx:37
ReadHandle.h
Handle class for reading from StoreGate.
GetEntries
TGraphErrors * GetEntries(TH2F *histo)
Definition TRTCalib_makeplots.cxx:4025
empty
static const Attributes_t empty
Definition XmlStreamer.cxx:16
AthAlgorithm::AthAlgorithm
AthAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition AthAlgorithm.cxx:10
AthCommonAlgorithm< Gaudi::Algorithm >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
AthCommonAlgorithm< Gaudi::Algorithm >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
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
SG::ReadHandleKey
Property holding a SG store/key/clid from which a ReadHandle is made.
Definition StoreGate/StoreGate/ReadHandleKey.h:40
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
TileBeamElemContByteStreamCnv
This AthConstConverter class provides conversion from ByteStream to TileBeamElemContainer.
Definition TileBeamElemContByteStreamCnv.h:48
TileCablingService::C10_connected
static bool C10_connected(int module)
Definition TileCablingService.cxx:1772
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition TileCablingService.cxx:24
TileCalibUtils::MAX_ROS
static const unsigned int MAX_ROS
Number of ROSs.
Definition TileCalibUtils.h:138
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition TileCalibUtils.cxx:145
TileCalibUtils::MAX_GAIN
static const unsigned int MAX_GAIN
Number of gains per channel.
Definition TileCalibUtils.h:142
TileCalibUtils::MAX_DRAWER
static const unsigned int MAX_DRAWER
Number of drawers in ROS 1-4.
Definition TileCalibUtils.h:139
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition TileCalibUtils.cxx:60
TileCalibUtils::MAX_CHAN
static const unsigned int MAX_CHAN
Number of channels in drawer.
Definition TileCalibUtils.h:141
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition TileDQstatus.h:49
TileDQstatus::isAdcDQgood
bool isAdcDQgood(int partition, int drawer, int ch, int gain) const
returns status of single ADC returns False if there are any errors
Definition TileDQstatus.cxx:178
TileDQstatus::isChanDQgood
bool isChanDQgood(int partition, int drawer, int ch) const
returns status of single channel (if bigain, returns AND of ADCs' status
Definition TileDQstatus.cxx:240
TileDQstatus::calibMode
uint32_t calibMode() const
Calibration mode.
Definition TileDQstatus.h:148
TileDQstatus::isChEmpty
static int isChEmpty(int partition, int drawer, int ch)
True if channel is not fully implemented.
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition TileDQstatus.h:152
TileRawChNoiseCalibAlg::m_rc_mean_err
float(* m_rc_mean_err)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:199
TileRawChNoiseCalibAlg::m_rc_av
float(* m_rc_av)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:195
TileRawChNoiseCalibAlg::m_ros
uint8_t(* m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:176
TileRawChNoiseCalibAlg::m_ecell_hash
uint32_t(* m_ecell_hash)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS]
Definition TileRawChNoiseCalibAlg.h:229
TileRawChNoiseCalibAlg::m_rc_probC2
float(* m_rc_probC2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:203
TileRawChNoiseCalibAlg::m_rawChannelContainerMFKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerMFKey
Definition TileRawChNoiseCalibAlg.h:146
TileRawChNoiseCalibAlg::m_side
bool(* m_side)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:221
TileRawChNoiseCalibAlg::m_rc_kurtosis
float(* m_rc_kurtosis)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:198
TileRawChNoiseCalibAlg::m_rc_sigma_err
float(* m_rc_sigma_err)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:200
TileRawChNoiseCalibAlg::m_rc_gsigma2
float(* m_rc_gsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:207
TileRawChNoiseCalibAlg::m_rc_mean
float(* m_rc_mean)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:193
TileRawChNoiseCalibAlg::m_drawer
uint8_t(* m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:177
TileRawChNoiseCalibAlg::m_gerrsigma1
float(* m_gerrsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:238
TileRawChNoiseCalibAlg::finalRawCh
void finalRawCh(int rctype)
finalDigits is called during finalize Here the average Ped, lfn, hfn and covariance are calculated.
Definition TileRawChNoiseCalibAlg.cxx:797
TileRawChNoiseCalibAlg::m_gg
uint8_t(* m_gg)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:225
TileRawChNoiseCalibAlg::m_beamCnv
TileBeamElemContByteStreamCnv * m_beamCnv
Definition TileRawChNoiseCalibAlg.h:115
TileRawChNoiseCalibAlg::m_rc_gerrsigma1
float(* m_rc_gerrsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:210
TileRawChNoiseCalibAlg::NSIDES
static constexpr int NSIDES
Definition TileRawChNoiseCalibAlg.h:50
TileRawChNoiseCalibAlg::m_sample
uint8_t(* m_sample)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:223
TileRawChNoiseCalibAlg::doFit
static void doFit(TH1F *h, float *gp, bool invert=true)
doFit performs the double gaussian fit of the amplitude
Definition TileRawChNoiseCalibAlg.cxx:999
TileRawChNoiseCalibAlg::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition TileRawChNoiseCalibAlg.h:124
TileRawChNoiseCalibAlg::m_tower
uint8_t(* m_tower)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:224
TileRawChNoiseCalibAlg::fillCellHist
void fillCellHist()
fillCellHist is called during execute It fill the HGHG and LGLG combination of the cell energies
Definition TileRawChNoiseCalibAlg.cxx:1105
TileRawChNoiseCalibAlg::m_phi
uint8_t(* m_phi)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:222
TileRawChNoiseCalibAlg::m_gerrnorm
float(* m_gerrnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:240
TileRawChNoiseCalibAlg::m_gain
bool(* m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:179
TileRawChNoiseCalibAlg::fillRawChannels
StatusCode fillRawChannels(const TileDQstatus *dqStatus, const SG::ReadHandleKey< TileRawChannelContainer > &rawChannelContainerKey, RCtype rctype)
Definition TileRawChNoiseCalibAlg.cxx:711
TileRawChNoiseCalibAlg::m_rc_chi2
float(* m_rc_chi2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:201
TileRawChNoiseCalibAlg::m_ecell_ene
float(* m_ecell_ene)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:232
TileRawChNoiseCalibAlg::m_rc_rms
float(* m_rc_rms)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:196
TileRawChNoiseCalibAlg::m_rc_gerrnorm
float(* m_rc_gerrnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:212
TileRawChNoiseCalibAlg::m_rc_gchi2
float(* m_rc_gchi2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:209
TileRawChNoiseCalibAlg::m_rawChannelContainerFixedKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerFixedKey
Definition TileRawChNoiseCalibAlg.h:131
TileRawChNoiseCalibAlg::m_rc_sigma
float(* m_rc_sigma)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:194
TileRawChNoiseCalibAlg::m_rc_gsigma1
float(* m_rc_gsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:206
TileRawChNoiseCalibAlg::execute
virtual StatusCode execute(const EventContext &ctx) override
Main method.
Definition TileRawChNoiseCalibAlg.cxx:317
TileRawChNoiseCalibAlg::m_rawChannelContainerDspKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerDspKey
Definition TileRawChNoiseCalibAlg.h:140
TileRawChNoiseCalibAlg::m_histAmp
TH1F *(* m_histAmp)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:170
TileRawChNoiseCalibAlg::m_tileBadChanTool
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Definition TileRawChNoiseCalibAlg.h:122
TileRawChNoiseCalibAlg::m_rc_ndf
float(* m_rc_ndf)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:202
TileRawChNoiseCalibAlg::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition TileRawChNoiseCalibAlg.h:120
TileRawChNoiseCalibAlg::m_rc_skewness
float(* m_rc_skewness)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:197
TileRawChNoiseCalibAlg::m_gcorrsigma1sigma2
float(* m_gcorrsigma1sigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:241
TileRawChNoiseCalibAlg::m_ecell_av
float(* m_ecell_av)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:227
TileRawChNoiseCalibAlg::m_gsigma1
float(* m_gsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:234
TileRawChNoiseCalibAlg::m_gnorm
float(* m_gnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:236
TileRawChNoiseCalibAlg::m_cabling
const TileCablingService * m_cabling
Definition TileRawChNoiseCalibAlg.h:116
TileRawChNoiseCalibAlg::fillCell
void fillCell(TileRawChannelUnit::UNIT RChUnit, const TileRawChannel *rch)
Definition TileRawChNoiseCalibAlg.cxx:870
TileRawChNoiseCalibAlg::m_ggpar
float(* m_ggpar)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]
Definition TileRawChNoiseCalibAlg.h:233
TileRawChNoiseCalibAlg::m_rc_gnorm
float(* m_rc_gnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:208
TileRawChNoiseCalibAlg::m_rawChannelContainerOptKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerOptKey
Definition TileRawChNoiseCalibAlg.h:137
TileRawChNoiseCalibAlg::m_rawChannelContainerOF1Key
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerOF1Key
Definition TileRawChNoiseCalibAlg.h:143
TileRawChNoiseCalibAlg::FirstEvt_initialize
StatusCode FirstEvt_initialize()
Initialization done at the first event.
Definition TileRawChNoiseCalibAlg.cxx:273
TileRawChNoiseCalibAlg::StoreRunInfo
void StoreRunInfo(const TileDQstatus *dqStatus)
StoreRunInfo is called only during the first event.
Definition TileRawChNoiseCalibAlg.cxx:630
TileRawChNoiseCalibAlg::m_gsigma2
float(* m_gsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:235
TileRawChNoiseCalibAlg::NTOWERS
static constexpr int NTOWERS
Definition TileRawChNoiseCalibAlg.h:52
TileRawChNoiseCalibAlg::m_histCellAmp
TH1F *(* m_histCellAmp)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:171
TileRawChNoiseCalibAlg::m_rc_gcorrsigma1sigma2
float(* m_rc_gcorrsigma1sigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:213
TileRawChNoiseCalibAlg::finalCell
void finalCell()
finalCell is called during finalize Here the cell variables of the ntuple are filled.
Definition TileRawChNoiseCalibAlg.cxx:955
TileRawChNoiseCalibAlg::NSAMPLES
static constexpr int NSAMPLES
Definition TileRawChNoiseCalibAlg.h:51
TileRawChNoiseCalibAlg::m_rawChannelContainerFitKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerFitKey
Definition TileRawChNoiseCalibAlg.h:134
TileRawChNoiseCalibAlg::NCELLGAINS
static constexpr int NCELLGAINS
Definition TileRawChNoiseCalibAlg.h:53
TileRawChNoiseCalibAlg::m_gchi2
float(* m_gchi2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:237
TileRawChNoiseCalibAlg::m_channel
uint8_t(* m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:178
TileRawChNoiseCalibAlg::m_evt
int(* m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:175
TileRawChNoiseCalibAlg::deleteHist
void deleteHist()
deleteHist is called at finalize to ensure that no histogram goes into any output root file delete []...
Definition TileRawChNoiseCalibAlg.cxx:1135
TileRawChNoiseCalibAlg::digiChannel2PMT
int digiChannel2PMT(int ros, int chan)
Definition TileRawChNoiseCalibAlg.h:89
TileRawChNoiseCalibAlg::initialize
virtual StatusCode initialize() override
Only array initialization is done here All the helpers initialization is done at the first event.
Definition TileRawChNoiseCalibAlg.cxx:198
TileRawChNoiseCalibAlg::m_cell_nch
int(* m_cell_nch)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:231
TileRawChNoiseCalibAlg::finalize
virtual StatusCode finalize() override
The output ntuple is created in finalize method.
Definition TileRawChNoiseCalibAlg.cxx:360
TileRawChNoiseCalibAlg::m_gerrsigma2
float(* m_gerrsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:239
TileRawChNoiseCalibAlg::m_rc_ggpar
float(* m_rc_ggpar)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]
Definition TileRawChNoiseCalibAlg.h:205
TileRawChNoiseCalibAlg::m_tileIdTrans
ToolHandle< TileCondIdTransforms > m_tileIdTrans
Definition TileRawChNoiseCalibAlg.h:125
TileRawChNoiseCalibAlg::m_rc_gerrsigma2
float(* m_rc_gerrsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition TileRawChNoiseCalibAlg.h:211
TileRawChNoiseCalibAlg::TileRawChNoiseCalibAlg
TileRawChNoiseCalibAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition TileRawChNoiseCalibAlg.cxx:51
TileRawChNoiseCalibAlg::m_ecell_rms
float(* m_ecell_rms)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:228
TileRawChNoiseCalibAlg::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition TileRawChNoiseCalibAlg.h:129
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition TileRawChannel.h:101
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::IS_CALIBRATION
@ IS_CALIBRATION
true: calibration, false: physics
Definition EventInfo_v1.h:155
doFit
bool doFit
Definition dependence.cxx:57
xmax
double xmax
Definition listroot.cxx:61
fout
static TFile * fout
Definition listroot.cxx:40
xmin
double xmin
Definition listroot.cxx:60
binwidth
bool binwidth
Definition listroot.cxx:58
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:269
index
Definition index.py:1
ClassID_traits::ID
static constexpr CLID ID()
Definition Control/AthenaKernel/AthenaKernel/ClassID_traits.h:44
Generated on for ATLAS Offline Software by doxygen 1.16.1