ATLAS Offline Software
CaloNoiseCompCondAlg.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "CaloNoiseCompCondAlg.h"
6 #include "CaloEvent/CaloCell.h"
8 // For Gaudi
9 #include "GaudiKernel/MsgStream.h"
12 #include "GaudiKernel/SystemOfUnits.h"
13 
15 
16 // Exceptions
18 
19 using Gaudi::Units::GeV;
20 
22 
23 CaloNoiseCompCondAlg::CaloNoiseCompCondAlg(const std::string& name, ISvcLocator* pSvcLocator):
24  AthAlgorithm( name, pSvcLocator),
25  m_atlas_id(nullptr),
26  m_calo_id_man(nullptr),
27  m_lar_em_id(nullptr),
28  m_lar_hec_id(nullptr),
29  m_lar_fcal_id(nullptr),
30  m_calocell_id(nullptr),
31  m_Adc2MeVFactor(0),
32  m_RMSpedestal(0),
33  m_nsamples(0),
34  m_SigmaNoise(0.),
35  m_fSampl(0),
36  m_AdcPerMev(5.*GeV),
37  m_MinBiasRMS(0)
38 
39 {
40 }
41 
43 
46 
52 
62 
63  //diagnostic
67 
68  //set calohash maximums
69  m_LArHashMax =0;
74 
75  //set calohash minimum
76  m_CaloHashMin = 0;
77 
78  ATH_MSG_DEBUG( " => CaloHashMin= " <<m_CaloHashMin << " CaloHashMax= " <<m_CaloHashMax );
79  //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
80  //gain-thresholds
81  m_LowGainThresh[CaloCell_ID::LAREM] = 3900;//ADC counts in MediumGain
82  m_HighGainThresh[CaloCell_ID::LAREM] = 1300;//ADC counts in MediumGain
83  m_LowGainThresh[CaloCell_ID::LARHEC] = 2500;//ADC counts in MediumGain
84  m_HighGainThresh[CaloCell_ID::LARHEC] = 0;//-> high-gain never used for HEC
85 
86  m_LowGainThresh[CaloCell_ID::LARFCAL] = 2000.;//ADC counts
87  m_HighGainThresh[CaloCell_ID::LARFCAL] = 1100.;//ADC counts
88 
89  m_LowGainThresh[CaloCell_ID::TILE] = 0.;// unit ?
91  //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
96 
97  //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
98 
101 
103 
104  return StatusCode::SUCCESS;
105 }
106 
108 
109 StatusCode
111 
112  const EventContext& ctx = Gaudi::Hive::currentContext();
113 
115  if(!caloMgrHandle.isValid()) {
116  ATH_MSG_ERROR( "Do not have CaloDetDescrMgr");
117  return StatusCode::FAILURE;
118  }
119 
120  m_calo_dd_man = *caloMgrHandle;
122 
123 
124  //Set up write handles
125  SG::WriteCondHandle<CaloNoise> writeElecHandle{m_outputElecKey,ctx};
126  SG::WriteCondHandle<CaloNoise> writePileupHandle{m_outputPileupKey,ctx};
127 
128  if (writeElecHandle.isValid() && writePileupHandle.isValid()) {
129  ATH_MSG_DEBUG("Found valid write handles");
130  return StatusCode::SUCCESS;
131  }
132 
133  //Start with infinite range and narrow it down
134  const EventIDRange fullRange=IOVInfiniteRange::infiniteMixed();
135  writeElecHandle.addDependency (fullRange);
136  writePileupHandle.addDependency (fullRange);
137 
138  // Read input conditions
139  auto cablingHdl = SG::ReadCondHandle<LArOnOffIdMapping>(m_cablingKey, ctx);
140  if(!cablingHdl.isValid()) {
141  ATH_MSG_ERROR( "Do not have cabling");
142  return StatusCode::FAILURE;
143  }
144  m_cabling=*cablingHdl;
145  writeElecHandle.addDependency (cablingHdl);
146  writePileupHandle.addDependency (cablingHdl);
147 
149  const LArADC2MeV* adc2mev{*adc2mevHdl};
150  if(!adc2mev) {
151  ATH_MSG_ERROR( "Do not have adc2mev");
152  return StatusCode::FAILURE;
153  }
154  writeElecHandle.addDependency (adc2mevHdl);
155  writePileupHandle.addDependency (adc2mevHdl);
156 
157  if(m_noiseKey.empty()) {
159  if(!pedHdl.isValid()){
160  ATH_MSG_ERROR( "Do not have pedestals");
161  return StatusCode::FAILURE;
162  }
163  m_ped=*pedHdl;
164  writeElecHandle.addDependency (pedHdl);
165  } else {
166  auto noiseHdl=SG::ReadCondHandle<ILArNoise>(m_noiseKey, ctx);
167  if(!noiseHdl.isValid()){
168  ATH_MSG_ERROR( "Do not have noise");
169  return StatusCode::FAILURE;
170  }
171  m_noise=*noiseHdl;
172  writeElecHandle.addDependency (noiseHdl);
173 
174  }
175 
176  auto acorrHdl=SG::ReadCondHandle<ILArAutoCorr>(m_acorrKey, ctx);
177  if(!acorrHdl.isValid()){
178  ATH_MSG_ERROR( "Do not have autocorr");
179  return StatusCode::FAILURE;
180  }
181  m_acorr=*acorrHdl;
182  writeElecHandle.addDependency (acorrHdl);
183 
185  if(!ofcHdl.isValid()){
186  ATH_MSG_ERROR( "Do not have ofc");
187  return StatusCode::FAILURE;
188  }
189  m_ofccond=*ofcHdl;
190  writeElecHandle.addDependency (ofcHdl);
191  writePileupHandle.addDependency (ofcHdl);
192 
193  auto shapeHdl=SG::ReadCondHandle<ILArShape>(m_shapeKey, ctx);
194  if(!shapeHdl.isValid()){
195  ATH_MSG_ERROR( "Do not have shape");
196  return StatusCode::FAILURE;
197  }
198  m_shapecond=*shapeHdl;
199  writeElecHandle.addDependency (shapeHdl);
200  writePileupHandle.addDependency (shapeHdl);
201 
202  auto fsamplHdl=SG::ReadCondHandle<ILArfSampl>(m_fSamplKey, ctx);
203  if(!fsamplHdl.isValid()){
204  ATH_MSG_ERROR( "Do not have fSampl");
205  return StatusCode::FAILURE;
206  }
207  m_fsamplcond=*fsamplHdl;
208  writePileupHandle.addDependency (fsamplHdl);
209 
210 
212  if(!minbiasHdl.isValid()){
213  ATH_MSG_ERROR( "Do not have minbias");
214  return StatusCode::FAILURE;
215  }
216  m_minbias=*minbiasHdl;
217  writePileupHandle.addDependency (minbiasHdl);
218 
219  ATH_CHECK(this->initData(adc2mev));
220 
221  //Create the CaloNoise CDO:
222  std::unique_ptr<CaloNoise> elecNoiseObj=std::make_unique<CaloNoise>(m_LArHashMax,m_nGains, 0,4,
224  std::unique_ptr<CaloNoise> pileupNoiseObj=std::make_unique<CaloNoise>(m_LArHashMax,m_nGains, 0,4,
226  //Get writeable access to underlying storage (boost::multi_array)
227  auto& elecnoise = elecNoiseObj->larStorage();
228  auto& pileupnoise = pileupNoiseObj->larStorage();
229 
230  for(unsigned ihash=m_CaloHashMin; ihash < m_CaloHashMax; ++ihash) {
231 
232  Identifier id=m_calocell_id->cell_id(ihash);
233  auto dde=m_calo_dd_man->get_element(id);
234  auto elec3gains = elecNoiseRMS3gains(dde);
235  auto pns = pileupNoiseRMS(dde,m_Nminbias);
236 
237  for (unsigned igain=0;igain<m_nGains;++igain) {
238  elecnoise[igain][ihash] = elec3gains[igain];
239  pileupnoise[igain][ihash] = pns;
240  }
241  }
242 
243  // store output
244  ATH_CHECK(writeElecHandle.record(std::move(elecNoiseObj)));
245  ATH_MSG_INFO("recorded new CaloNoise object with key " << writeElecHandle.key() << " and range " << writeElecHandle.getRange());
246 
247  ATH_CHECK(writePileupHandle.record(std::move(pileupNoiseObj)));
248  ATH_MSG_INFO("recorded new CaloNoise object with key " << writePileupHandle.key() << " and range " << writePileupHandle.getRange());
249 
250  return StatusCode::SUCCESS;
251 }
252 
253 
254 
256 
257 StatusCode
259 {
260  //initialize the maps m_ElecNoiseContainer and m_ScaleContainer
261  //(assuming type of elements of the containers is the same for LAr)
262 
263  MsgStream log( msgSvc(), name() );
264  ATH_MSG_INFO( "initContainers() begin " );
265 
266  // intialise indices
267  ATH_CHECK(this->initIndex());
268 
269  //::::::::::::::::::::::::::::::::::::::
274  //::::::::::::::::::::::::::::::::::::::
275  ATH_MSG_INFO( "initContainers() end : " <<" size of containers = " <<m_idSymmCaloHashContainer.size() );
276  return StatusCode::SUCCESS;
277 }
278 
280 
281 StatusCode
283  //::::::::::::::::::::::::::::::::::::::
284  m_indexContainer.clear();
286  static_cast<unsigned int> (-1));
287 
288  //maybe the other container sould be reset
290  m_idSymmCaloHashContainer.reserve(5000);
291 
292 
293 
294  for (unsigned int intIdCaloHash=m_CaloHashMin; intIdCaloHash<m_CaloHashMax;
295  ++intIdCaloHash)
296  {
297 
298 
299  IdentifierHash idCaloHash=static_cast<IdentifierHash>(intIdCaloHash);
300 
301  // initialize the vector of indexes (big vector without symmetry)
302 
303 
304 
305 
306  // o idCaloHash -> id -> idSymm (symmetry phi->0 and z->|z|)
307  // o idSymm -> idSymmCaloHash
308  // o idSymmCaloHash stored in m_idSymmCaloHashContainer
309  // o an index is associated to an idSymmCaloHash
310  // o index stored in m_indexContainer
311 
312  CaloCell_ID::SUBCALO iCalo = this->caloNum(idCaloHash);
313  Identifier id = m_calocell_id->cell_id(idCaloHash);
314  Identifier regId;
315  Identifier idSymm;
316  IdentifierHash idSymmCaloHash;
317 
318  if(m_UseSymmetry){
319  if(iCalo==CaloCell_ID::LAREM)
320  {
321  int barrel_ec = m_lar_em_id->barrel_ec(id);
322  int sampling = m_lar_em_id->sampling(id);
323  int region = m_lar_em_id->region(id);
324  int eta = m_lar_em_id->eta(id);
325  regId = m_lar_em_id->region_id(abs(barrel_ec),sampling,region);
326  idSymm = m_lar_em_id->channel_id(regId,
327  eta,
328  m_calocell_id->phi_min(regId));
329  idSymmCaloHash= m_calocell_id->calo_cell_hash(idSymm);
330  }
331  else if(iCalo==CaloCell_ID::LARHEC)
332  {
333  int pos_neg = m_lar_hec_id->pos_neg(id);
334  int sampling = m_lar_hec_id->sampling(id);
335  int region = m_lar_hec_id->region(id);
336  int eta = m_lar_hec_id->eta(id);
337  regId = m_lar_hec_id->region_id(abs(pos_neg),sampling,region);
338  idSymm = m_lar_hec_id->channel_id(regId,
339  eta,
340  m_calocell_id->phi_min(regId));
341  idSymmCaloHash= m_calocell_id->calo_cell_hash(idSymm);
342  }
343  else if(iCalo==CaloCell_ID::LARFCAL)
344  {
345  int pos_neg = m_lar_fcal_id->pos_neg(id);
346  int module = m_lar_fcal_id->module(id);
347  int eta = m_lar_fcal_id->eta(id);
348  int phi = m_lar_fcal_id->phi(id);
349  if(phi>7) phi = phi-8; //as in LArMCSymTool
350  regId = m_lar_fcal_id->module_id(abs(pos_neg),module);
351  idSymm = m_lar_fcal_id->channel_id(regId,
352  eta,
353  phi);
354  idSymmCaloHash= m_calocell_id->calo_cell_hash(idSymm);
355  }
356  else if(iCalo==CaloCell_ID::TILE)
357  {
358  idSymm = id;
359  idSymmCaloHash = m_calocell_id->calo_cell_hash(idSymm);
360  }
361  else
362  {
363  MsgStream log( msgSvc(), name() );
364  ATH_MSG_WARNING("CaloNoiseCompCondAlg::chooseIndex wrong id ! " << m_lar_em_id->show_to_string(id));
365  continue ;
366  }
367 
368  assert (idSymmCaloHash < m_CaloHashMax);
369  if (m_indexContainer[idSymmCaloHash] != static_cast<unsigned int>(-1)) {
370  m_indexContainer[idCaloHash] = m_indexContainer[idSymmCaloHash];
371  continue;
372  }
373  }
374  else idSymmCaloHash=idCaloHash;// no symmetry
375 
376 
377  if(iCalo!=CaloCell_ID::TILE) {
378  if(this->checkIfConnected(id)==false) {
379  continue;
380  }
381  }
382 
383 
384  /* cabling eta= 0 -> 0.8 (for private debug)
385  int samp = m_lar_em_id->sampling(id);
386  int region= m_lar_em_id->region(id);
387  int eta = m_lar_em_id->eta(id);
388  int phi = m_lar_em_id->phi(id);
389  if(samp==1 && eta>=256) return;
390  if(samp==1 && eta==0) return;
391  if(samp==2 && eta>=32) return;
392  if(samp==3 && eta>=16) return;
393  if(region>0) return;
394  */
395 
396 
397  //we come here if idSymmHash is not yet indexed (and is connected)
398  m_indexContainer[idCaloHash] =
399  m_indexContainer[idSymmCaloHash] =
401 
402  m_idSymmCaloHashContainer.push_back(idSymmCaloHash);
403  }// loop on all cells
404 
405  return StatusCode::SUCCESS;
406 }
407 
409 
410 bool
412 {
413  try
414  {
416  if(!m_cabling->isOnlineConnected(hwid))
417  {
418  return false;
419  }
420  }
421  catch(LArID_Exception & except)
422  {return false;}
423  return true;
424 }
425 
427 
428 int
430 {
431  return m_indexContainer[idCaloHash];
432 }
433 
434 
436 
437 StatusCode
439 {
440  MsgStream log( msgSvc(), name() );
441 
442  StatusCode sc ;
443  sc = this->initContainers();
444  if (sc.isFailure()) {
445  ATH_MSG_WARNING( "initContainers failed" ) ;
446  return sc;
447  }
448 
449  // reset diagnostics
450  for(int igain=0;igain<CaloGain::LARNGAIN;++igain)
451  {
453  for(int i=0;i<5000;++i) m_nReason[i][igain]=0;
454  for(int i=0;i<10;++i) m_itReason[i][igain]=0;
455  }
456 
457 
458  //stores the Adc2MeV factors
459  sc = this->initAdc2MeV(adc2mev);
460  if (!sc.isSuccess())
461  ATH_MSG_ERROR( "initData(): error with initAdc2MeV() " );
462 
463  //calculates and stores the electronic noise
464  sc = this->initElecNoise();
465  if (!sc.isSuccess())
466  ATH_MSG_ERROR( "initData(): error with initElecNoise() " );
467 
468  //calculates and stores the pileup noise
469  sc = this->initPileUpNoise();
470  if (!sc.isSuccess())
471  ATH_MSG_ERROR( "initData(): error with initPileUpNoise() ");
472 
473 
474  return StatusCode::SUCCESS;
475 }
476 
478 
479 StatusCode
481 {
482  MsgStream log( msgSvc(), name() );
483  ATH_MSG_INFO( "initAdc2MeV() begin " );
484  for (unsigned int it=0; it<m_adc2mevContainer.size(); ++it)
485  {
488  //::::::::::::::::::::::::::::::::::::::
489  //::::::::::::::::::::::::::::::::::::::
490  if(iCalo!=CaloCell_ID::TILE)
491  {
492  std::vector<float>& adc2mevVector = m_adc2mevContainer[it];
493  adc2mevVector.reserve (CaloGain::LARNGAIN);
494  for(unsigned int igain=0;igain<CaloGain::LARNGAIN;++igain)
495  {
496  auto polynom_adc2mev = adc2mev->ADC2MEV(id,igain);
497  if(polynom_adc2mev.size()==0)
498  adc2mevVector.push_back(0.);
499  else
500  adc2mevVector.push_back(polynom_adc2mev[1]);
501  }
502  }
503  //::::::::::::::::::::::::::::::::::::::
504  }
505  ATH_MSG_INFO( "initAdc2MeV() end " );
506  return StatusCode::SUCCESS;
507 }
508 
510 
511 StatusCode
513 {
514  // initialize the parameters (the same for each event for each Identifier)
515  // for the calculation of the electronic noise
516 
517 
518  MsgStream log( msgSvc(), name() );
519  ATH_MSG_DEBUG( "initElecNoise() begin " );
520 
521  for (unsigned int it=0; it<m_elecNoiseCELLContainer.size(); ++it)
522  {
523  //::::::::::::::::::::::::::::::::::::::
526  //::::::::::::::::::::::::::::::::::::::
527  }
528 
529  //print diagnostic
530  for(int igain=0;igain<CaloGain::LARNGAIN;++igain)
531  if(m_diagnostic[igain])
532  {
533  ATH_MSG_INFO("===== Diagnostic for gain "<<igain<<" =====");
534  for(int i=0;i<m_nCellsWithProblem[igain];++i)
535  {
537  log<<MSG::DEBUG<<m_idHash[i][igain]<<" "
539  <<" "<<m_nReason[i][igain]<<" : ";
540  for(int j=0;j<m_nReason[i][igain];++j)
541  log<<MSG::DEBUG<<m_reasonName[m_reason[i][j][igain]]<<" ";
542  log << MSG::DEBUG<<endmsg;
543  }
545  ATH_MSG_INFO("N cells with problem(s) = " <<m_nCellsWithProblem[igain]);
546  for(int i=0;i<10;++i)
547  if(m_itReason[i][igain]>0)
548  ATH_MSG_INFO( i<<" "<<m_reasonName[i] <<": for "<<m_itReason[i][igain]<<" cells" );
549  }
550 
551  ATH_MSG_DEBUG( "initElecNoise() end " );
552  return StatusCode::SUCCESS;
553 }
554 
556 
557 StatusCode
559 {
560  // initialize the parameters (the same for each event for each Identifier)
561  // for the calculation of the PileUp noise
562 
563  MsgStream log( msgSvc(), name() );
564  ATH_MSG_DEBUG( "initPileUpNoise() begin " );
565  ATH_MSG_INFO( "N events of Minimum Bias per bunch crossing = " << m_Nminbias);
566  //::::::::::::::::::::::::::::::::::::::
567  for (unsigned int it=0; it<m_pileupNoiseContainer.size(); ++it)
570  //::::::::::::::::::::::::::::::::::::::
571  ATH_MSG_DEBUG( "initPileUpNoise() end " );
572  return StatusCode::SUCCESS;
573 }
574 
576 
577 std::vector<float>
579 {
580  /*
581 
582 E=SUMi { OFCi * (short[ (PulseShapei*Ehit/Adc2MeV(gain) + Noisei(gain)
583  + pedestal) ]
584  - pedestal) * Adc2Mev(gain) ] }
585  with Noisei =SUMj { cij*Rndm } * m_SigmaNoise
586 
587  NB: without short and with cij=identity (no autocorrelation)
588  E=SUMi { NOISEi(gain)*Rndm }
589  with NOISEi(gain) = Adc2MeV(gain) * OFCi * m_SigmaNoise(gain)
590 
591  => Sigma^2=SUMi{NOISEi(gain)*NOISEj(gain)*cij} + quantification part
592  = NOISE(gain) + REST
593  Sigma = std::sqrt( NOISE(gain) + REST)
594 
595 
596 */
597 
598  std::vector<float> sigmaVector (CaloGain::LARNGAIN,BADVALUE);
599  float sigma;
600 
601  Identifier id = m_calocell_id->cell_id(idCaloHash);
602 
603  for(int igain=0;igain<CaloGain::LARNGAIN;++igain)
604  {
605  bool noiseOK=true;
606  //::::::::::::::::::::::::::::::::::::::::::::::::::
607  //==== retrieve the database ====
608  //::::::::::::::::::::::::::::::::::::::::::::::::::
609 
610  std::vector<bool> retrieve(nDATABASE,false);
611  retrieve[iADC2MEV]=true;
612  retrieve[iSIGMANOISE]=true;
613  retrieve[iAUTOCORR]=true;
614  retrieve[iOFC]=true;
615  //retrieve[iSHAPE]=true;
616  StatusCode sc=this->retrieveCellDatabase(idCaloHash,id,igain, retrieve);
617  //if(sc.isFailure()) continue;
618  //NOTE: if an element of the database is empty,
619  // leave the iteration (on gains) => value will be BADVALUE
620  //the interfaces take care of that !
621 
622  //::::::::::::::::::::::::::::::::::::::::::::::::::
623  //==== calculations ====
624  //::::::::::::::::::::::::::::::::::::::::::::::::::
625 
626  if(sc.isFailure()) {
628  }
629  else
630  {
631  float OFC_AC_OFC,OFC_OFC;
632  this->commonCalculations(OFC_AC_OFC,OFC_OFC,1);
633  //::::::::::::::::::::::::::::::::::::::
634  float NOISE= OFC_AC_OFC*m_SigmaNoise*m_SigmaNoise ;
635  float REST = OFC_OFC*(1./12.);// 12.=std::sqrt(12)*std::sqrt(12)
636  sigma=(NOISE+REST) * m_Adc2MeVFactor*m_Adc2MeVFactor;
637  //::::::::::::::::::::::::::::::::::::::
638  if(sigma>0) sigma=std::sqrt(sigma);
639  else
640  {
641  sigma=-std::sqrt(-sigma);
642  //:::::::::::::::::
643  // MsgStream log(msgSvc(), name());
644  // if(igain==0) log << MSG::ERROR
645  // <<m_lar_em_id->show_to_string(id)<<" gain "<<igain
646  // <<" : negative root square => WRONG noise "
647  // <<"(please check if OFC or AutoCorr are correct for this cell)"
648  // <<endreq;
649  }
650 
651  //diagnostic
652  if(m_diagnostic[igain])
653  {
654  if(noiseOK && sigma<0)
655  this->updateDiagnostic(9,"sigma<0",igain, noiseOK);
656  if(!noiseOK)
657  {
658  m_idHash[m_nCellsWithProblem[igain]][igain]=idCaloHash;
661  }
662  }
663  //::::::::::::::::::::::::::::::::::::::
664  if(noiseOK==false || sigma<0) sigma=float(BADVALUE_TO_RETURN);
665  }
666  sigmaVector[igain]=sigma;
667 
668  }//loop on gains
669 
670  return sigmaVector;
671 }
672 
674 
675 
676 float
678  const float &Nminbias)
679 {
680  if(Nminbias<=0.000001) return 0.;
681  //only on WorkMode==1
682  if(this->caloNum(idCaloHash)==CaloCell_ID::TILE) return 0.;
683  //no pile-up for tiles, for the moment ...
684 
685  /*
686  SigmaPileUp^2 = ( SigmaE * std::sqrt(Nmb) )^2 * Ipileup/Tc
687  where:
688  - Ipileup = Tc * SUM(k=1->Nb) g(tk)^2
689  - Tc is the time between bunch crossings
690  - Nb is the number of bunch crossings
691  (over which the response function is non-zero)
692  - g is the shape
693  - SigmaE is the RMS of the energy in 1 minimum bias event
694  - Nmb is the number of minimum bias events (depending on the luminosity)
695  */
696 
697  Identifier id = m_calocell_id->cell_id(idCaloHash);
698 
699  //::::::::::::::::::::::::::::::::::::::
700 
701  std::vector<bool> retrieve(nDATABASE,false);
702  retrieve[iAUTOCORR]=true;
703  retrieve[iOFC]=true;
704  retrieve[iSHAPE]=true;
705  retrieve[iMINBIASRMS]=true;
706  retrieve[iFSAMPL]=true;
707  StatusCode sc=this->retrieveCellDatabase(idCaloHash,id,
709  if(sc.isFailure()) return 0.;
710 
711  //::::::::::::::::::::::::::::::::::::::
712 
713  //in the database, RMS is at the scale of the Hits,
714  // so we need to scale it at the e.m scale using the sampling fraction ...
716 
717  //::::::::::::::::::::::::::::::::::::::
718 
719 // overall normalization factor
720  float PileUp=m_MinBiasRMS*std::sqrt(Nminbias);
721 
722  //::::::::::::::::::::::::::::::::::::::
723 
724  float OFC_AC_OFC,OFC_OFC;
725  unsigned int firstSample=m_firstSample;
726  // for HEC, always use firstSample=1 when the number of samples is 4
727  if (m_lar_hec_id->is_lar_hec(id) && m_nsamples==4 && m_firstSample==0u) firstSample=1;
728  this->commonCalculations(OFC_AC_OFC,OFC_OFC,2,firstSample);
729 
730  //::::::::::::::::::::::::::::::::::::::
731 
732  PileUp*=std::sqrt(OFC_AC_OFC);
733 
734  return PileUp;
735 }
736 
738 
739 void
740 CaloNoiseCompCondAlg::commonCalculations(float & OFC_AC_OFC,float & OFC_OFC,int icase, unsigned int firstSample)
741 {
742 
743  // case 1 electronic noise
744  if (icase==1) {
745  //calculate the matrix of autocorrelation
746  for(int i=0;i<m_nsamples;++i)
747  for(int j=0;j<m_nsamples;++j)
748  {
749  if(i==j) m_c[i][j] = 1.;
750  for(int k=1;k<m_nsamples;++k)
751  if(i==j-k || i==j+k)
752  m_c[i][j] = m_AutoCorr[k-1];
753  }
754  }
755 // other case: pileup noise
756  else {
757  for (int i=0;i<m_nsamples;i++) {
758  for (int j=0;j<m_nsamples;j++)
759  {
760  m_c[i][j]=0.;
761  int nsize = m_Shape.size();
762  for (int k=0;k<nsize;k++) {
763  if ((j-i+k)>=0 && (j-i+k)<nsize) {
764  int ibunch=0;
765  if ((i+firstSample-k)%m_deltaBunch == 0 ) ibunch=1;
766  m_c[i][j] += ((double) (ibunch)) * (m_Shape[k]) * (m_Shape[j-i+k]);
767  }
768  }
769  }
770  }
771  }
772 
773  //::::::::::::::::::::::::::::::::::::::
774  OFC_AC_OFC=0;
775  OFC_OFC=0;
776 
777  float tmp;
778  for(int i=0;i<m_nsamples;++i)
779  {
780  tmp=0.;
781  for(int j=0;j<m_nsamples;++j)
782  tmp+=m_c[i][j]*m_OFC[j];
783  tmp*=m_OFC[i];
784  OFC_AC_OFC+=tmp;
785  OFC_OFC+= m_OFC[i] * m_OFC[i];
786  }
787  //::::::::::::::::::::::::::::::::::::::
788 }
789 
791 
794  const Identifier & id,
795  int igain,
796  std::vector<bool> &retrieve)
797 {
798  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
799  //ADC2MEV
800  if(retrieve[iADC2MEV])
801  {
802  {
803  int index=this->index(idCaloHash);
805  }
806  }
807 
808  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
809  //SIGMANOISE
810  if(retrieve[iSIGMANOISE])
811  {
812  if(m_ped) {
816  else
817  {
818  m_SigmaNoise = 0.;
819  }
820  } else {
822 
823  }
824  }
825 
826  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
827  //AUTOCORR
828  if(retrieve[iAUTOCORR])
829  {
832  ATH_MSG_VERBOSE("AutoCorr= ");
833  for(unsigned int i=0;i<m_AutoCorr.size();++i)
835  }
836 
837  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
838  //OFC
839  if(retrieve[iOFC])
840  {
843  ATH_MSG_VERBOSE("OFC= ");
844  for(unsigned int i=0;i<m_OFC.size();++i)
845  ATH_MSG_VERBOSE(m_OFC[i]<<" ");
846  }
847 
848  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
849  //SHAPE
850  if(retrieve[iSHAPE])
851  {
854  ATH_MSG_VERBOSE("Shape= ");
855  for(unsigned int i=0;i<m_Shape.size();++i)
856  ATH_MSG_VERBOSE(m_Shape[i]<<" ");
857  }
858 
859  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
860  //MinimumBias RMS
861  if(retrieve[iMINBIASRMS])
862  {
864  ATH_MSG_VERBOSE("MinBiasRMS="<<m_MinBiasRMS);
865  }
866 
867  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
868  //SAMPLING FRACTION
869  if(retrieve[iFSAMPL])
870  {
872  ATH_MSG_VERBOSE("fSampl="<<m_fSampl);
873  }
874 
875  return this->checkCellDatabase(id,igain, retrieve);
876 }
877 
879 
882 {
883  StatusCode StatusDatabase=StatusCode::SUCCESS;
884 
885  bool dummy=false;
886  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
887  //ADC2MEV
888  if(retrieve[iADC2MEV]) {
889  if(std::fabs(m_Adc2MeVFactor)<0.000001) {
890  StatusDatabase=StatusCode::FAILURE;
891  if(m_diagnostic[igain])
892  this->updateDiagnostic(0,"m_Adc2MeVFactor=0",igain,dummy);
893  }
894  }
895 
896  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
897  //SIGMANOISE
898  if(retrieve[iSIGMANOISE]) {
899  if(std::fabs(m_SigmaNoise)<0.000001) {
900  StatusDatabase=StatusCode::FAILURE;
901  if(m_diagnostic[igain])
902  this->updateDiagnostic(1,"m_SigmaNoise=0",igain,dummy);
903  }
904  }
905 
906  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
907  //AUTOCORR
908  if(retrieve[iAUTOCORR])
909  {
910  if (!m_AutoCorr.valid())
911  {
912  ATH_MSG_WARNING( " AutoCorr invalid for " <<m_lar_em_id->show_to_string(id)<<" at gain "<<igain);
913  StatusDatabase=StatusCode::FAILURE;
914  }
915  if (m_AutoCorr.size()==0)
916  {
917  StatusDatabase=StatusCode::FAILURE;
918  if(m_diagnostic[igain]) this->updateDiagnostic(2,"AC empty",igain,dummy);
919  }
920  // autocorr can be null (and it is for low-gain !), so allow it !
921  m_nsamples=m_AutoCorr.size()+1;
922  }
923 
924  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
925  //OFC
926  if(retrieve[iOFC])
927  {
928  if (!m_OFC.valid())
929  {
930  ATH_MSG_WARNING( " OFC pointer null for " <<m_lar_em_id->show_to_string(id)<<" at gain "<<igain);
931  StatusDatabase=StatusCode::FAILURE;
932  }
933  if (m_OFC.size()==0)
934  {
935  StatusDatabase=StatusCode::FAILURE;
936  if(m_diagnostic[igain]) this->updateDiagnostic(4,"OFC empty",igain,dummy);
937  }
938  else
939  if(m_diagnostic[igain])
940  {
941  unsigned int n_OFCnull=0;
942  for(auto ofc : m_OFC)
943  if(std::fabs(ofc)<0.000001) ++n_OFCnull;
944  if(n_OFCnull==m_OFC.size()) this->updateDiagnostic(5,"OFC=0",igain,dummy);
945  }
946  m_nsamples=m_OFC.size();
947  }
948 
949  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
950  //SHAPE
951  if(retrieve[iSHAPE])
952  {
953  if (!m_Shape.valid())
954  {
955  MsgStream log(msgSvc(), name());
956  ATH_MSG_WARNING( " Shape pointer null -> PileUp will be 0 for " <<m_lar_em_id->show_to_string(id) );
957  StatusDatabase=StatusCode::FAILURE;
958  }
959  if (m_Shape.size()==0)
960  {
961  // MsgStream log(msgSvc(), name());
962  // log<<MSG::WARNING
963  // <<" Shape vector empty -> PileUp will be 0 for "
964  // <<m_lar_em_id->show_to_string(id)<<endreq;
965  StatusDatabase=StatusCode::FAILURE;
966  if(m_diagnostic[igain]) this->updateDiagnostic(6,"Shape empty",igain,dummy);
967  }
968  else
969  if(m_diagnostic[igain])
970  {
971  unsigned int n_SHAPEnull=0;
972  for(auto shp : m_Shape)
973  if(std::fabs(shp)<0.000001) ++n_SHAPEnull;
974  if(n_SHAPEnull==m_Shape.size())
975  this->updateDiagnostic(7,"Shape=0",igain,dummy);
976  }
977  }
978 
979  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
980  //NSAMPLES
982  && m_OFC.size()!=m_AutoCorr.size()+1)
983  {
984  m_nsamples=std::min(m_OFC.size(),m_AutoCorr.size()+1);
985  MsgStream log( msgSvc(), name() );
986  ATH_MSG_DEBUG( "AutoCorr and OFC vectors have not the same " <<"number of elements" <<" ("<<m_AutoCorr.size()<<"/"<<m_OFC.size() <<" ) => will take into account only " << m_nsamples << " samples !" );
987  }
988 
989  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
990  if(retrieve[iOFC] && retrieve[iSHAPE] && m_OFC.size()==m_Shape.size())
991  {
992  float scalar=0;
993  for(unsigned int i=0;i<m_Shape.size();++i)
994  scalar+=m_Shape[i]*m_OFC[i];
995  if((scalar-1)>0.05)
996  this->updateDiagnostic(8,"[Shape].[OFC] not 1",igain,dummy);
997  }
998 
999  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
1000  //SAMPLING FRACTION
1001  if(retrieve[iFSAMPL])
1002  {
1003  if (m_fSampl<0.000001)
1004  {
1005  MsgStream log(msgSvc(), name());
1006  ATH_MSG_WARNING(" fSampl null -> PileUp will be 0 for " <<m_lar_em_id->show_to_string(id) );
1007  StatusDatabase=StatusCode::FAILURE;
1008  }
1009  }
1010 
1011  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
1012  return StatusDatabase;
1013 }
1014 
1016 
1017 void
1018 CaloNoiseCompCondAlg::updateDiagnostic(int ireason,const std::string &nameReason,int igain, bool &noiseOK)
1019 {
1020  int nTmp=m_nCellsWithProblem[igain];
1021  if (nTmp >= 5000) return;
1022  int nr = m_nReason[nTmp][igain];
1023  if (nr >= 10) return;
1024  m_reason[nTmp][nr][igain]=ireason;
1025  m_reasonName[ireason]=nameReason;
1026  ++m_nReason[nTmp][igain];
1027  ++m_itReason[ireason][igain];
1028  noiseOK=false;
1029 }
1030 
1032 
1033 
1034 //======================== USER INTERFACES ===================================
1035 
1036 
1038 
1039 float
1041  const CaloGain::CaloGain gain)
1042 {
1043 
1044 
1045  float sigma=0.;
1046 
1047  const IdentifierHash idCaloHash = caloDDE->calo_hash();
1048  //CaloCell_ID::SUBCALO iCalo = this->caloNum(idCaloHash);
1049  CaloCell_ID::SUBCALO iCalo = caloDDE->getSubCalo();
1050  int index=this->index(idCaloHash);
1051 
1052 
1053  int igain=static_cast<int>(gain);//for LAr
1054  if(iCalo==CaloCell_ID::TILE) //for Tile
1055  {
1056  CaloGain::CaloGain convertedGain;
1057  switch(gain)
1058  {
1059  //convert Tile gain into LAr gain (the one used to store the noise in arrays)
1060  case CaloGain::TILEHIGHHIGH : convertedGain=CaloGain::LARHIGHGAIN; break;
1061  case CaloGain::TILEHIGHLOW : convertedGain=CaloGain::LARMEDIUMGAIN; break;
1062  case CaloGain::TILELOWHIGH : convertedGain=CaloGain::LARMEDIUMGAIN; break;
1063  case CaloGain::TILELOWLOW : convertedGain=CaloGain::LARLOWGAIN; break;
1064  case CaloGain::TILEONEHIGH : convertedGain=CaloGain::LARHIGHGAIN; break;
1065  case CaloGain::TILEONELOW : convertedGain=CaloGain::LARLOWGAIN; break;
1066  default: convertedGain = CaloGain::INVALIDGAIN;
1067  }
1068  igain=static_cast<int>(convertedGain);
1069  }
1070 
1072  MsgStream log( msgSvc(), name() );
1073  ATH_MSG_WARNING( " ask noise for invalid/unknown gain, will return noise for high gain " );
1074  igain=static_cast<int>(CaloGain::LARHIGHGAIN);
1075  }
1076 
1077  if (iCalo<0 || index<0)
1078  {
1079  MsgStream log(msgSvc(), name());
1080  ATH_MSG_WARNING( "CaloNoiseCompCondAlg::elecNoiseRMS wrong id ! " << "iCalo="<<iCalo << "index="<<index << "id:" << m_lar_em_id->show_to_string(caloDDE->identify()) );
1081  return 0.;
1082  }
1083  else
1084  {
1085  const std::vector<float>* sigmaVector = 0;
1086  sigmaVector = &m_elecNoiseCELLContainer[index];
1087 
1088  bool retry=true;
1089  int shift_gain=0;
1090  int gain_wanted=igain;
1091  int gain_shifted=gain_wanted;
1092 
1093  while(retry)
1094  {
1095  //:::::::::::::::::
1096  retry=false;
1097  //:::::::::::::::::
1098  gain_shifted=gain_wanted-shift_gain;
1099  //:::::::::::::::::
1100  sigma = (*sigmaVector)[gain_shifted];
1101  //:::::::::::::::::
1102  sigma = this->calculateElecNoiseForLAR(idCaloHash) [gain_shifted];
1103  //:::::::::::::::::
1104  if(this->isBadValue(sigma))
1105  {
1106  ++shift_gain;
1107  if(shift_gain<=igain) retry=true;
1108  MsgStream log(msgSvc(), name());
1109  ATH_MSG_WARNING( "noise is missing for this cell " << m_lar_em_id->show_to_string(caloDDE->identify()) << " at this gain (" <<gain_wanted<<"), return the noise at next gain (" <<gain_shifted<<")" );
1110  }
1111  //:::::::::::::::::
1112  }
1113  return sigma;
1114  }
1115 }
1116 
1117 
1119 
1120 std::vector<float>
1122 {
1123  std::vector<float> sigma;
1124  sigma.reserve (CaloGain::LARNGAIN);
1125  for(int igain=0;igain<CaloGain::LARNGAIN;++igain)
1126  sigma.push_back(this->elecNoiseRMS(caloDDE,
1127  static_cast<CaloGain::CaloGain>(igain)));
1128  for(int igain=0;igain<CaloGain::LARNGAIN;++igain)
1129  if(this->isBadValue(sigma[igain]) &&
1131  sigma[igain]=sigma[igain-1];//take the next gain (low->medium->high)
1132  return sigma;
1133 }
1134 
1135 
1137 
1138 float
1140  const CaloDetDescrElement* caloDDE = theCell->caloDDE();
1141  CaloGain::CaloGain igain = theCell->gain();
1142  return this->elecNoiseRMS(caloDDE, igain);
1143 }
1144 
1145 float
1146 
1148  const float Nminbias) {
1149  const CaloDetDescrElement* caloDDE = theCell->caloDDE();
1150  return this->pileupNoiseRMS(caloDDE,Nminbias);
1151 }
1152 
1153 float
1154 
1156  const float Nminbias) {
1157  float elecNoiseRMS_tmp = this->elecNoiseRMS(theCell);
1158  float pileupNoiseRMS_tmp = this->pileupNoiseRMS(theCell,Nminbias);
1159 
1160  if(elecNoiseRMS_tmp>=0)
1161  return std::sqrt((elecNoiseRMS_tmp*elecNoiseRMS_tmp) + (pileupNoiseRMS_tmp*pileupNoiseRMS_tmp));
1162  return(-1);
1163 }
1164 
1165 
1167 
1168 
1169 float
1171  const float Nminbias)
1172 // << base class >>
1173 {
1174 
1175 
1176  const IdentifierHash idCaloHash = caloDDE->calo_hash();
1177  CaloCell_ID::SUBCALO iCalo = this->caloNum(idCaloHash);
1178 
1179  if(iCalo!=CaloCell_ID::TILE)
1180  {
1181  int index=this->index(idCaloHash);
1182  float PileUp;
1183  // check if noise stored in container was calcualted with this Nminbias
1184  if ((Nminbias==m_Nminbias) || (Nminbias<=0)) //default
1186  else
1187  PileUp=this->calculatePileUpNoise(idCaloHash,Nminbias);//slower !!
1188  return PileUp;
1189  }
1190  else//TILE
1191  {
1192  return 0.;
1193  }
1194 }
1195 
1197 
1198 
1199 float
1201  const CaloGain::CaloGain gain,
1202  const float Nminbias)
1203 {
1204  float elecNoiseRMS_tmp = this->elecNoiseRMS(caloDDE,gain);
1205  float pileupNoiseRMS_tmp = this->pileupNoiseRMS(caloDDE,Nminbias);
1206 
1207  float totalNoiseRMS = -1;
1208 
1209  // checks that elecNoise is valid
1210  if(elecNoiseRMS_tmp>0)
1211  totalNoiseRMS= std::sqrt((elecNoiseRMS_tmp*elecNoiseRMS_tmp) + (pileupNoiseRMS_tmp*pileupNoiseRMS_tmp) );
1212 
1213  return totalNoiseRMS;
1214 }
1215 
1217 
1218 float
1220  const float Nminbias)
1221 {
1222  return this->totalNoiseRMSHighestGain(caloCell->caloDDE(),Nminbias);
1223 }
1224 
1226 
1227 float
1229  const float Nminbias)
1230 {
1231  //getSubCalo can return 999999 (CaloCell_ID::SUBCALO::NOT_VALID)
1232  CaloCell_ID::SUBCALO iCalo = caloDDE->getSubCalo();
1233  if (iCalo == CaloCell_ID::SUBCALO::NOT_VALID){
1234  throw std::runtime_error("Invalid CaloID in CaloNoiseCompCondAlg::totalNoiseRMSHighestGain");
1235  }
1236  CaloGain::CaloGain highestGain=m_highestGain[iCalo];
1237  return this->totalNoiseRMS(caloDDE,highestGain,Nminbias);
1238 }
1239 
1240 
1243 
1244 float
1246  const CaloGain::CaloGain gain)
1247 {
1248 
1249  float factor=1.;
1250  IdentifierHash idCaloHash = caloDDE->calo_hash();
1251  CaloCell_ID::SUBCALO iCalo = this->caloNum(idCaloHash);
1252 
1253  if(iCalo==CaloCell_ID::LAREM || iCalo==CaloCell_ID::LARHEC)
1254  {
1255  int index=this->index(idCaloHash);
1256  factor=(m_adc2mevContainer[index])[gain];
1257  }
1258  else if(iCalo==CaloCell_ID::LARFCAL)
1259  {
1260  int index=this->index(idCaloHash);
1261  factor=(m_adc2mevContainer[index])[gain];
1262  }
1263  else if(iCalo==CaloCell_ID::TILE)
1264  {
1265  //TILE_PART
1266  MsgStream log( msgSvc(), name() );
1267  ATH_MSG_WARNING("CaloNoiseCompCondAlg::adc2mev(id,gain) : NOT IMPLEMENTED !" <<"for TILE (-> returns 1. for the moment)" );
1268  factor=1.;
1269  }
1270  else
1271  {
1272  MsgStream log( msgSvc(), name() );
1273  ATH_MSG_WARNING("CaloNoiseCompCondAlg::adc2mev(id,gain) wrong id ! " <<m_lar_em_id->show_to_string(caloDDE->identify()) );
1274  factor=0.;
1275  }
1276  return factor;
1277 }
1278 
1280 
1281 float
1283 {
1284  return adc2mev(m_calo_dd_man->get_element(id),gain);
1285 }
1286 
1287 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
CaloNoiseCompCondAlg::m_noiseKey
SG::ReadCondHandleKey< ILArNoise > m_noiseKey
Definition: CaloNoiseCompCondAlg.h:236
CaloNoiseCompCondAlg::m_ofccond
const ILArOFC * m_ofccond
Definition: CaloNoiseCompCondAlg.h:243
CaloCell_Base_ID::LARFCAL
@ LARFCAL
Definition: CaloCell_Base_ID.h:43
LArVectorProxy::valid
bool valid() const
Test to see if the proxy has been initialized.
GeV
#define GeV
Definition: PhysicsAnalysis/TauID/TauAnalysisTools/Root/HelperFunctions.cxx:18
CaloNoiseCompCondAlg::adc2mev
float adc2mev(const CaloDetDescrElement *caloDDE, const CaloGain::CaloGain gain)
Definition: CaloNoiseCompCondAlg.cxx:1245
pdg_comparison.sigma
sigma
Definition: pdg_comparison.py:324
CaloCell_Base_ID::calo_cell_hash
IdentifierHash calo_cell_hash(const Identifier cellId) const
create hash id from 'global' cell id
CaloNoiseCompCondAlg::updateDiagnostic
void updateDiagnostic(int reason, const std::string &reason_name, int igain, bool &noiseOK)
Definition: CaloNoiseCompCondAlg.cxx:1018
CaloNoiseCompCondAlg::m_highestGain
CaloGain::CaloGain m_highestGain[m_nCalos]
Definition: CaloNoiseCompCondAlg.h:167
CaloNoiseCompCondAlg::commonCalculations
void commonCalculations(float &OFC_AC_OFC, float &OFC_OFC, int icase, unsigned int firstSample=0)
Definition: CaloNoiseCompCondAlg.cxx:740
CaloNoiseCompCondAlg::m_noise
const ILArNoise * m_noise
Definition: CaloNoiseCompCondAlg.h:237
LArHEC_Base_ID::eta
int eta(const Identifier id) const
return eta [0,9] outer part [0,3] inner part
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
CaloCell_Base_ID::phi_min
int phi_min(const Identifier regId) const
min value of phi index (-999 == failure)
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
LArConditionsException.h
LArFCAL_Base_ID::pos_neg
int pos_neg(const Identifier id) const
pos_neg : +/- 2 (A/C side)
CaloNoiseCompCondAlg::m_indexContainer
std::vector< IdentifierHash > m_indexContainer
Definition: CaloNoiseCompCondAlg.h:260
CaloIDHelper::channel_hash_max
size_type channel_hash_max() const
One more than the largest channel (cell) hash code.
CaloNoiseCompCondAlg::initPileUpNoise
StatusCode initPileUpNoise()
Definition: CaloNoiseCompCondAlg.cxx:558
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:83
CaloNoiseCompCondAlg::m_LArOFCObjKey
SG::ReadCondHandleKey< ILArOFC > m_LArOFCObjKey
Definition: CaloNoiseCompCondAlg.h:242
index
Definition: index.py:1
CaloNoiseCompCondAlg::m_shapecond
const ILArShape * m_shapecond
Definition: CaloNoiseCompCondAlg.h:246
CaloGain::UNKNOWNGAIN
@ UNKNOWNGAIN
Definition: CaloGain.h:20
CaloNoiseCompCondAlg::m_lar_hec_id
const LArHEC_Base_ID * m_lar_hec_id
Definition: CaloNoiseCompCondAlg.h:184
min
constexpr double min()
Definition: ap_fixedTest.cxx:26
LArEM_Base_ID::region_id
Identifier region_id(const ExpandedIdentifier &exp_id) const
Build a cell identifier from an expanded identifier.
CaloNoiseCompCondAlg::m_lar_fcal_id
const LArFCAL_Base_ID * m_lar_fcal_id
Definition: CaloNoiseCompCondAlg.h:185
CaloNoiseCompCondAlg::m_elecNoiseRAWContainer
VectorContainer m_elecNoiseRAWContainer
Definition: CaloNoiseCompCondAlg.h:267
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
CaloIdManager::getEM_ID
const LArEM_ID * getEM_ID(void) const
Definition: CaloIdManager.cxx:80
CaloNoiseCompCondAlg::initIndex
StatusCode initIndex()
Definition: CaloNoiseCompCondAlg.cxx:282
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:109
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
CaloNoiseCompCondAlg::m_diagnostic
bool m_diagnostic[m_nGains]
Definition: CaloNoiseCompCondAlg.h:169
iSIGMANOISE
@ iSIGMANOISE
Definition: CaloNoiseCompCondAlg.h:38
IOVInfiniteRange::infiniteMixed
static EventIDRange infiniteMixed()
Produces an mixed EventIDRange that is infinite in Time and RunLumi.
Definition: IOVInfiniteRange.h:55
CaloNoise::ELEC
@ ELEC
Definition: CaloNoise.h:21
CaloNoiseCompCondAlg.h
skel.it
it
Definition: skel.GENtoEVGEN.py:407
CaloNoiseCompCondAlg::m_adc2mevContainer
VectorContainer m_adc2mevContainer
Definition: CaloNoiseCompCondAlg.h:270
CaloNoiseCompCondAlg::m_DiagnosticLG
BooleanProperty m_DiagnosticLG
Definition: CaloNoiseCompCondAlg.h:204
CaloNoiseCompCondAlg::m_UseSymmetry
BooleanProperty m_UseSymmetry
Definition: CaloNoiseCompCondAlg.h:201
LArFCAL_Base_ID::module
int module(const Identifier id) const
module [1,3]
CaloCell.h
CaloNoiseCompCondAlg::m_pileupNoiseContainer
SingleContainer m_pileupNoiseContainer
Definition: CaloNoiseCompCondAlg.h:269
LArEM_Base_ID::region
int region(const Identifier id) const
return region according to :
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
BADVALUE_TO_RETURN
@ BADVALUE_TO_RETURN
Definition: CaloNoiseCompCondAlg.h:37
CaloNoiseCompCondAlg::m_nReason
int m_nReason[5000][m_nGains]
Definition: CaloNoiseCompCondAlg.h:171
CaloCell_Base_ID::LARHEC
@ LARHEC
Definition: CaloCell_Base_ID.h:43
CaloNoiseCompCondAlg::m_cabling
const LArOnOffIdMapping * m_cabling
Definition: CaloNoiseCompCondAlg.h:229
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::VarHandleKey::empty
bool empty() const
Test if the key is blank.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:150
CaloNoiseCompCondAlg::calculatePileUpNoise
float calculatePileUpNoise(const IdentifierHash &idCaloHash, const float &Nminbias)
Definition: CaloNoiseCompCondAlg.cxx:677
HWIdentifier
Definition: HWIdentifier.h:13
CaloGain::LARNGAIN
@ LARNGAIN
Definition: CaloGain.h:19
LArHEC_Base_ID::region_id
Identifier region_id(const ExpandedIdentifier &exp_id) const
region identifier for a channel from ExpandedIdentifier
CaloNoiseCompCondAlg::m_Adc2MeVFactor
float m_Adc2MeVFactor
Definition: CaloNoiseCompCondAlg.h:213
iAUTOCORR
@ iAUTOCORR
Definition: CaloNoiseCompCondAlg.h:38
LArEM_Base_ID::channel_id
Identifier channel_id(const ExpandedIdentifier &exp_id) const
Build a cell identifier from an expanded identifier.
CaloNoiseCompCondAlg::m_lar_em_id
const LArEM_Base_ID * m_lar_em_id
Definition: CaloNoiseCompCondAlg.h:183
CaloGain::TILELOWLOW
@ TILELOWLOW
Definition: CaloGain.h:12
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
LArEM_Base_ID::eta
int eta(const Identifier id) const
return eta according to :
ILArAutoCorr::autoCorr
virtual AutoCorrRef_t autoCorr(const HWIdentifier &CellID, int gain) const =0
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
LArFCAL_Base_ID::eta
int eta(const Identifier id) const
eta [0,63] module 1 ; [0,31] module 2 ; [0,15] module 3
CaloNoiseCompCondAlg::m_AutoCorr
LArVectorProxy m_AutoCorr
Definition: CaloNoiseCompCondAlg.h:216
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
CaloNoiseCompCondAlg::m_shapeKey
SG::ReadCondHandleKey< ILArShape > m_shapeKey
Definition: CaloNoiseCompCondAlg.h:245
CaloDetDescrElement::getSubCalo
CaloCell_ID::SUBCALO getSubCalo() const
cell subcalo
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:433
CaloNoiseCompCondAlg::retrieveCellDatabase
StatusCode retrieveCellDatabase(const IdentifierHash &idCaloHash, const Identifier &id, int igain, std::vector< bool > &retrieve)
Definition: CaloNoiseCompCondAlg.cxx:793
CaloGain::TILEHIGHHIGH
@ TILEHIGHHIGH
Definition: CaloGain.h:15
CaloNoiseCompCondAlg::m_firstSample
UnsignedIntegerProperty m_firstSample
Definition: CaloNoiseCompCondAlg.h:200
CaloNoiseCompCondAlg::m_reason
int m_reason[5000][10][m_nGains]
Definition: CaloNoiseCompCondAlg.h:174
CaloGain::INVALIDGAIN
@ INVALIDGAIN
Definition: CaloGain.h:18
iOFC
@ iOFC
Definition: CaloNoiseCompCondAlg.h:38
python.PyAthena.module
module
Definition: PyAthena.py:131
LArFCAL_Base_ID::phi
int phi(const Identifier id) const
phi [0,15]
CaloNoiseCompCondAlg::initAdc2MeV
StatusCode initAdc2MeV(const LArADC2MeV *adc2mev)
Definition: CaloNoiseCompCondAlg.cxx:480
CaloDetDescrElement::identify
Identifier identify() const override final
cell identifier
Definition: CaloDetDescrElement.cxx:63
CaloNoiseCompCondAlg::index
int index(const IdentifierHash &idCaloHash)
Definition: CaloNoiseCompCondAlg.cxx:429
CaloNoiseCompCondAlg::m_LowGainThresh
float m_LowGainThresh[m_nCalos]
Definition: CaloNoiseCompCondAlg.h:165
CaloNoiseCompCondAlg::m_CaloHashMin
IdentifierHash m_CaloHashMin
Definition: CaloNoiseCompCondAlg.h:194
CaloIdManager::getHEC_ID
const LArHEC_ID * getHEC_ID(void) const
Definition: CaloIdManager.cxx:95
CaloDetDescrElement::calo_hash
IdentifierHash calo_hash() const
cell calo hash
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:412
iADC2MEV
@ iADC2MEV
Definition: CaloNoiseCompCondAlg.h:38
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CaloNoiseCompCondAlg::initElecNoise
StatusCode initElecNoise()
Definition: CaloNoiseCompCondAlg.cxx:512
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
lumiFormat.i
int i
Definition: lumiFormat.py:85
CaloNoiseCompCondAlg::checkCellDatabase
StatusCode checkCellDatabase(const Identifier &id, int igain, std::vector< bool > &retrieve)
Definition: CaloNoiseCompCondAlg.cxx:881
CaloNoiseCompCondAlg::checkIfConnected
bool checkIfConnected(const Identifier &id)
Definition: CaloNoiseCompCondAlg.cxx:411
CaloGain::TILEONELOW
@ TILEONELOW
Definition: CaloGain.h:16
endmsg
#define endmsg
Definition: AnalysisConfig_Ntuple.cxx:63
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
CaloNoiseCompCondAlg::m_calo_id_man
const CaloIdManager * m_calo_id_man
Definition: CaloNoiseCompCondAlg.h:181
iFSAMPL
@ iFSAMPL
Definition: CaloNoiseCompCondAlg.h:39
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
ILArfSampl::FSAMPL
virtual const float & FSAMPL(const HWIdentifier &id) const =0
CaloNoiseCompCondAlg::m_MinBiasRMS
float m_MinBiasRMS
Definition: CaloNoiseCompCondAlg.h:223
CaloNoiseCompCondAlg::elecNoiseRMS
float elecNoiseRMS(const CaloCell *caloCell)
Definition: CaloNoiseCompCondAlg.cxx:1139
CaloCell::caloDDE
const CaloDetDescrElement * caloDDE() const
get pointer to CaloDetDescrElement (data member)
Definition: CaloCell.h:315
LArFCAL_Base_ID::channel_id
Identifier channel_id(const ExpandedIdentifier &exp_id) const
cell identifier for a channel from ExpandedIdentifier
CaloCell_Base_ID::SUBCALO
SUBCALO
enumeration of sub calorimeters
Definition: CaloCell_Base_ID.h:43
CaloNoiseCompCondAlg::pileupNoiseRMS
float pileupNoiseRMS(const CaloCell *caloCell, const float Nminbias=-1)
Definition: CaloNoiseCompCondAlg.cxx:1147
CaloNoiseCompCondAlg::elecNoiseRMS3gains
std::vector< float > elecNoiseRMS3gains(const CaloDetDescrElement *caloDDE)
Definition: CaloNoiseCompCondAlg.cxx:1121
CaloIdManager::getFCAL_ID
const LArFCAL_ID * getFCAL_ID(void) const
Definition: CaloIdManager.cxx:85
CaloNoiseCompCondAlg::execute
virtual StatusCode execute() override final
standard Athena-Algorithm method
Definition: CaloNoiseCompCondAlg.cxx:110
ILArNoise::noise
virtual const float & noise(const HWIdentifier &id, int gain) const =0
CaloNoiseCompCondAlg::CaloNoiseCompCondAlg
CaloNoiseCompCondAlg(const std::string &name, ISvcLocator *pSvcLocator)
Standard Athena-Algorithm Constructor.
Definition: CaloNoiseCompCondAlg.cxx:23
CalibDbCompareRT.dummy
dummy
Definition: CalibDbCompareRT.py:59
CaloNoiseCompCondAlg::m_calo_dd_man
const CaloDetDescrManager * m_calo_dd_man
Definition: CaloNoiseCompCondAlg.h:226
LArElecCalib::ERRORCODE
@ ERRORCODE
Definition: LArCalibErrorCode.h:17
LArFCAL_Base_ID::module_id
Identifier module_id(const ExpandedIdentifier &exp_id) const
module identifier for a channel from ExpandedIdentifier
CaloNoiseCompCondAlg::m_LArHashMax
IdentifierHash m_LArHashMax
Definition: CaloNoiseCompCondAlg.h:191
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
CaloNoiseCompCondAlg::initContainers
StatusCode initContainers()
Definition: CaloNoiseCompCondAlg.cxx:258
AtlasDetectorID::is_lar_hec
bool is_lar_hec(Identifier id) const
Definition: AtlasDetectorID.h:836
CaloCell_Base_ID::TILE
@ TILE
Definition: CaloCell_Base_ID.h:43
WriteCellNoiseToCool.igain
igain
Definition: WriteCellNoiseToCool.py:338
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
CaloNoiseCompCondAlg::m_ped
const ILArPedestal * m_ped
Definition: CaloNoiseCompCondAlg.h:234
DeMoUpdate.tmp
string tmp
Definition: DeMoUpdate.py:1167
CaloGain::TILEHIGHLOW
@ TILEHIGHLOW
Definition: CaloGain.h:14
CaloNoiseCompCondAlg::m_outputElecKey
SG::WriteCondHandleKey< CaloNoise > m_outputElecKey
Definition: CaloNoiseCompCondAlg.h:255
LArOnOffIdMapping::createSignalChannelID
HWIdentifier createSignalChannelID(const Identifier &id) const
create a HWIdentifier from an Identifier (not inline)
Definition: LArOnOffIdMapping.h:126
AthAlgorithm
Definition: AthAlgorithm.h:47
CaloNoiseCompCondAlg::m_fSamplKey
SG::ReadCondHandleKey< ILArfSampl > m_fSamplKey
Definition: CaloNoiseCompCondAlg.h:248
CaloNoiseCompCondAlg::m_DiagnosticMG
BooleanProperty m_DiagnosticMG
Definition: CaloNoiseCompCondAlg.h:203
BADVALUE
@ BADVALUE
Definition: CaloNoiseCompCondAlg.h:37
CaloNoiseCompCondAlg::m_LArMinBiasObjKey
SG::ReadCondHandleKey< ILArMinBias > m_LArMinBiasObjKey
Definition: CaloNoiseCompCondAlg.h:251
CaloNoiseCompCondAlg::totalNoiseRMS
float totalNoiseRMS(const CaloCell *caloCell, const float Nminbias=-1)
Definition: CaloNoiseCompCondAlg.cxx:1155
CaloNoiseCompCondAlg::m_DiagnosticHG
BooleanProperty m_DiagnosticHG
Definition: CaloNoiseCompCondAlg.h:202
CaloNoiseCompCondAlg::m_fSampl
float m_fSampl
Definition: CaloNoiseCompCondAlg.h:221
IOVInfiniteRange.h
CaloGain::TILELOWHIGH
@ TILELOWHIGH
Definition: CaloGain.h:13
xAOD::VxType::PileUp
@ PileUp
Pile-up vertex.
Definition: TrackingPrimitives.h:574
CaloNoiseCompCondAlg::m_Nminbias
FloatProperty m_Nminbias
Definition: CaloNoiseCompCondAlg.h:208
id
SG::auxid_t id
Definition: Control/AthContainers/Root/debug.cxx:239
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
CaloNoiseCompCondAlg::m_HighGainThresh
float m_HighGainThresh[m_nCalos]
Definition: CaloNoiseCompCondAlg.h:166
LArEM_Base_ID::barrel_ec
int barrel_ec(const Identifier id) const
return barrel_ec according to :
CaloNoiseCompCondAlg::m_idHash
int m_idHash[5000][m_nGains]
Definition: CaloNoiseCompCondAlg.h:173
CaloCell::gain
CaloGain::CaloGain gain() const
get gain (data member )
Definition: CaloCell.h:355
LArHEC_Base_ID::channel_id
Identifier channel_id(const ExpandedIdentifier &exp_id) const
channel identifier for a channel from ExpandedIdentifier
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
CaloNoiseCompCondAlg::m_minbias
const ILArMinBias * m_minbias
Definition: CaloNoiseCompCondAlg.h:252
CaloNoiseCompCondAlg::m_reasonName
std::string m_reasonName[10]
Definition: CaloNoiseCompCondAlg.h:176
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
CaloCell_Base_ID::cell_id
Identifier cell_id(const int subCalo, const int barec_or_posneg, const int sampling_or_fcalmodule, const int region_or_dummy, const int eta, const int phi) const
Make a cell (== channel) ID from constituting fields and subCalo index; for (Mini)FCAL,...
TileRawChannelUnit.h
CaloNoiseCompCondAlg::m_adc2mevKey
SG::ReadCondHandleKey< LArADC2MeV > m_adc2mevKey
Definition: CaloNoiseCompCondAlg.h:231
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
CaloNoiseCompCondAlg::initData
StatusCode initData(const LArADC2MeV *adc2mev)
Definition: CaloNoiseCompCondAlg.cxx:438
CaloNoiseCompCondAlg::totalNoiseRMSHighestGain
float totalNoiseRMSHighestGain(const CaloCell *caloCell, const float Nminbias=-1)
Definition: CaloNoiseCompCondAlg.cxx:1219
CaloNoise::PILEUP
@ PILEUP
Definition: CaloNoise.h:22
python.SUBCALO.NOT_VALID
int NOT_VALID
Definition: SUBCALO.py:14
LArADC2MeV
Definition: LArADC2MeV.h:21
CaloGain::LARMEDIUMGAIN
@ LARMEDIUMGAIN
Definition: CaloGain.h:18
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
CaloNoiseCompCondAlg::m_RMSpedestal
float m_RMSpedestal
Definition: CaloNoiseCompCondAlg.h:218
CaloNoiseCompCondAlg::m_nCellsWithProblem
int m_nCellsWithProblem[m_nGains]
Definition: CaloNoiseCompCondAlg.h:170
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:360
CaloNoiseCompCondAlg::m_pedestalKey
SG::ReadCondHandleKey< ILArPedestal > m_pedestalKey
Definition: CaloNoiseCompCondAlg.h:233
CaloNoiseCompCondAlg::m_acorrKey
SG::ReadCondHandleKey< ILArAutoCorr > m_acorrKey
Definition: CaloNoiseCompCondAlg.h:239
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
CaloNoise::larStorage
boost::multi_array< float, 2 > & larStorage()
Non-const accessor to underlying storage for filling:
Definition: CaloNoise.h:71
ILArMinBias::minBiasRMS
virtual const float & minBiasRMS(const HWIdentifier &id) const =0
access to RMS of E in minimum bias events index by Identifier
DEBUG
#define DEBUG
Definition: page_access.h:11
LArHEC_Base_ID::sampling
int sampling(const Identifier id) const
return sampling [0,3] (only 0 for supercells)
CaloNoiseCompCondAlg::initialize
virtual StatusCode initialize() override final
standard Athena-Algorithm method
Definition: CaloNoiseCompCondAlg.cxx:45
python.CaloCondTools.log
log
Definition: CaloCondTools.py:20
CaloIdManager::getCaloCell_SuperCell_ID
const CaloCell_SuperCell_ID * getCaloCell_SuperCell_ID(void) const
Definition: CaloIdManager.cxx:110
LArHEC_Base_ID::pos_neg
int pos_neg(const Identifier id) const
return pos_neg -2 (C side) or 2 (A side)
CaloNoiseCompCondAlg::m_nsamples
int m_nsamples
Definition: CaloNoiseCompCondAlg.h:219
CaloNoiseCompCondAlg::m_acorr
const ILArAutoCorr * m_acorr
Definition: CaloNoiseCompCondAlg.h:240
CaloDetDescrManager::getCaloCell_ID
const CaloCell_ID * getCaloCell_ID() const
get calo cell ID helper
Definition: CaloDetDescrManager.cxx:1590
ILArOFC::OFC_a
virtual OFCRef_t OFC_a(const HWIdentifier &id, int gain, int tbin=0) const =0
access to OFCs by online ID, gain, and tbin (!=0 for testbeam)
CaloNoiseCompCondAlg::m_Shape
LArVectorProxy m_Shape
Definition: CaloNoiseCompCondAlg.h:215
CaloNoiseCompCondAlg::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: CaloNoiseCompCondAlg.h:225
CaloNoiseCompCondAlg::m_elecNoiseCELLContainer
VectorContainer m_elecNoiseCELLContainer
Definition: CaloNoiseCompCondAlg.h:268
CaloIdManager.h
CaloNoiseCompCondAlg::calculateElecNoiseForLAR
std::vector< float > calculateElecNoiseForLAR(const IdentifierHash &idCaloHash)
Definition: CaloNoiseCompCondAlg.cxx:578
CaloNoiseCompCondAlg::m_idSymmCaloHashContainer
std::vector< IdentifierHash > m_idSymmCaloHashContainer
Definition: CaloNoiseCompCondAlg.h:263
iSHAPE
@ iSHAPE
Definition: CaloNoiseCompCondAlg.h:38
CaloNoiseCompCondAlg::m_nGains
static constexpr int m_nGains
Definition: CaloNoiseCompCondAlg.h:164
nDATABASE
@ nDATABASE
Definition: CaloNoiseCompCondAlg.h:39
CaloNoiseCompCondAlg::isBadValue
bool isBadValue(float tested_value)
Definition: CaloNoiseCompCondAlg.h:314
CaloNoiseCompCondAlg::m_c
float m_c[32][32]
Definition: CaloNoiseCompCondAlg.h:217
CaloNoiseCompCondAlg::m_outputPileupKey
SG::WriteCondHandleKey< CaloNoise > m_outputPileupKey
Definition: CaloNoiseCompCondAlg.h:256
CaloNoiseCompCondAlg::m_deltaBunch
IntegerProperty m_deltaBunch
Definition: CaloNoiseCompCondAlg.h:199
CaloGain::LARLOWGAIN
@ LARLOWGAIN
Definition: CaloGain.h:18
IdentifierHash
This is a "hash" representation of an Identifier. This encodes a 32 bit index which can be used to lo...
Definition: IdentifierHash.h:25
CaloCell_Base_ID::LAREM
@ LAREM
Definition: CaloCell_Base_ID.h:43
CaloNoiseCompCondAlg::m_calosupercell_id
const CaloCell_SuperCell_ID * m_calosupercell_id
Definition: CaloNoiseCompCondAlg.h:189
IGeoModelSvc.h
ILArPedestal::pedestalRMS
virtual float pedestalRMS(const HWIdentifier &id, int gain) const =0
access to RMS of Pedestal index by Identifier, and gain setting
ReadOfcFromCool.ofc
ofc
Definition: ReadOfcFromCool.py:110
iMINBIASRMS
@ iMINBIASRMS
Definition: CaloNoiseCompCondAlg.h:39
LArHEC_Base_ID::region
int region(const Identifier id) const
return region [0,1]
SG::WriteCondHandle
Definition: WriteCondHandle.h:26
CaloNoiseCompCondAlg::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: CaloNoiseCompCondAlg.h:228
CaloGain::TILEONEHIGH
@ TILEONEHIGH
Definition: CaloGain.h:17
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
CaloNoiseCompCondAlg::m_itReason
int m_itReason[10][m_nGains]
Definition: CaloNoiseCompCondAlg.h:172
LArOnOffIdMapping::isOnlineConnected
bool isOnlineConnected(const HWIdentifier &sid) const
Test whether a HWIdentifier is connected of not (inline)
Definition: LArOnOffIdMapping.h:121
CaloNoiseCompCondAlg::m_fsamplcond
const ILArfSampl * m_fsamplcond
Definition: CaloNoiseCompCondAlg.h:249
CaloNoiseCompCondAlg::m_calocell_id
const CaloCell_ID * m_calocell_id
Definition: CaloNoiseCompCondAlg.h:188
fitman.k
k
Definition: fitman.py:528
CaloNoiseCompCondAlg::caloNum
CaloCell_ID::SUBCALO caloNum(const IdentifierHash idCaloHash)
Definition: CaloNoiseCompCondAlg.h:323
python.LArMinBiasAlgConfig.float
float
Definition: LArMinBiasAlgConfig.py:65
ILArShape::Shape
virtual ShapeRef_t Shape(const HWIdentifier &id, int gain, int tbin=0, int mode=0) const =0
CaloNoiseCompCondAlg::m_SigmaNoise
float m_SigmaNoise
Definition: CaloNoiseCompCondAlg.h:220
CaloNoiseCompCondAlg::m_CaloHashMax
IdentifierHash m_CaloHashMax
Definition: CaloNoiseCompCondAlg.h:193
CaloNoiseCompCondAlg::m_OFC
LArVectorProxy m_OFC
Definition: CaloNoiseCompCondAlg.h:214
Identifier
Definition: IdentifierFieldParser.cxx:14