ATLAS Offline Software
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 
50 TileRawChNoiseCalibAlg::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 
143 TileRawChNoiseCalibAlg::~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 
197 StatusCode 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 
272 StatusCode 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 
316 StatusCode 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 
360 StatusCode 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 
630 void 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 /*---------------------------------------------------------*/
711 StatusCode 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 /*---------------------------------------------------------*/
797 void 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 /*---------------------------------------------------------*/
863 void 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 /*---------------------------------------------------------*/
948 void 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 /*---------------------------------------------------------*/
992 void 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 /*---------------------------------------------------------*/
1087 void 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 /*---------------------------------------------------------*/
1117 void 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 }
TileBeamElemContByteStreamCnv::validBeamFrag
bool validBeamFrag() const
Definition: TileBeamElemContByteStreamCnv.h:67
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
TileRawChNoiseCalibAlg::m_usePMT
bool m_usePMT
Definition: TileRawChNoiseCalibAlg.h:110
TileRawChNoiseCalibAlg::m_rawChannelContainerDspKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerDspKey
Definition: TileRawChNoiseCalibAlg.h:140
TileRawChNoiseCalibAlg::NSIDES
static constexpr int NSIDES
Definition: TileRawChNoiseCalibAlg.h:50
TileRawChNoiseCalibAlg::m_fillidx
bool m_fillidx
Definition: TileRawChNoiseCalibAlg.h:112
TileRawChNoiseCalibAlg::m_rc_gsigma2
float(* m_rc_gsigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:207
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
DataModel_detail::const_iterator
Const iterator class for DataVector/DataList.
Definition: DVLIterator.h:82
sendEI_SPB.ch
ch
Definition: sendEI_SPB.py:35
TileRawChNoiseCalibAlg::m_ecell_rms
float(* m_ecell_rms)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:228
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_month
int m_month
Definition: TileRawChNoiseCalibAlg.h:183
TileRawChNoiseCalibAlg::m_gerrsigma2
float(* m_gerrsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:239
TileRawChNoiseCalibAlg::m_histCellAmp
TH1F *(* m_histCellAmp)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:171
TileRawChNoiseCalibAlg::m_maskBadChannels
bool m_maskBadChannels
Definition: TileRawChNoiseCalibAlg.h:107
TileRawChNoiseCalibAlg::m_gsigma2
float(* m_gsigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:235
max
#define max(a, b)
Definition: cfImp.cxx:41
TileRawChNoiseCalibAlg::m_digitsContainer
std::string m_digitsContainer
Definition: TileRawChNoiseCalibAlg.h:159
plotting.yearwise_efficiency.channel
channel
Definition: yearwise_efficiency.py:28
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_rc_sigma
float(* m_rc_sigma)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:194
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:575
TileCablingService::getInstance
static const TileCablingService * getInstance()
get pointer to service instance
Definition: TileCablingService.cxx:24
TileRawChNoiseCalibAlg::m_doOpt
bool m_doOpt
Definition: TileRawChNoiseCalibAlg.h:98
TileRawChNoiseCalibAlg::Fit
@ Fit
Definition: TileRawChNoiseCalibAlg.h:68
cellbin
Definition: CellClusterLinkTool.h:36
xAOD::uint32_t
setEventNumber uint32_t
Definition: EventInfo_v1.cxx:127
TileRawChNoiseCalibAlg::m_UseforCells
int m_UseforCells
Definition: TileRawChNoiseCalibAlg.h:105
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
TileRawChNoiseCalibAlg::m_doDsp
bool m_doDsp
Definition: TileRawChNoiseCalibAlg.h:99
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
index
Definition: index.py:1
TileRawChNoiseCalibAlg::m_gcorrsigma1sigma2
float(* m_gcorrsigma1sigma2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:241
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
TileRawChNoiseCalibAlg::m_beamElemContainer
std::string m_beamElemContainer
Definition: TileRawChNoiseCalibAlg.h:160
TileRawChNoiseCalibAlg::m_cispar
const uint32_t * m_cispar
Definition: TileRawChNoiseCalibAlg.h:127
TileRawChNoiseCalibAlg::OUTER_MBTS_CHANNEL
@ OUTER_MBTS_CHANNEL
Definition: TileRawChNoiseCalibAlg.h:243
ReadBchFromCool.pmt
pmt
Definition: ReadBchFromCool.py:62
TileRawChNoiseCalibAlg::StoreRunInfo
void StoreRunInfo(const TileDQstatus *dqStatus)
StoreRunInfo is called only during the first event.
Definition: TileRawChNoiseCalibAlg.cxx:630
TileRawChNoiseCalibAlg::m_tileBadChanTool
ToolHandle< ITileBadChanTool > m_tileBadChanTool
Definition: TileRawChNoiseCalibAlg.h:122
binwidth
bool binwidth
Definition: listroot.cxx:58
TileRawChNoiseCalibAlg::m_calibMode
bool m_calibMode
Definition: TileRawChNoiseCalibAlg.h:94
TileDQstatus::calibMode
uint32_t calibMode() const
Calibration mode.
Definition: TileDQstatus.h:148
TileRawChNoiseCalibAlg::m_beamCnv
TileBeamElemContByteStreamCnv * m_beamCnv
Definition: TileRawChNoiseCalibAlg.h:115
TileRawChNoiseCalibAlg::E1_CHANNEL
@ E1_CHANNEL
Definition: TileRawChNoiseCalibAlg.h:243
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
xAOD::EventInfo_v1::IS_CALIBRATION
@ IS_CALIBRATION
true: calibration, false: physics
Definition: EventInfo_v1.h:155
Tile_Base_ID::side
int side(const Identifier &id) const
Definition: Tile_Base_ID.cxx:153
TileRawChNoiseCalibAlg::m_drawer
uint8_t(* m_drawer)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:177
TileRawChNoiseCalibAlg::NPARS
static constexpr int NPARS
Definition: TileRawChNoiseCalibAlg.h:54
TileBeamElemContByteStreamCnv::robFragment
const eformat::ROBFragment< const uint32_t * > * robFragment() const
Definition: TileBeamElemContByteStreamCnv.h:66
Tile_Base_ID::sample
int sample(const Identifier &id) const
Definition: Tile_Base_ID.cxx:171
bin
Definition: BinsDiffFromStripMedian.h:43
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::m_side
bool(* m_side)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:221
TileRawChNoiseCalibAlg::Dsp
@ Dsp
Definition: TileRawChNoiseCalibAlg.h:68
TileRawChNoiseCalibAlg::m_tileID
const TileID * m_tileID
Definition: TileRawChNoiseCalibAlg.h:118
TileRawChNoiseCalibAlg::m_gchi2
float(* m_gchi2)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:237
TileRawChNoiseCalibAlg::finalize
virtual StatusCode finalize() override
The output ntuple is created in finalize method.
Definition: TileRawChNoiseCalibAlg.cxx:360
TileCalibUtils.h
TileRawChNoiseCalibAlg::m_gerrsigma1
float(* m_gerrsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:238
TileRawChannelUnit::OnlineADCcounts
@ OnlineADCcounts
Definition: TileRawChannelUnit.h:21
Tile_Base_ID::tower
int tower(const Identifier &id) const
Definition: Tile_Base_ID.cxx:165
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::OF1
@ OF1
Definition: TileRawChNoiseCalibAlg.h:68
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
TileRawChNoiseCalibAlg::m_time
int m_time
Definition: TileRawChNoiseCalibAlg.h:181
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
TileRawChNoiseCalibAlg::m_gsigma1
float(* m_gsigma1)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:234
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
SG::ReadHandleKey< TileRawChannelContainer >
TileRawChNoiseCalibAlg::m_run
int m_run
Definition: TileRawChNoiseCalibAlg.h:188
TileRawChNoiseCalibAlg::m_year
int m_year
Definition: TileRawChNoiseCalibAlg.h:182
TileRawData::adc_HWID
HWIdentifier adc_HWID(void) const
Definition: TileRawData.h:53
HWIdentifier
Definition: HWIdentifier.h:13
TileRawChNoiseCalibAlg::m_rawChannelContainerOF1Key
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerOF1Key
Definition: TileRawChNoiseCalibAlg.h:143
TileDQstatus::isChEmpty
static int isChEmpty(int partition, int drawer, int ch)
True if channel is not fully implemented.
empty
bool empty(TH1 *h)
Definition: computils.cxx:294
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::fillCell
void fillCell(TileRawChannelUnit::UNIT RChUnit, const TileRawChannel *rch)
Definition: TileRawChNoiseCalibAlg.cxx:863
Example_ReadSampleNoise.drawer
drawer
Definition: Example_ReadSampleNoise.py:39
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
TileRawChNoiseCalibAlg::Ped
@ Ped
Definition: TileRawChNoiseCalibAlg.h:72
TileID.h
TileRawChNoiseCalibAlg::m_cell_nch
int(* m_cell_nch)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:231
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
TileCalibUtils::MAX_DRAWER
static const unsigned int MAX_DRAWER
Number of drawers in ROS 1-4.
Definition: TileCalibUtils.h:139
TileRawChNoiseCalibAlg::NTOWERS
static constexpr int NTOWERS
Definition: TileRawChNoiseCalibAlg.h:52
TileRawChNoiseCalibAlg::m_ecell_av
float(* m_ecell_av)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:227
TileRawChNoiseCalibAlg::m_rc_gnorm
float(* m_rc_gnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:208
TRT::Hit::side
@ side
Definition: HitInfo.h:83
TileRawChNoiseCalibAlg::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Definition: TileRawChNoiseCalibAlg.h:129
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:269
TileRawChannelContainer.h
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_treeSize
int64_t m_treeSize
Definition: TileRawChNoiseCalibAlg.h:155
TileRawChNoiseCalibAlg::m_ntupleID
std::string m_ntupleID
Definition: TileRawChNoiseCalibAlg.h:153
TileDQstatus
Class that holds Data Quality fragment information and provides functions to extract the data quality...
Definition: TileDQstatus.h:49
TileCablingService::isRun2PlusCabling
bool isRun2PlusCabling() const
Definition: TileCablingService.h:278
PlotCalibFromCool.nentries
nentries
Definition: PlotCalibFromCool.py:798
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
TileRawChannel::amplitude
float amplitude(int ind=0) const
Definition: TileRawChannel.h:101
TileHWID.h
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
TileRawChNoiseCalibAlg::m_rawChannelContainerMFKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerMFKey
Definition: TileRawChNoiseCalibAlg.h:146
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
FullCPAlgorithmsTest_eljob.sample
sample
Definition: FullCPAlgorithmsTest_eljob.py:100
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
TileRawChNoiseCalibAlg::m_hour
int m_hour
Definition: TileRawChNoiseCalibAlg.h:186
xmin
double xmin
Definition: listroot.cxx:60
TileRawChNoiseCalibAlg::m_rawChannelContainerOptKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerOptKey
Definition: TileRawChNoiseCalibAlg.h:137
ReadCellNoiseFromCool.chan
chan
Definition: ReadCellNoiseFromCool.py:52
TileRawChNoiseCalibAlg::MF
@ MF
Definition: TileRawChNoiseCalibAlg.h:68
TileRawChNoiseCalibAlg::m_tileIdTrans
ToolHandle< TileCondIdTransforms > m_tileIdTrans
Definition: TileRawChNoiseCalibAlg.h:125
TileDigitsContainer.h
Identifier
Definition: DetectorDescription/Identifier/Identifier/Identifier.h:32
python.CaloCondTools.g
g
Definition: CaloCondTools.py:15
dqt_zlumi_alleff_HIST.fout
fout
Definition: dqt_zlumi_alleff_HIST.py:59
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
TileRawChNoiseCalibAlg::m_rawChannelContainerFitKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerFitKey
Definition: TileRawChNoiseCalibAlg.h:134
TileRawChNoiseCalibAlg::m_trigType
int m_trigType
Definition: TileRawChNoiseCalibAlg.h:189
TileRawChNoiseCalibAlg::m_file
std::string m_file
Definition: TileRawChNoiseCalibAlg.h:154
TileRawChNoiseCalibAlg::m_doFit
bool m_doFit
Definition: TileRawChNoiseCalibAlg.h:96
TileRawChNoiseCalibAlg::m_cabling
const TileCablingService * m_cabling
Definition: TileRawChNoiseCalibAlg.h:116
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:40
TileRawChNoiseCalibAlg::Fixed
@ Fixed
Definition: TileRawChNoiseCalibAlg.h:68
TileRawChNoiseCalibAlg::execute
virtual StatusCode execute() override
Main method.
Definition: TileRawChNoiseCalibAlg.cxx:316
TileRawChannelUnit::MegaElectronVolts
@ MegaElectronVolts
Definition: TileRawChannelUnit.h:20
TileRawChNoiseCalibAlg::m_rawChannelContainerFixedKey
SG::ReadHandleKey< TileRawChannelContainer > m_rawChannelContainerFixedKey
Definition: TileRawChNoiseCalibAlg.h:131
TileRawChannel
Definition: TileRawChannel.h:35
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::m_ecell_hash
uint32_t(* m_ecell_hash)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS]
Definition: TileRawChNoiseCalibAlg.h:229
TileRawChNoiseCalibAlg::m_gnorm
float(* m_gnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:236
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CHECK
#define CHECK(...)
Evaluate an expression and check for errors.
Definition: Control/AthenaKernel/AthenaKernel/errorcheck.h:422
IdentifiableContainerMT::const_iterator
Definition: IdentifiableContainerMT.h:82
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
TileCalibUtils::MAX_ROS
static const unsigned int MAX_ROS
Number of ROSs
Definition: TileCalibUtils.h:138
TileRawChNoiseCalibAlg.h
maskDeadModules.ros
ros
Definition: maskDeadModules.py:35
TileRawChNoiseCalibAlg::m_doMF
bool m_doMF
Definition: TileRawChNoiseCalibAlg.h:101
TileRawChNoiseCalibAlg::m_ggpar
float(* m_ggpar)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS][NPARS]
Definition: TileRawChNoiseCalibAlg.h:233
TileRawChannelUnit::UNIT
UNIT
Definition: TileRawChannelUnit.h:16
TileRawChNoiseCalibAlg::m_day
int m_day
Definition: TileRawChNoiseCalibAlg.h:184
TileRawChNoiseCalibAlg::m_gerrnorm
float(* m_gerrnorm)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:240
TileBeamElemContByteStreamCnv
This AthConstConverter class provides conversion from ByteStream to TileBeamElemContainer.
Definition: TileBeamElemContByteStreamCnv.h:48
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_yday
int m_yday
Definition: TileRawChNoiseCalibAlg.h:185
TileRawChNoiseCalibAlg::Cis
@ Cis
Definition: TileRawChNoiseCalibAlg.h:72
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
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
TileRawChNoiseCalibAlg::Opt
@ Opt
Definition: TileRawChNoiseCalibAlg.h:68
TileRawChNoiseCalibAlg::RCnum
@ RCnum
Definition: TileRawChNoiseCalibAlg.h:68
TileRawChNoiseCalibAlg::Phys
@ Phys
Definition: TileRawChNoiseCalibAlg.h:72
TileRawChNoiseCalibAlg::SPECIAL_C10_CHANNEL
@ SPECIAL_C10_CHANNEL
Definition: TileRawChNoiseCalibAlg.h:243
TileRawChNoiseCalibAlg::finalCell
void finalCell()
finalCell is called during finalize Here the cell variables of the ntuple are filled.
Definition: TileRawChNoiseCalibAlg.cxx:948
TileRawChNoiseCalibAlg::m_sample
uint8_t(* m_sample)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:223
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
createCoolChannelIdFile.par
par
Definition: createCoolChannelIdFile.py:29
errorcheck.h
Helpers for checking error return status codes and reporting errors.
TileRawChNoiseCalibAlg::fillRawChannels
StatusCode fillRawChannels(const TileDQstatus *dqStatus, const SG::ReadHandleKey< TileRawChannelContainer > &rawChannelContainerKey, RCtype rctype)
Definition: TileRawChNoiseCalibAlg.cxx:711
TileDQstatus::cispar
const uint32_t * cispar() const
CIS parameters.
Definition: TileDQstatus.h:152
TileRawChNoiseCalibAlg::NCELLGAINS
static constexpr int NCELLGAINS
Definition: TileRawChNoiseCalibAlg.h:53
TileRawChNoiseCalibAlg::m_histAmp
TH1F *(* m_histAmp)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:170
EventInfo.h
TileRawChNoiseCalibAlg::m_tileToolEmscale
ToolHandle< TileCondToolEmscale > m_tileToolEmscale
Definition: TileRawChNoiseCalibAlg.h:120
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_evt
int(* m_evt)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:175
TileRawChNoiseCalibAlg::TileRawChNoiseCalibAlg
TileRawChNoiseCalibAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: TileRawChNoiseCalibAlg.cxx:50
TileRawChNoiseCalibAlg::m_saveHist
bool m_saveHist
Definition: TileRawChNoiseCalibAlg.h:102
TileRawChNoiseCalibAlg::digiChannel2PMT
int digiChannel2PMT(int ros, int chan)
Definition: TileRawChNoiseCalibAlg.h:89
TileCalibUtils::getDrawerString
static std::string getDrawerString(unsigned int ros, unsigned int drawer)
Return the drawer name, e.g.
Definition: TileCalibUtils.cxx:145
TileRawChNoiseCalibAlg::m_phi
uint8_t(* m_phi)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:222
TileRawChNoiseCalibAlg::m_dqStatusKey
SG::ReadHandleKey< TileDQstatus > m_dqStatusKey
Definition: TileRawChNoiseCalibAlg.h:124
TileRawChNoiseCalibAlg::m_ecell_ene
float(* m_ecell_ene)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:232
DeMoScan.index
string index
Definition: DeMoScan.py:362
TileRawChNoiseCalibAlg::m_tower
uint8_t(* m_tower)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:224
TileRawChNoiseCalibAlg::FirstEvt_initialize
StatusCode FirstEvt_initialize()
Initialization done at the first event.
Definition: TileRawChNoiseCalibAlg.cxx:272
TileRawChNoiseCalibAlg::m_doFixed
bool m_doFixed
Definition: TileRawChNoiseCalibAlg.h:97
TileCablingService::C10_connected
static bool C10_connected(int module)
Definition: TileCablingService.cxx:1779
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
TileRawData::cell_ID_index
Identifier cell_ID_index(int &index, int &pmt) const
Definition: TileRawData.cxx:65
h
TH1F
Definition: rootspy.cxx:320
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
TileRawChNoiseCalibAlg::~TileRawChNoiseCalibAlg
virtual ~TileRawChNoiseCalibAlg()
Definition: TileRawChNoiseCalibAlg.cxx:143
TileRawChNoiseCalibAlg::m_rc_gcorrsigma1sigma2
float(* m_rc_gcorrsigma1sigma2)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:213
TileBeamElemContByteStreamCnv.h
F
#define F(x, y, z)
Definition: MD5.cxx:112
generate::GetEntries
double GetEntries(TH1D *h, int ilow, int ihi)
Definition: rmsFrac.cxx:20
TileBeamElemContainer.h
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
TileRawChNoiseCalibAlg::m_gg
uint8_t(* m_gg)[Tile::MAX_DRAWER][NSAMPLES][NTOWERS][NCELLGAINS]
Definition: TileRawChNoiseCalibAlg.h:225
xmax
double xmax
Definition: listroot.cxx:61
beamspotnt.rms
rms
Definition: bin/beamspotnt.py:1266
TileRawChNoiseCalibAlg::m_rc_rms
float(* m_rc_rms)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:196
xAOD::EventInfo_v1::timeStamp
uint32_t timeStamp() const
POSIX time in seconds from 1970. January 1st.
TileRawChNoiseCalibAlg::NSAMPLES
static constexpr int NSAMPLES
Definition: TileRawChNoiseCalibAlg.h:51
TileRawChNoiseCalibAlg::m_gain
bool(* m_gain)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:179
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
python.TrigEgammaMonitorHelper.TH1F
def TH1F(name, title, nxbins, bins_par2, bins_par3=None, path='', **kwargs)
Definition: TrigEgammaMonitorHelper.py:24
TileCalibUtils::getDrawerIdx
static unsigned int getDrawerIdx(unsigned int ros, unsigned int drawer)
Returns a drawer hash.
Definition: TileCalibUtils.cxx:60
Tile_Base_ID::cell_hash
IdentifierHash cell_hash(const Identifier &cell_id) const
fast conversion from ID to hash for cells
Definition: Tile_Base_ID.cxx:1030
TileAANtupleConfig.rawChannelContainer
rawChannelContainer
Definition: TileAANtupleConfig.py:120
TileRawChNoiseCalibAlg::m_tileHWID
const TileHWID * m_tileHWID
Definition: TileRawChNoiseCalibAlg.h:119
ReadHandle.h
Handle class for reading from StoreGate.
TileCalibUtils::MAX_CHAN
static const unsigned int MAX_CHAN
Number of channels in drawer.
Definition: TileCalibUtils.h:141
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_ggpar
float(* m_rc_ggpar)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN][NPARS]
Definition: TileRawChNoiseCalibAlg.h:205
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::Las
@ Las
Definition: TileRawChNoiseCalibAlg.h:72
TileRawChNoiseCalibAlg::m_evtNr
int m_evtNr
Definition: TileRawChNoiseCalibAlg.h:174
TileRawChNoiseCalibAlg::m_ros
uint8_t(* m_ros)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:176
TileRawChNoiseCalibAlg::m_doOF1
bool m_doOF1
Definition: TileRawChNoiseCalibAlg.h:100
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::RCtype
RCtype
Definition: TileRawChNoiseCalibAlg.h:67
TileRawChNoiseCalibAlg::m_rc_gerrnorm
float(* m_rc_gerrnorm)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:212
readCCLHist.float
float
Definition: readCCLHist.py:83
TileRawChNoiseCalibAlg::m_rc_skewness
float(* m_rc_skewness)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:197
TileCablingService::E1_merged_with_run2plus
int E1_merged_with_run2plus(int ros, int module) const
Definition: TileCablingService.cxx:2457
TileRawChNoiseCalibAlg::m_rc_gerrsigma1
float(* m_rc_gerrsigma1)[Tile::MAX_ROS][Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:210
TileRawChannelUnit::ADCcounts
@ ADCcounts
Definition: TileRawChannelUnit.h:17
TileRawChNoiseCalibAlg::m_min
int m_min
Definition: TileRawChNoiseCalibAlg.h:187
TileRawChNoiseCalibAlg::m_invertChanRatio
bool m_invertChanRatio
Definition: TileRawChNoiseCalibAlg.h:103
xAOD::EventInfo_v1::eventType
bool eventType(EventType type) const
Check for one particular bitmask value.
ServiceHandle< IConversionSvc >
TileCalibUtils::MAX_GAIN
static const unsigned int MAX_GAIN
Number of gains per channel
Definition: TileCalibUtils.h:142
TileRawChNoiseCalibAlg::m_channel
uint8_t(* m_channel)[Tile::MAX_DRAWER][Tile::MAX_CHAN][Tile::MAX_GAIN]
Definition: TileRawChNoiseCalibAlg.h:178
Generated on Tue Jul 2 2024 21:29:12 for ATLAS Offline Software by   doxygen 1.8.18