ATLAS Offline Software
Loading...
Searching...
No Matches
TileRawChNoiseCalibAlg.cxx
Go to the documentation of this file.
1/*
2 Copyright (C) 2002-2022 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
34
35#include "TFile.h"
36#include "TTree.h"
37#include "TH1F.h"
38#include "TF1.h"
39#include "TFitResult.h"
40#include "TFitResultPtr.h"
41#include "TMatrixDSym.h"
42#include "TGraphErrors.h"
43#include "TClonesArray.h"
44
45#include <cmath>
46#include <ctime>
47#include <iostream>
48
49
50TileRawChNoiseCalibAlg::TileRawChNoiseCalibAlg(const std::string& name, ISvcLocator* pSvcLocator)
51 : AthAlgorithm(name,pSvcLocator)
52 , m_beamCnv(nullptr)
53 , m_cabling(nullptr)
54 , m_tileID(nullptr)
55 , m_tileHWID(nullptr)
56 , m_cispar(nullptr)
57 //, m_nDrawers(0)
58 , m_time(0)
59 , m_year(0)
60 , m_month(0)
61 , m_day(0)
62 , m_yday(0)
63 , m_hour(0)
64 , m_min(0)
65 , m_run(0)
66 , m_trigType(0)
67{
68
69 declareProperty("TileDigitsContainer", m_digitsContainer = "TileDigitsCnt");
70 declareProperty("TileBeamElemContainer", m_beamElemContainer = "TileBeamElemCnt");
71 declareProperty("doFit" , m_doFit = true);
72 declareProperty("doFixed", m_doFixed = true);
73 declareProperty("doOpt" , m_doOpt = true);
74 declareProperty("doDsp" , m_doDsp = true);
75 declareProperty("doOF1" , m_doOF1 = true);
76 declareProperty("doMF" , m_doMF = true);
77 declareProperty("SaveHist", m_saveHist = false); // write all histograms to output file
78 declareProperty("InvertChanRatio", m_invertChanRatio = true); // swap two sigmas and invert ratio if it is above 1.0 (channel fit only)
79 declareProperty("MaskBadChannels",m_maskBadChannels = true);
80 declareProperty("UseforCells" , m_UseforCells = 2); // Fit=0, Fixed=1, Opt=2, Dsp=3, OF1=4, MF=5
81 declareProperty("CalibMode", m_calibMode = true);
82 declareProperty("UsePMT", m_usePMT = false);
83 declareProperty("RunNumber", m_run=0);
84 declareProperty("FileNamePrefix", m_file="RawCh_NoiseCalib");
85 declareProperty("NtupleID", m_ntupleID="RawCh_NoiseCalib");
86 declareProperty("TreeSize", m_treeSize = 16000000000LL);
87 declareProperty("TileDQstatus", m_dqStatusKey = "TileDQstatus");
88
89 m_evtNr=-1;
90
91 m_fillidx=false;
92
93 m_histAmp = new TH1F*[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
94 m_histCellAmp = new TH1F*[2][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
95 m_evt = new int[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
96 m_ros = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
97 m_drawer = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
98 m_channel = new uint8_t[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
99 m_gain = new bool[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
100 m_rc_mean = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
101 m_rc_sigma = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
102 m_rc_av = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
103 m_rc_rms = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
104 m_rc_skewness = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
105 m_rc_kurtosis = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
106 m_rc_mean_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
107 m_rc_sigma_err = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
108 m_rc_chi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
109 m_rc_ndf = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
110 m_rc_probC2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
111 m_rc_ggpar = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]();
112 m_rc_gsigma1 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
113 m_rc_gsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
114 m_rc_gnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
115 m_rc_gchi2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
116 m_rc_gerrsigma1= new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
117 m_rc_gerrsigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
118 m_rc_gerrnorm = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
119 m_rc_gcorrsigma1sigma2 = new float[RCnum][Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]();
120
121 m_side = new bool[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
122 m_phi = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
123 m_sample = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
124 m_tower = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
125 m_gg = new uint8_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
126 m_ecell_av = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
127 m_ecell_rms= new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
128 m_ecell_hash= new uint32_t[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS]();
129
130 m_cell_nch = new int[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
131 m_ecell_ene = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]();
132 m_ggpar = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]();
133 m_gsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
134 m_gsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
135 m_gnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
136 m_gchi2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
137 m_gerrsigma1 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
138 m_gerrsigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
139 m_gerrnorm = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
140 m_gcorrsigma1sigma2 = new float[NSIDES][Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]();
141}
142
143TileRawChNoiseCalibAlg::~TileRawChNoiseCalibAlg()
144{
145 delete[] m_histAmp;
146 delete[] m_histCellAmp;
147 delete[] m_evt;
148 delete[] m_ros;
149 delete[] m_drawer;
150 delete[] m_channel;
151 delete[] m_gain;
152 delete[] m_rc_mean;
153 delete[] m_rc_sigma;
154 delete[] m_rc_av;
155 delete[] m_rc_rms;
156 delete[] m_rc_skewness;
157 delete[] m_rc_kurtosis;
158 delete[] m_rc_mean_err;
159 delete[] m_rc_sigma_err;
160 delete[] m_rc_chi2;
161 delete[] m_rc_ndf;
162 delete[] m_rc_probC2;
163 delete[] m_rc_ggpar;
164 delete[] m_rc_gsigma1;
165 delete[] m_rc_gsigma2;
166 delete[] m_rc_gnorm;
167 delete[] m_rc_gchi2;
168 delete[] m_rc_gerrsigma1;
169 delete[] m_rc_gerrsigma2;
170 delete[] m_rc_gerrnorm;
171 delete[] m_rc_gcorrsigma1sigma2;
172
173 delete[] m_side;
174 delete[] m_phi;
175 delete[] m_sample;
176 delete[] m_tower;
177 delete[] m_gg;
178 delete[] m_ecell_av;
179 delete[] m_ecell_rms;
180 delete[] m_ecell_hash;
181
182 delete[] m_cell_nch;
183 delete[] m_ecell_ene;
184 delete[] m_ggpar;
185 delete[] m_gsigma1;
186 delete[] m_gsigma2;
187 delete[] m_gnorm;
188 delete[] m_gchi2;
189 delete[] m_gerrsigma1;
190 delete[] m_gerrsigma2;
191 delete[] m_gerrnorm;
192 delete[] m_gcorrsigma1sigma2;
193}
194
197StatusCode TileRawChNoiseCalibAlg::initialize() {
198
199 int nbin = 151;
200 float binwidth[2] = { 0.125, 0.25 }; // in ADC
201 float xmax[2] = { (float) nbin * binwidth[0] / 2.F, (float) nbin * binwidth[1] / 2.F }; // in ADC
202
203 std::ostringstream sStr;
204 std::string nam;
205
206 for (int rc = 0; rc < RCnum; ++rc) {
207 for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
208 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
209 for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
210 for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
211 sStr.str("");
212 sStr << "Amplitudes_RC_" << rc << "_Part_" << ros << "_Drawer_" << drawer << "_Ch_" << ch << "_Gain_" << g;
213 nam = sStr.str();
214 m_histAmp[rc][ros][drawer][ch][g] = new TH1F(nam.c_str(), nam.c_str(), nbin, -xmax[g], xmax[g]);
215 m_histAmp[rc][ros][drawer][ch][g]->SetCanExtend(TH1::kAllAxes); //in case some entries are outside the initial limits
216 m_histAmp[rc][ros][drawer][ch][g]->SetDirectory(nullptr);
217 }
218 }
219 }
220 }
221 }
222
223 nbin = 301;
224 float cellbin[2] = { 80., 2.5 }; //in MeV
225 float xcellmax[2] = { (float) nbin * cellbin[0] / 2.F, (float) nbin * cellbin[1] / 2.F }; //in MeV
226
227 for (int side = 0; side < NSIDES; side++) {
228 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
229 for (int sample = 0; sample < NSAMPLES; sample++) {
230 for (int tower = 0; tower < NTOWERS; tower++) {
231 for (int gg = 0; gg < NCELLGAINS; gg++) {
232 sStr.str("");
233 sStr << "CellAmplitude_Side_" << side << "_Drawer_" << drawer << "_Sample_" << sample << "_Tower_" << tower << "_Gains_" << gg;
234 nam = sStr.str();
235 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
236 m_histCellAmp[side][drawer][sample][tower][gg]->SetCanExtend(TH1::kAllAxes); //in case some entries are outside the initial limits
237 m_histCellAmp[side][drawer][sample][tower][gg]->SetDirectory(nullptr);
238 }
239 }
240 }
241 }
242 }
243
244
245 //=== get TileCondToolEmscale
246 CHECK( m_tileToolEmscale.retrieve() );
247
248 //=== get TileBadChanTool
249 CHECK( m_tileBadChanTool.retrieve() );
250
251 //=== get TileCondIdTransforms
252 CHECK( m_tileIdTrans.retrieve() );
253
254 CHECK( m_dqStatusKey.initialize() );
255
256 ATH_CHECK( m_rawChannelContainerFitKey.initialize(m_doFit) );
257 ATH_CHECK( m_rawChannelContainerFixedKey.initialize(m_doFixed) );
258 ATH_CHECK( m_rawChannelContainerOptKey.initialize(m_doOpt) );
259 ATH_CHECK( m_rawChannelContainerDspKey.initialize(m_doDsp) );
260 ATH_CHECK( m_rawChannelContainerOF1Key.initialize(m_doOF1) );
261 ATH_CHECK( m_rawChannelContainerMFKey.initialize(m_doMF) );
262
263 if (!m_eventInfoKey.key().empty()) {
264 ATH_CHECK( m_eventInfoKey.initialize() );
265 }
266
267 return StatusCode::SUCCESS;
268}
269
272StatusCode TileRawChNoiseCalibAlg::FirstEvt_initialize() {
273
274
275 // find TileCablingService
276 m_cabling = TileCablingService::getInstance();
277
278 // retrieve TileID helper from det store
279 CHECK( detStore()->retrieve(m_tileID) );
280
281 CHECK( detStore()->retrieve(m_tileHWID) );
282
283 ATH_MSG_INFO( "calibMode " << m_calibMode );
284
285
286 // set event number to 0 before first event
287
288 if ( m_evtNr < 0 ) {
289 m_evtNr = 0;
290 if (m_beamElemContainer.length() > 0) {
291 ServiceHandle<IConversionSvc> cnvSvc("ByteStreamCnvSvc","");
292 if (cnvSvc.retrieve().isFailure()) {
293 ATH_MSG_ERROR( " Can't get ByteStreamCnvSvc " );
294 m_beamCnv = nullptr;
295
296 } else {
297
298 m_beamCnv = dynamic_cast<TileBeamElemContByteStreamCnv *> ( cnvSvc->converter( ClassID_traits<TileBeamElemContainer>::ID() ) );
299
300 if ( m_beamCnv == nullptr ) {
301 ATH_MSG_ERROR( " Can't get TileBeamElemContByteStreamCnv " );
302 }
303 }
304 } else {
305 m_beamCnv = nullptr;
306 }
307 }
308
309 ATH_MSG_INFO( "initialization completed" );
310
311 return StatusCode::SUCCESS;
312
313}
314
316StatusCode TileRawChNoiseCalibAlg::execute() {
317
318 const EventContext& ctx = Gaudi::Hive::currentContext();
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 TF1 * fit_gaus = new TF1("g", "gaus");
801
802 for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
803 ATH_MSG_INFO( "Fitting RCh container " << rctype << " ROS " << ros );
804
805 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
806 for (unsigned int gain = 0; gain < TileCalibUtils::MAX_GAIN; ++gain) {
807 for (unsigned int chan = 0; chan < TileCalibUtils::MAX_CHAN; ++chan) {
808
809 if (!m_fillidx) {
810 m_fillidx = true;
811 m_ros[ros][drawer][chan][gain] = ros;
812 m_drawer[ros][drawer][chan][gain] = drawer;
813 m_channel[ros][drawer][chan][gain] = chan;
814 m_gain[ros][drawer][chan][gain] = gain;
815 }
816
817 if (m_evt[ros][drawer][chan][gain] > 0) {
818
819 m_histAmp[rctype][ros][drawer][chan][gain]->Fit("g", "NQ");
820
821 m_rc_av[rctype][ros][drawer][chan][gain] = m_histAmp[rctype][ros][drawer][chan][gain]->GetMean();
822 m_rc_rms[rctype][ros][drawer][chan][gain] = m_histAmp[rctype][ros][drawer][chan][gain]->GetRMS();
823
824 if (TMath::Abs(m_histAmp[rctype][ros][drawer][chan][gain]->GetSkewness()) < 1000.)
825 m_rc_skewness[rctype][ros][drawer][chan][gain] = m_histAmp[rctype][ros][drawer][chan][gain]->GetSkewness();
826 if (TMath::Abs(m_histAmp[rctype][ros][drawer][chan][gain]->GetKurtosis()) < 1000.)
827 m_rc_kurtosis[rctype][ros][drawer][chan][gain] = m_histAmp[rctype][ros][drawer][chan][gain]->GetKurtosis();
828
829 m_rc_mean[rctype][ros][drawer][chan][gain] = fit_gaus->GetParameter(1);
830 m_rc_mean_err[rctype][ros][drawer][chan][gain] = fit_gaus->GetParError(1);
831 m_rc_sigma[rctype][ros][drawer][chan][gain] = fit_gaus->GetParameter(2);
832 m_rc_sigma_err[rctype][ros][drawer][chan][gain] = fit_gaus->GetParError(2);
833 m_rc_chi2[rctype][ros][drawer][chan][gain] = fit_gaus->GetChisquare();
834 m_rc_ndf[rctype][ros][drawer][chan][gain] = fit_gaus->GetNDF();
835 m_rc_probC2[rctype][ros][drawer][chan][gain] = fit_gaus->GetProb();
836
837 doFit(m_histAmp[rctype][ros][drawer][chan][gain], m_rc_ggpar[rctype][ros][drawer][chan][gain], m_invertChanRatio);
838
839 m_rc_gsigma1[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][0];
840 m_rc_gsigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][2];
841 m_rc_gnorm[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][1];
842 m_rc_gchi2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][3];
843 m_rc_gerrsigma1[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][4];
844 m_rc_gerrnorm[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][5];
845 m_rc_gerrsigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][6];
846 m_rc_gcorrsigma1sigma2[rctype][ros][drawer][chan][gain] = m_rc_ggpar[rctype][ros][drawer][chan][gain][7];
847
848 } // end if evt>0
849
850 }
851 }
852 }
853 } // end if ros
854
855 delete fit_gaus;
856
857}
858
859
860// fillCell is called at every events.
861// Statistics is summed for Average, RMS calculations
862/*---------------------------------------------------------*/
863void TileRawChNoiseCalibAlg::fillCell(TileRawChannelUnit::UNIT RChUnit, const TileRawChannel * rch) {
864 /*---------------------------------------------------------*/
865
866 int index, pmt;
867 Identifier cell_id = rch->cell_ID_index(index, pmt);
868 if (index > -1) { //disconnect channel index is -1/ MBTS cell index is -2 and they don't have an idhash
869 unsigned int ros(0), drawer(0), channel(0), gain(0);
870 m_tileIdTrans->getIndices(rch->adc_HWID(), ros, drawer, channel, gain);
871 unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
872
873 if (m_maskBadChannels && m_tileBadChanTool->getAdcStatus(drawerIdx, channel, gain).isBad()) {
874 ATH_MSG_VERBOSE( "Skipping Module: " << TileCalibUtils::getDrawerString(ros, drawer)
875 << " channel: " << channel
876 << " ADC: " << gain
877 << " in fillCell() because channel is bad in DB." );
878 return;
879 }
880
881 int sample = m_tileID->sample(cell_id);
882 int tower = m_tileID->tower(cell_id);
883 int side = m_tileID->side(cell_id);
884
885 if (side == 1) side = 0; //A side
886 else if (side == -1) side = 1; //C side
887 else side = 0; //D0 cell? we put it in LBA
888
889 if (m_evtNr < 1) { //first event
890 m_ecell_hash[side][drawer][sample][tower] = m_tileID->cell_hash(cell_id);
891 }
892
893 int g, gg;
894 if (gain == 0) {
895 gg = 0;
896 if (pmt == 0) g = 1; //in most cases even channels on side A AND odd channels on side C
897 else g = 2; //are the first channels of the cells
898 } else {
899 gg = 3;
900 if (pmt == 0) g = 4; //pmt tells us which is the first and second channel of the cells!!
901 else g = 5;
902 }
903
904 //not needed anymore if (channel==0 && ros==2) g++; //D0 second channel is special : move from first to second channel
905
906 double amp = rch->amplitude();
907 amp = m_tileToolEmscale->channelCalib(drawerIdx, channel, gain, amp, RChUnit, TileRawChannelUnit::MegaElectronVolts);
908 int nch = 1;
909
910 if (m_cabling->isRun2PlusCabling() && (ros > 2)) { // Ext.barrel modules
911
912 if (channel == E1_CHANNEL) { // Raw channel -> E1 cell.
913 int drawer2 = m_cabling->E1_merged_with_run2plus(ros, drawer);
914 if (drawer2 != 0) { // Raw channel splitted into two E1 cells for Run 2.
915 amp /= 2.0F;
916 m_ecell_ene[side][drawer2][sample][tower][gg / 3] += amp;
917 ++m_cell_nch[side][drawer2][sample][tower][gg / 3];
918
919 if (TMath::Abs(amp) > 1.e-5) {
920 m_histCellAmp[side][drawer2][sample][tower][g]->Fill(amp);
921 }
922 }
923
924 } else if (!TileCablingService::C10_connected(drawer)) { // modules with special C10
925 if (channel == OUTER_MBTS_CHANNEL) {
926 amp = 0.0; // ignore MBTS completely
927 nch = 0;
928 } else if (channel == SPECIAL_C10_CHANNEL) {
929 nch = 2; // count this channel twice - needed for correct bad-channel masking
930 }
931 }
932 }
933
934 m_ecell_ene[side][drawer][sample][tower][gg / 3] += amp;
935 m_cell_nch[side][drawer][sample][tower][gg / 3] += nch;
936
937 if (TMath::Abs(amp) > 1.e-5) {
938 m_histCellAmp[side][drawer][sample][tower][g]->Fill(amp);
939 }
940
941 } // is a connected channel
942}
943
944
947/*---------------------------------------------------------*/
948void TileRawChNoiseCalibAlg::finalCell() {
949 /*---------------------------------------------------------*/
950
951 for (int side = 0; side < 2; ++side) {
952 ATH_MSG_INFO( "Fitting cells side " << side );
953 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
954 for (int sample = 0; sample < 4; ++sample) {
955 for (int tower = 0; tower < 17; ++tower) {
956 for (int gg = 0; gg < 6; ++gg) {
957
958 m_side[side][drawer][sample][tower][gg] = side;
959 m_phi[side][drawer][sample][tower][gg] = drawer;
960 m_sample[side][drawer][sample][tower][gg] = sample;
961 m_tower[side][drawer][sample][tower][gg] = tower;
962 m_gg[side][drawer][sample][tower][gg] = gg;
963
964 if (m_histCellAmp[side][drawer][sample][tower][gg]->GetEntries() > 0) {
965
966 m_ecell_av[side][drawer][sample][tower][gg] = m_histCellAmp[side][drawer][sample][tower][gg]->GetMean();
967 m_ecell_rms[side][drawer][sample][tower][gg] = m_histCellAmp[side][drawer][sample][tower][gg]->GetRMS();
968 doFit(m_histCellAmp[side][drawer][sample][tower][gg], m_ggpar[side][drawer][sample][tower][gg]);
969 m_gsigma1[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][0];
970 m_gsigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][2];
971 m_gnorm[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][1];
972 m_gchi2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][3];
973 m_gerrsigma1[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][4];
974 m_gerrnorm[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][5];
975 m_gerrsigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][6];
976 m_gcorrsigma1sigma2[side][drawer][sample][tower][gg] = m_ggpar[side][drawer][sample][tower][gg][7];
977// gcorrsigma1norm[side][drawer][sample][tower][gg]=m_ggpar[side][drawer][sample][tower][gg][8];
978// gcorrsigma2norm[side][drawer][sample][tower][gg]=m_ggpar[side][drawer][sample][tower][gg][9];
979
980 }
981
982 }
983 }
984 }
985 }
986 }
987
988}
989
991/*---------------------------------------------------------*/
992void TileRawChNoiseCalibAlg::doFit(TH1F* h, float* gp, bool invert) {
993/*---------------------------------------------------------*/
994 Double_t par[6];
995
996 float xmin = h->GetBinCenter(1);
997 float xmax = h->GetBinCenter(h->GetNbinsX());
998 TF1* total = new TF1("total", "gaus(0)+gaus(3)", xmin, xmax);
999 total->SetLineColor(2);
1000
1001 float nentries = h->GetEntries();
1002 float rms = h->GetRMS();
1003 float bin = h->GetBinWidth(0);
1004
1005 par[0] = 0.1 * nentries;
1006 par[1] = 0.;
1007 par[2] = 0.7 * std::max(rms, bin);
1008
1009 par[3] = 0.15 * par[0];
1010 par[4] = 0.;
1011 par[5] = 5. * par[2];
1012
1013 total->SetParameters(par);
1014
1015 float lim1 = bin / 2.;
1016 float lim2 = std::max(rms * 1.05, bin * 2.0);
1017 float lim3 = std::max(rms * 10.0, bin * 20.);
1018
1019 float limN1 = nentries;
1020 if (lim1 < 0.5) limN1 /= (2. * lim1); // a bit more than Nentries / ( sqrt(2*pi) * sigma1 )
1021 float limN2 = nentries;
1022 if (lim2 < 0.5) limN2 /= (2. * lim2); // a bit more than Nentries / ( sqrt(2*pi) * sigma2 )
1023
1024 total->SetParLimits(0, 0., limN1);
1025 total->FixParameter(1, 0.);
1026 total->SetParLimits(2, lim1, lim2);
1027 total->SetParLimits(3, 0., limN2);
1028 total->FixParameter(4, 0.);
1029 total->SetParLimits(5, lim2, lim3);
1030
1031 TFitResultPtr resfit = h->Fit(total, "BLQRS");
1032
1033 float par0 = total->GetParameter(0);
1034 float par3 = total->GetParameter(3);
1035
1036 float sigma1 = total->GetParameter(2); //sigma gauss1
1037 float sigma2 = total->GetParameter(5); //sigma gauss1
1038
1039 //Get errors
1040 float errpar0 = total->GetParError(0);
1041 float errpar3 = total->GetParError(3);
1042
1043 float errsigma1 = total->GetParError(2);
1044 float errsigma2 = total->GetParError(5);
1045
1046 float norm = par3 / par0; //rel normalization of the gaussians
1047
1048 if (invert && norm > 1.) { //invert the 2 gaussians if normalization is greater than 1
1049
1050 gp[0] = sigma2;
1051 gp[1] = 1. / norm;
1052 gp[2] = sigma1;
1053
1054 gp[4] = errsigma2;
1055 gp[5] = sqrt((errpar0 * errpar0) + (errpar3 * errpar3) * (par0 * par0) / (par3 * par3)) / par3;
1056 gp[6] = errsigma1;
1057
1058 } else {
1059
1060 gp[0] = sigma1;
1061 gp[1] = norm;
1062 gp[2] = sigma2;
1063
1064 gp[4] = errsigma1;
1065 gp[5] = sqrt((errpar3 * errpar3) + (errpar0 * errpar0) * (par3 * par3) / (par0 * par0)) / par0;
1066 gp[6] = errsigma2;
1067
1068 }
1069
1070 if (total->GetNDF() > 0) {
1071 gp[3] = total->GetChisquare() / total->GetNDF(); //chi2/ndf
1072 } else {
1073 gp[3] = 0.;
1074 }
1075
1076 // Get correlation sigma1, sigma2
1077 TMatrixDSym corr = resfit->GetCorrelationMatrix();
1078 gp[7] = corr(2, 5);
1079
1080 delete total;
1081}
1082
1083
1086/*---------------------------------------------------------*/
1087void TileRawChNoiseCalibAlg::fillCellHist() {
1088/*---------------------------------------------------------*/
1089
1090 for (int side = 0; side < 2; ++side) {
1091 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
1092 for (int sample = 0; sample < 4; ++sample) {
1093 for (int tower = 0; tower < 17; ++tower) {
1094 for (unsigned int gg = 0; gg < TileCalibUtils::MAX_GAIN; ++gg) {
1095
1096 float ene = m_ecell_ene[side][drawer][sample][tower][gg];
1097 if (m_cell_nch[side][drawer][sample][tower][gg] == 1 && sample != 3) ene *= 2; // one good channel in normal cell - multiply energy by 2
1098
1099 if (TMath::Abs(ene) > 1.e-5) {
1100 m_histCellAmp[side][drawer][sample][tower][gg * 3]->Fill(ene);
1101 }
1102
1103 }
1104 }
1105 }
1106 }
1107 }
1108
1109}
1110
1111
1112
1116/*---------------------------------------------------------*/
1117void TileRawChNoiseCalibAlg::deleteHist() {
1118/*---------------------------------------------------------*/
1119
1120 for (int rc = 0; rc < RCnum; ++rc) {
1121 for (unsigned int ros = 1; ros < TileCalibUtils::MAX_ROS; ++ros) {
1122 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
1123
1124 for (unsigned int ch = 0; ch < TileCalibUtils::MAX_CHAN; ++ch) {
1125 for (unsigned int g = 0; g < TileCalibUtils::MAX_GAIN; ++g) {
1126 delete m_histAmp[rc][ros][drawer][ch][g];
1127 }
1128 }
1129 }
1130 }
1131 }
1132
1133 for (int side = 0; side < 2; side++) {
1134 for (unsigned int drawer = 0; drawer < TileCalibUtils::MAX_DRAWER; ++drawer) {
1135 for (int sample = 0; sample < 4; ++sample) {
1136 for (int tower = 0; tower < 17; ++tower) {
1137 for (int gg = 0; gg < 6; gg++) {
1138 delete m_histCellAmp[side][drawer][sample][tower][gg];
1139 }
1140 }
1141 }
1142 }
1143 }
1144
1145}
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
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 with parameters:
Definition AthAlgorithm.cxx:24
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition AthCommonDataStore.h:145
AthCommonDataStore< AthCommonMsg< 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:80
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:992
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:1087
TileRawChNoiseCalibAlg::m_phi
uint8_t(* m_phi)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition TileRawChNoiseCalibAlg.h:222
TileRawChNoiseCalibAlg::execute
virtual StatusCode execute() override
Main method.
Definition TileRawChNoiseCalibAlg.cxx:316
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::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:863
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:272
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:948
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:1117
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:197
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:50
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:270
index
Definition index.py:1
ClassID_traits::ID
static CLID ID()
Definition Control/AthenaKernel/AthenaKernel/ClassID_traits.h:44
Generated on for ATLAS Offline Software by doxygen 1.14.0