ATLAS Offline Software
Public Member Functions | Protected Member Functions | Private Types | Private Member Functions | Private Attributes | Static Private Attributes | List of all members
CaloNoiseCompCondAlg Class Reference

algo to compute electronic and pile up noise in MeV @ based on old CaloNoiseTool, only WorkMode=1 implemented More...

#include <CaloNoiseCompCondAlg.h>

Inheritance diagram for CaloNoiseCompCondAlg:
Collaboration diagram for CaloNoiseCompCondAlg:

Public Member Functions

 CaloNoiseCompCondAlg (const std::string &name, ISvcLocator *pSvcLocator)
 Standard Athena-Algorithm Constructor. More...
 
virtual ~CaloNoiseCompCondAlg ()=default
 Default Destructor. More...
 
virtual StatusCode initialize () override final
 standard Athena-Algorithm method More...
 
virtual StatusCode execute () override final
 standard Athena-Algorithm method More...
 
virtual StatusCode finalize () override final
 standard Athena-Algorithm method More...
 
float elecNoiseRMS (const CaloCell *caloCell)
 
float elecNoiseRMS (const CaloDetDescrElement *caloDDE, const CaloGain::CaloGain gain)
 
std::vector< float > elecNoiseRMS3gains (const CaloDetDescrElement *caloDDE)
 
float pileupNoiseRMS (const CaloCell *caloCell, const float Nminbias=-1)
 
float pileupNoiseRMS (const CaloDetDescrElement *caloDDE, const float Nminbias=-1)
 
float totalNoiseRMS (const CaloCell *caloCell, const float Nminbias=-1)
 
float totalNoiseRMS (const CaloDetDescrElement *caloDDE, const CaloGain::CaloGain gain, const float Nminbias=-1)
 
float totalNoiseRMSHighestGain (const CaloCell *caloCell, const float Nminbias=-1)
 
float totalNoiseRMSHighestGain (const CaloDetDescrElement *caloDDE, const float Nminbias=-1)
 
CaloGain::CaloGain estimatedGain (const CaloCell *caloCell)
 
CaloGain::CaloGain estimatedGain (const CaloCell *caloCell, const CaloDetDescrElement *caloDDE)
 
CaloGain::CaloGain estimatedGain (const CaloDetDescrElement *caloDDE, const float &energy)
 
float adc2mev (const CaloDetDescrElement *caloDDE, const CaloGain::CaloGain gain)
 
float adc2mev (const Identifier &id, const CaloGain::CaloGain gain)
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T, V, H > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode initContainers ()
 
StatusCode initData (const LArADC2MeV *adc2mev)
 
StatusCode initIndex ()
 
StatusCode initAdc2MeV (const LArADC2MeV *adc2mev)
 
StatusCode initElecNoise ()
 
StatusCode initPileUpNoise ()
 
bool checkIfConnected (const Identifier &id)
 
void commonCalculations (float &OFC_AC_OFC, float &OFC_OFC, int icase, unsigned int firstSample=0)
 
StatusCode retrieveCellDatabase (const IdentifierHash &idCaloHash, const Identifier &id, int igain, std::vector< bool > &retrieve)
 
StatusCode checkCellDatabase (const Identifier &id, int igain, std::vector< bool > &retrieve)
 
void updateDiagnostic (int reason, const std::string &reason_name, int igain, bool &noiseOK)
 
std::vector< float > calculateElecNoiseForLAR (const IdentifierHash &idCaloHash)
 
float calculatePileUpNoise (const IdentifierHash &idCaloHash, const float &Nminbias)
 
int index (const IdentifierHash &idCaloHash)
 
CaloCell_ID::SUBCALO caloNum (const IdentifierHash idCaloHash)
 
bool isBadValue (float tested_value)
 
CaloGain::CaloGain estimatedLArGain (const CaloCell_ID::SUBCALO &iCalo, const CaloDetDescrElement *caloDDE, const float &energy)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T, V, H > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

std::string m_ReturnNoiseName
 
float m_LowGainThresh [m_nCalos] {}
 
float m_HighGainThresh [m_nCalos] {}
 
CaloGain::CaloGain m_highestGain [m_nCalos] {}
 
bool m_diagnostic [m_nGains] {}
 
int m_nCellsWithProblem [m_nGains] {}
 
int m_nReason [5000][m_nGains] {}
 
int m_itReason [10][m_nGains] {}
 
int m_idHash [5000][m_nGains] {}
 
int m_reason [5000][10][m_nGains] {}
 
std::string m_reasonName [10]
 
const AtlasDetectorID * m_atlas_id {}
 
const CaloIdManager * m_calo_id_man {}
 
const LArEM_Base_ID * m_lar_em_id {}
 
const LArHEC_Base_ID * m_lar_hec_id {}
 
const LArFCAL_Base_ID * m_lar_fcal_id {}
 
const CaloCell_ID * m_calocell_id {}
 
const CaloCell_SuperCell_ID * m_calosupercell_id {}
 
IdentifierHash m_LArHashMax
 
IdentifierHash m_TileHashMax
 
IdentifierHash m_CaloHashMax
 
IdentifierHash m_CaloHashMin
 
IntegerProperty m_deltaBunch {this, "deltaBunch", 1}
 
UnsignedIntegerProperty m_firstSample {this, "firstSample", 0}
 
BooleanProperty m_UseSymmetry {this, "UseSymmetry", true}
 
BooleanProperty m_DiagnosticHG {this, "DiagnosticHG", false}
 
BooleanProperty m_DiagnosticMG {this, "DiagnosticMG", false}
 
BooleanProperty m_DiagnosticLG {this, "DiagnosticLG", false}
 
BooleanProperty m_DumpDatabaseHG {this, "DumpDatabaseHG", false}
 
BooleanProperty m_DumpDatabaseMG {this, "DumpDatabaseMG", false}
 
BooleanProperty m_DumpDatabaseLG {this, "DumpDatabaseLG", false}
 
FloatProperty m_Nminbias {this, "NMinBias", -1}
 
float m_Adc2MeVFactor {}
 
LArVectorProxy m_OFC
 
LArVectorProxy m_Shape
 
LArVectorProxy m_AutoCorr
 
float m_c [32][32] {}
 
float m_RMSpedestal {}
 
int m_nsamples {}
 
float m_SigmaNoise {}
 
float m_fSampl {}
 
double m_AdcPerMev {}
 
float m_MinBiasRMS {}
 
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager", "SG Key for CaloDetDescrManager in the Condition Store" }
 
const CaloDetDescrManager * m_calo_dd_man =nullptr
 
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
 
const LArOnOffIdMapping * m_cabling =nullptr
 
SG::ReadCondHandleKey< LArADC2MeV > m_adc2mevKey {this, "ADC2MeVKey", "LArADC2MeV", "SG Key of the LArADC2MeV CDO" }
 
SG::ReadCondHandleKey< ILArPedestal > m_pedestalKey {this,"PedestalKey","LArPedestal","SG Key of LArPedestal object"}
 
const ILArPedestal * m_ped =nullptr
 
SG::ReadCondHandleKey< ILArNoise > m_noiseKey {this,"NoiseKey","","SG Key of LArNoise object"}
 
const ILArNoise * m_noise =nullptr
 
SG::ReadCondHandleKey< ILArAutoCorr > m_acorrKey {this,"AutocorrKey","LArAutoCorrSym","SG Key of LArAutoCorr object"}
 
const ILArAutoCorr * m_acorr =nullptr
 
SG::ReadCondHandleKey< ILArOFC > m_LArOFCObjKey {this, "OFKey","LArOFC", "SG Key of LAr OFCs"}
 
const ILArOFC * m_ofccond =nullptr
 
SG::ReadCondHandleKey< ILArShape > m_shapeKey {this,"ShapeKey","LArShapeSym","SG Key of Shape conditions object"}
 
const ILArShape * m_shapecond =nullptr
 
SG::ReadCondHandleKey< ILArfSampl > m_fSamplKey {this,"fSamplKey","LArfSamplSym","SG Key of LArfSampl object"}
 
const ILArfSampl * m_fsamplcond = nullptr
 
SG::ReadCondHandleKey< ILArMinBias > m_LArMinBiasObjKey {this, "LArMinBiasKey", "LArMinBiasSym", "SG Key of LArMinBias"}
 
const ILArMinBias * m_minbias = nullptr
 
SG::WriteCondHandleKey< CaloNoise > m_outputElecKey {this, "OutputElecKey", "elecNoise", "SG Key of resulting noise CDO"}
 
SG::WriteCondHandleKey< CaloNoise > m_outputPileupKey {this, "OutputPileupKey", "pileupNoise", "SG Key of resulting noise CDO"}
 
std::vector< IdentifierHash > m_indexContainer
 
std::vector< IdentifierHash > m_idSymmCaloHashContainer
 
VectorContainer m_elecNoiseRAWContainer
 
VectorContainer m_elecNoiseCELLContainer
 
SingleContainer m_pileupNoiseContainer
 
VectorContainer m_adc2mevContainer
 
DataObjIDColl m_extendedExtraObjects
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Static Private Attributes

static constexpr int m_nCalos =NCALOS
 
static constexpr int m_nGains =NGAINS
 

Detailed Description

algo to compute electronic and pile up noise in MeV @ based on old CaloNoiseTool, only WorkMode=1 implemented

Definition at line 60 of file CaloNoiseCompCondAlg.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< Algorithm > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

◆ CaloNoiseCompCondAlg()

CaloNoiseCompCondAlg::CaloNoiseCompCondAlg ( const std::string &  name,
ISvcLocator *  pSvcLocator 
)

Standard Athena-Algorithm Constructor.

Definition at line 23 of file CaloNoiseCompCondAlg.cxx.

23  :
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 }

◆ ~CaloNoiseCompCondAlg()

virtual CaloNoiseCompCondAlg::~CaloNoiseCompCondAlg ( )
virtualdefault

Default Destructor.

Member Function Documentation

◆ adc2mev() [1/2]

float CaloNoiseCompCondAlg::adc2mev ( const CaloDetDescrElement *  caloDDE,
const CaloGain::CaloGain  gain 
)

Definition at line 1245 of file CaloNoiseCompCondAlg.cxx.

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 }

◆ adc2mev() [2/2]

float CaloNoiseCompCondAlg::adc2mev ( const Identifier &  id,
const CaloGain::CaloGain  gain 
)

Definition at line 1282 of file CaloNoiseCompCondAlg.cxx.

1283 {
1284  return adc2mev(m_calo_dd_man->get_element(id),gain);
1285 }

◆ calculateElecNoiseForLAR()

std::vector< float > CaloNoiseCompCondAlg::calculateElecNoiseForLAR ( const IdentifierHash &  idCaloHash)
private

Definition at line 578 of file CaloNoiseCompCondAlg.cxx.

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()) {
627  sigma=float(BADVALUE_TO_RETURN);
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;
659  ++m_nCellsWithProblem[igain];
660  m_nReason[m_nCellsWithProblem[igain]][igain]=0;
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 }

◆ calculatePileUpNoise()

float CaloNoiseCompCondAlg::calculatePileUpNoise ( const IdentifierHash &  idCaloHash,
const float &  Nminbias 
)
private

Definition at line 677 of file CaloNoiseCompCondAlg.cxx.

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,
708  CaloGain::LARHIGHGAIN,retrieve);
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 ...
715  m_MinBiasRMS /= m_fSampl;
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 }

◆ caloNum()

CaloCell_ID::SUBCALO CaloNoiseCompCondAlg::caloNum ( const IdentifierHash  idCaloHash)
inlineprivate

Definition at line 323 of file CaloNoiseCompCondAlg.h.

324 {
325  return
326  static_cast<CaloCell_ID::SUBCALO>(m_calocell_id->sub_calo(idCaloHash));
327 }

◆ checkCellDatabase()

StatusCode CaloNoiseCompCondAlg::checkCellDatabase ( const Identifier &  id,
int  igain,
std::vector< bool > &  retrieve 
)
private

Definition at line 881 of file CaloNoiseCompCondAlg.cxx.

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
981  if(retrieve[iOFC] && retrieve[iAUTOCORR]
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 }

◆ checkIfConnected()

bool CaloNoiseCompCondAlg::checkIfConnected ( const Identifier &  id)
private

Definition at line 411 of file CaloNoiseCompCondAlg.cxx.

412 {
413  try
414  {
415  HWIdentifier hwid = m_cabling->createSignalChannelID(id);
416  if(!m_cabling->isOnlineConnected(hwid))
417  {
418  return false;
419  }
420  }
421  catch(LArID_Exception & except)
422  {return false;}
423  return true;
424 }

◆ commonCalculations()

void CaloNoiseCompCondAlg::commonCalculations ( float &  OFC_AC_OFC,
float &  OFC_OFC,
int  icase,
unsigned int  firstSample = 0 
)
private

Definition at line 740 of file CaloNoiseCompCondAlg.cxx.

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 }

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareGaudiProperty ( Gaudi::Property< T, V, H > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty ( Gaudi::Property< T, V, H > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ elecNoiseRMS() [1/2]

float CaloNoiseCompCondAlg::elecNoiseRMS ( const CaloCell *  caloCell)

Definition at line 1139 of file CaloNoiseCompCondAlg.cxx.

1139  {
1140  const CaloDetDescrElement* caloDDE = theCell->caloDDE();
1141  CaloGain::CaloGain igain = theCell->gain();
1142  return this->elecNoiseRMS(caloDDE, igain);
1143 }

◆ elecNoiseRMS() [2/2]

float CaloNoiseCompCondAlg::elecNoiseRMS ( const CaloDetDescrElement *  caloDDE,
const CaloGain::CaloGain  gain 
)

Definition at line 1040 of file CaloNoiseCompCondAlg.cxx.

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 
1071  if (gain==CaloGain::INVALIDGAIN || gain==CaloGain::UNKNOWNGAIN) {
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 }

◆ elecNoiseRMS3gains()

std::vector< float > CaloNoiseCompCondAlg::elecNoiseRMS3gains ( const CaloDetDescrElement *  caloDDE)

Definition at line 1121 of file CaloNoiseCompCondAlg.cxx.

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]) &&
1130  igain!=CaloGain::LARHIGHGAIN)
1131  sigma[igain]=sigma[igain-1];//take the next gain (low->medium->high)
1132  return sigma;
1133 }

◆ estimatedGain() [1/3]

CaloGain::CaloGain CaloNoiseCompCondAlg::estimatedGain ( const CaloCell *  caloCell)

◆ estimatedGain() [2/3]

CaloGain::CaloGain CaloNoiseCompCondAlg::estimatedGain ( const CaloCell *  caloCell,
const CaloDetDescrElement *  caloDDE 
)

◆ estimatedGain() [3/3]

CaloGain::CaloGain CaloNoiseCompCondAlg::estimatedGain ( const CaloDetDescrElement *  caloDDE,
const float &  energy 
)

◆ estimatedLArGain()

CaloGain::CaloGain CaloNoiseCompCondAlg::estimatedLArGain ( const CaloCell_ID::SUBCALO &  iCalo,
const CaloDetDescrElement *  caloDDE,
const float &  energy 
)
private

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode CaloNoiseCompCondAlg::execute ( )
finaloverridevirtual

standard Athena-Algorithm method

Definition at line 110 of file CaloNoiseCompCondAlg.cxx.

110  {
111 
112  const EventContext& ctx = Gaudi::Hive::currentContext();
113 
114  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
115  if(!caloMgrHandle.isValid()) {
116  ATH_MSG_ERROR( "Do not have CaloDetDescrMgr");
117  return StatusCode::FAILURE;
118  }
119 
120  m_calo_dd_man = *caloMgrHandle;
121  m_calocell_id = m_calo_dd_man->getCaloCell_ID();
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 
148  SG::ReadCondHandle<LArADC2MeV> adc2mevHdl (m_adc2mevKey, ctx);
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()) {
158  auto pedHdl=SG::ReadCondHandle<ILArPedestal>(m_pedestalKey, ctx);
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 
184  auto ofcHdl=SG::ReadCondHandle<ILArOFC>(m_LArOFCObjKey, ctx);
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 
211  auto minbiasHdl=SG::ReadCondHandle<ILArMinBias>(m_LArMinBiasObjKey, ctx);
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,
223  m_calocell_id,CaloNoise::ELEC);
224  std::unique_ptr<CaloNoise> pileupNoiseObj=std::make_unique<CaloNoise>(m_LArHashMax,m_nGains, 0,4,
225  m_calocell_id,CaloNoise::PILEUP);
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 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

This list is extended to include symlinks implied by inheritance relations.

Definition at line 50 of file AthAlgorithm.cxx.

51 {
52  // If we didn't find any symlinks to add, just return the collection
53  // from the base class. Otherwise, return the extended collection.
54  if (!m_extendedExtraObjects.empty()) {
55  return m_extendedExtraObjects;
56  }
57  return Algorithm::extraOutputDeps();
58 }

◆ finalize()

virtual StatusCode CaloNoiseCompCondAlg::finalize ( )
inlinefinaloverridevirtual

standard Athena-Algorithm method

Definition at line 74 of file CaloNoiseCompCondAlg.h.

74 {return StatusCode::SUCCESS;};

◆ index()

int CaloNoiseCompCondAlg::index ( const IdentifierHash &  idCaloHash)
private

Definition at line 429 of file CaloNoiseCompCondAlg.cxx.

430 {
431  return m_indexContainer[idCaloHash];
432 }

◆ initAdc2MeV()

StatusCode CaloNoiseCompCondAlg::initAdc2MeV ( const LArADC2MeV *  adc2mev)
private

Definition at line 480 of file CaloNoiseCompCondAlg.cxx.

481 {
482  MsgStream log( msgSvc(), name() );
483  ATH_MSG_INFO( "initAdc2MeV() begin " );
484  for (unsigned int it=0; it<m_adc2mevContainer.size(); ++it)
485  {
486  CaloCell_ID::SUBCALO iCalo = this->caloNum(m_idSymmCaloHashContainer[it]);
487  Identifier id=m_calocell_id->cell_id(m_idSymmCaloHashContainer[it]);
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 }

◆ initContainers()

StatusCode CaloNoiseCompCondAlg::initContainers ( )
private

Definition at line 258 of file CaloNoiseCompCondAlg.cxx.

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  //::::::::::::::::::::::::::::::::::::::
270  m_elecNoiseRAWContainer.resize(m_idSymmCaloHashContainer.size());
271  m_elecNoiseCELLContainer.resize(m_idSymmCaloHashContainer.size());
272  m_pileupNoiseContainer.resize(m_idSymmCaloHashContainer.size());
273  m_adc2mevContainer.resize(m_idSymmCaloHashContainer.size());
274  //::::::::::::::::::::::::::::::::::::::
275  ATH_MSG_INFO( "initContainers() end : " <<" size of containers = " <<m_idSymmCaloHashContainer.size() );
276  return StatusCode::SUCCESS;
277 }

◆ initData()

StatusCode CaloNoiseCompCondAlg::initData ( const LArADC2MeV *  adc2mev)
private

Definition at line 438 of file CaloNoiseCompCondAlg.cxx.

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  {
452  m_nCellsWithProblem[igain]=0;
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 }

◆ initElecNoise()

StatusCode CaloNoiseCompCondAlg::initElecNoise ( )
private

Definition at line 512 of file CaloNoiseCompCondAlg.cxx.

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  //::::::::::::::::::::::::::::::::::::::
524  m_elecNoiseCELLContainer[it] =
525  this->calculateElecNoiseForLAR(m_idSymmCaloHashContainer[it]);
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  {
536  Identifier id = m_calocell_id->cell_id(m_idHash[i][igain]);
537  log<<MSG::DEBUG<<m_idHash[i][igain]<<" "
538  <<m_lar_em_id->show_to_string(id)
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  }
544  log<<MSG::DEBUG<<endmsg;
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 }

◆ initialize()

StatusCode CaloNoiseCompCondAlg::initialize ( )
finaloverridevirtual

standard Athena-Algorithm method

Definition at line 45 of file CaloNoiseCompCondAlg.cxx.

45  {
46 
47  ATH_CHECK( detStore()->retrieve( m_calo_id_man ) );
48  m_lar_em_id = m_calo_id_man->getEM_ID();
49  m_lar_hec_id = m_calo_id_man->getHEC_ID();
50  m_lar_fcal_id = m_calo_id_man->getFCAL_ID();
51  m_calosupercell_id = m_calo_id_man->getCaloCell_SuperCell_ID();
52 
53  ATH_CHECK(m_LArOFCObjKey.initialize());
54  ATH_CHECK(m_shapeKey.initialize());
55  ATH_CHECK(m_fSamplKey.initialize());
56  ATH_CHECK(m_LArMinBiasObjKey.initialize());
57  ATH_CHECK(m_cablingKey.initialize());
58  ATH_CHECK(m_adc2mevKey.initialize());
59  ATH_CHECK(m_pedestalKey.initialize(m_noiseKey.empty()));
60  ATH_CHECK(m_noiseKey.initialize(!m_noiseKey.empty()));
61  ATH_CHECK(m_acorrKey.initialize());
62 
63  //diagnostic
64  m_diagnostic[CaloGain::LARHIGHGAIN] =m_DiagnosticHG;
65  m_diagnostic[CaloGain::LARMEDIUMGAIN]=m_DiagnosticMG;
66  m_diagnostic[CaloGain::LARLOWGAIN] =m_DiagnosticLG;
67 
68  //set calohash maximums
69  m_LArHashMax =0;
70  m_LArHashMax = m_lar_em_id->channel_hash_max()
71  + m_lar_hec_id->channel_hash_max()
72  + m_lar_fcal_id->channel_hash_max();
73  m_CaloHashMax = m_LArHashMax;
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 ?
90  m_HighGainThresh[CaloCell_ID::TILE] = 0.;//
91  //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
92  m_highestGain[CaloCell_ID::LAREM] = CaloGain::LARHIGHGAIN;
93  m_highestGain[CaloCell_ID::LARHEC] = CaloGain::LARMEDIUMGAIN;
94  m_highestGain[CaloCell_ID::LARFCAL] = CaloGain::LARHIGHGAIN;
95  m_highestGain[CaloCell_ID::TILE] = CaloGain::TILEHIGHHIGH;
96 
97  //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
98 
99  ATH_CHECK(m_outputElecKey.initialize());
100  ATH_CHECK(m_outputPileupKey.initialize());
101 
102  ATH_CHECK( m_caloMgrKey.initialize() );
103 
104  return StatusCode::SUCCESS;
105 }

◆ initIndex()

StatusCode CaloNoiseCompCondAlg::initIndex ( )
private

Definition at line 282 of file CaloNoiseCompCondAlg.cxx.

282  {
283  //::::::::::::::::::::::::::::::::::::::
284  m_indexContainer.clear();
285  m_indexContainer.resize(m_CaloHashMax,
286  static_cast<unsigned int> (-1));
287 
288  //maybe the other container sould be reset
289  m_idSymmCaloHashContainer.clear();
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] =
400  m_idSymmCaloHashContainer.size();
401 
402  m_idSymmCaloHashContainer.push_back(idSymmCaloHash);
403  }// loop on all cells
404 
405  return StatusCode::SUCCESS;
406 }

◆ initPileUpNoise()

StatusCode CaloNoiseCompCondAlg::initPileUpNoise ( )
private

Definition at line 558 of file CaloNoiseCompCondAlg.cxx.

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)
568  m_pileupNoiseContainer[it]
569  =this->calculatePileUpNoise(m_idSymmCaloHashContainer[it],m_Nminbias);
570  //::::::::::::::::::::::::::::::::::::::
571  ATH_MSG_DEBUG( "initPileUpNoise() end " );
572  return StatusCode::SUCCESS;
573 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ isBadValue()

bool CaloNoiseCompCondAlg::isBadValue ( float  tested_value)
inlineprivate

Definition at line 314 of file CaloNoiseCompCondAlg.h.

315 {
316  if(tested_value<BADVALUE+1) return true;
317  return false;
318 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

MsgStream& AthCommonMsg< Algorithm >::msg ( const MSG::Level  lvl) const
inlineinherited

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

bool AthCommonMsg< Algorithm >::msgLvl ( const MSG::Level  lvl) const
inlineinherited

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ pileupNoiseRMS() [1/2]

float CaloNoiseCompCondAlg::pileupNoiseRMS ( const CaloCell *  caloCell,
const float  Nminbias = -1 
)

Definition at line 1147 of file CaloNoiseCompCondAlg.cxx.

1148  {
1149  const CaloDetDescrElement* caloDDE = theCell->caloDDE();
1150  return this->pileupNoiseRMS(caloDDE,Nminbias);
1151 }

◆ pileupNoiseRMS() [2/2]

float CaloNoiseCompCondAlg::pileupNoiseRMS ( const CaloDetDescrElement *  caloDDE,
const float  Nminbias = -1 
)

Definition at line 1170 of file CaloNoiseCompCondAlg.cxx.

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
1185  PileUp=m_pileupNoiseContainer[index];
1186  else
1187  PileUp=this->calculatePileUpNoise(idCaloHash,Nminbias);//slower !!
1188  return PileUp;
1189  }
1190  else//TILE
1191  {
1192  return 0.;
1193  }
1194 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< Algorithm > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ retrieveCellDatabase()

StatusCode CaloNoiseCompCondAlg::retrieveCellDatabase ( const IdentifierHash &  idCaloHash,
const Identifier &  id,
int  igain,
std::vector< bool > &  retrieve 
)
private

Definition at line 793 of file CaloNoiseCompCondAlg.cxx.

797 {
798  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
799  //ADC2MEV
800  if(retrieve[iADC2MEV])
801  {
802  {
803  int index=this->index(idCaloHash);
804  m_Adc2MeVFactor = (m_adc2mevContainer[index])[igain];
805  }
806  }
807 
808  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
809  //SIGMANOISE
810  if(retrieve[iSIGMANOISE])
811  {
812  if(m_ped) {
813  m_RMSpedestal = m_ped->pedestalRMS(m_cabling->createSignalChannelID(id),igain);
814  if(m_RMSpedestal>(1.0+LArElecCalib::ERRORCODE))
815  m_SigmaNoise = m_RMSpedestal;
816  else
817  {
818  m_SigmaNoise = 0.;
819  }
820  } else {
821  m_SigmaNoise = m_noise->noise(m_cabling->createSignalChannelID(id),igain);
822 
823  }
824  }
825 
826  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
827  //AUTOCORR
828  if(retrieve[iAUTOCORR])
829  {
830  m_AutoCorr = m_acorr->autoCorr(m_cabling->createSignalChannelID(id),igain);
832  ATH_MSG_VERBOSE("AutoCorr= ");
833  for(unsigned int i=0;i<m_AutoCorr.size();++i)
834  ATH_MSG_VERBOSE(m_AutoCorr[i]<<" ");
835  }
836 
837  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
838  //OFC
839  if(retrieve[iOFC])
840  {
841  m_OFC = m_ofccond->OFC_a(m_cabling->createSignalChannelID(id), igain) ;
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  {
852  m_Shape = m_shapecond->Shape(m_cabling->createSignalChannelID(id),0);
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  {
863  m_MinBiasRMS = m_minbias->minBiasRMS(m_cabling->createSignalChannelID(id));
864  ATH_MSG_VERBOSE("MinBiasRMS="<<m_MinBiasRMS);
865  }
866 
867  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
868  //SAMPLING FRACTION
869  if(retrieve[iFSAMPL])
870  {
871  m_fSampl = m_fsamplcond->FSAMPL(m_cabling->createSignalChannelID(id));
872  ATH_MSG_VERBOSE("fSampl="<<m_fSampl);
873  }
874 
875  return this->checkCellDatabase(id,igain, retrieve);
876 }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

Loop through all output handles, and if they're WriteCondHandles, automatically register them and this Algorithm with the CondSvc

Scan through all outputHandles, and if they're WriteCondHandles, register them with the CondSvc

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

Reimplemented in AthAnalysisAlgorithm, AthFilterAlgorithm, PyAthena::Alg, and AthHistogramAlgorithm.

Definition at line 66 of file AthAlgorithm.cxx.

66  {
67  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::sysInitialize();
68 
69  if (sc.isFailure()) {
70  return sc;
71  }
72  ServiceHandle<ICondSvc> cs("CondSvc",name());
73  for (auto h : outputHandles()) {
74  if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
75  // do this inside the loop so we don't create the CondSvc until needed
76  if ( cs.retrieve().isFailure() ) {
77  ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
78  return StatusCode::SUCCESS;
79  }
80  if (cs->regHandle(this,*h).isFailure()) {
81  sc = StatusCode::FAILURE;
82  ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
83  << " with CondSvc");
84  }
85  }
86  }
87  return sc;
88 }

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Algorithm > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ totalNoiseRMS() [1/2]

float CaloNoiseCompCondAlg::totalNoiseRMS ( const CaloCell *  caloCell,
const float  Nminbias = -1 
)

Definition at line 1155 of file CaloNoiseCompCondAlg.cxx.

1156  {
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 }

◆ totalNoiseRMS() [2/2]

float CaloNoiseCompCondAlg::totalNoiseRMS ( const CaloDetDescrElement *  caloDDE,
const CaloGain::CaloGain  gain,
const float  Nminbias = -1 
)

Definition at line 1200 of file CaloNoiseCompCondAlg.cxx.

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 }

◆ totalNoiseRMSHighestGain() [1/2]

float CaloNoiseCompCondAlg::totalNoiseRMSHighestGain ( const CaloCell *  caloCell,
const float  Nminbias = -1 
)

Definition at line 1219 of file CaloNoiseCompCondAlg.cxx.

1221 {
1222  return this->totalNoiseRMSHighestGain(caloCell->caloDDE(),Nminbias);
1223 }

◆ totalNoiseRMSHighestGain() [2/2]

float CaloNoiseCompCondAlg::totalNoiseRMSHighestGain ( const CaloDetDescrElement *  caloDDE,
const float  Nminbias = -1 
)

Definition at line 1228 of file CaloNoiseCompCondAlg.cxx.

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 }

◆ updateDiagnostic()

void CaloNoiseCompCondAlg::updateDiagnostic ( int  reason,
const std::string &  reason_name,
int  igain,
bool &  noiseOK 
)
private

Definition at line 1018 of file CaloNoiseCompCondAlg.cxx.

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 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< Algorithm > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

Member Data Documentation

◆ m_acorr

const ILArAutoCorr* CaloNoiseCompCondAlg::m_acorr =nullptr
private

Definition at line 240 of file CaloNoiseCompCondAlg.h.

◆ m_acorrKey

SG::ReadCondHandleKey<ILArAutoCorr> CaloNoiseCompCondAlg::m_acorrKey {this,"AutocorrKey","LArAutoCorrSym","SG Key of LArAutoCorr object"}
private

Definition at line 239 of file CaloNoiseCompCondAlg.h.

◆ m_adc2mevContainer

VectorContainer CaloNoiseCompCondAlg::m_adc2mevContainer
private

Definition at line 270 of file CaloNoiseCompCondAlg.h.

◆ m_Adc2MeVFactor

float CaloNoiseCompCondAlg::m_Adc2MeVFactor {}
private

Definition at line 213 of file CaloNoiseCompCondAlg.h.

◆ m_adc2mevKey

SG::ReadCondHandleKey<LArADC2MeV> CaloNoiseCompCondAlg::m_adc2mevKey {this, "ADC2MeVKey", "LArADC2MeV", "SG Key of the LArADC2MeV CDO" }
private

Definition at line 231 of file CaloNoiseCompCondAlg.h.

◆ m_AdcPerMev

double CaloNoiseCompCondAlg::m_AdcPerMev {}
private

Definition at line 222 of file CaloNoiseCompCondAlg.h.

◆ m_atlas_id

const AtlasDetectorID* CaloNoiseCompCondAlg::m_atlas_id {}
private

Definition at line 179 of file CaloNoiseCompCondAlg.h.

◆ m_AutoCorr

LArVectorProxy CaloNoiseCompCondAlg::m_AutoCorr
private

Definition at line 216 of file CaloNoiseCompCondAlg.h.

◆ m_c

float CaloNoiseCompCondAlg::m_c[32][32] {}
private

Definition at line 217 of file CaloNoiseCompCondAlg.h.

◆ m_cabling

const LArOnOffIdMapping* CaloNoiseCompCondAlg::m_cabling =nullptr
private

Definition at line 229 of file CaloNoiseCompCondAlg.h.

◆ m_cablingKey

SG::ReadCondHandleKey<LArOnOffIdMapping> CaloNoiseCompCondAlg::m_cablingKey {this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
private

Definition at line 228 of file CaloNoiseCompCondAlg.h.

◆ m_calo_dd_man

const CaloDetDescrManager* CaloNoiseCompCondAlg::m_calo_dd_man =nullptr
private

Definition at line 226 of file CaloNoiseCompCondAlg.h.

◆ m_calo_id_man

const CaloIdManager* CaloNoiseCompCondAlg::m_calo_id_man {}
private

Definition at line 181 of file CaloNoiseCompCondAlg.h.

◆ m_calocell_id

const CaloCell_ID* CaloNoiseCompCondAlg::m_calocell_id {}
private

Definition at line 188 of file CaloNoiseCompCondAlg.h.

◆ m_CaloHashMax

IdentifierHash CaloNoiseCompCondAlg::m_CaloHashMax
private

Definition at line 193 of file CaloNoiseCompCondAlg.h.

◆ m_CaloHashMin

IdentifierHash CaloNoiseCompCondAlg::m_CaloHashMin
private

Definition at line 194 of file CaloNoiseCompCondAlg.h.

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> CaloNoiseCompCondAlg::m_caloMgrKey {this,"CaloDetDescrManager", "CaloDetDescrManager", "SG Key for CaloDetDescrManager in the Condition Store" }
private

Definition at line 225 of file CaloNoiseCompCondAlg.h.

◆ m_calosupercell_id

const CaloCell_SuperCell_ID* CaloNoiseCompCondAlg::m_calosupercell_id {}
private

Definition at line 189 of file CaloNoiseCompCondAlg.h.

◆ m_deltaBunch

IntegerProperty CaloNoiseCompCondAlg::m_deltaBunch {this, "deltaBunch", 1}
private

Definition at line 199 of file CaloNoiseCompCondAlg.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_diagnostic

bool CaloNoiseCompCondAlg::m_diagnostic[m_nGains] {}
private

Definition at line 169 of file CaloNoiseCompCondAlg.h.

◆ m_DiagnosticHG

BooleanProperty CaloNoiseCompCondAlg::m_DiagnosticHG {this, "DiagnosticHG", false}
private

Definition at line 202 of file CaloNoiseCompCondAlg.h.

◆ m_DiagnosticLG

BooleanProperty CaloNoiseCompCondAlg::m_DiagnosticLG {this, "DiagnosticLG", false}
private

Definition at line 204 of file CaloNoiseCompCondAlg.h.

◆ m_DiagnosticMG

BooleanProperty CaloNoiseCompCondAlg::m_DiagnosticMG {this, "DiagnosticMG", false}
private

Definition at line 203 of file CaloNoiseCompCondAlg.h.

◆ m_DumpDatabaseHG

BooleanProperty CaloNoiseCompCondAlg::m_DumpDatabaseHG {this, "DumpDatabaseHG", false}
private

Definition at line 205 of file CaloNoiseCompCondAlg.h.

◆ m_DumpDatabaseLG

BooleanProperty CaloNoiseCompCondAlg::m_DumpDatabaseLG {this, "DumpDatabaseLG", false}
private

Definition at line 207 of file CaloNoiseCompCondAlg.h.

◆ m_DumpDatabaseMG

BooleanProperty CaloNoiseCompCondAlg::m_DumpDatabaseMG {this, "DumpDatabaseMG", false}
private

Definition at line 206 of file CaloNoiseCompCondAlg.h.

◆ m_elecNoiseCELLContainer

VectorContainer CaloNoiseCompCondAlg::m_elecNoiseCELLContainer
private

Definition at line 268 of file CaloNoiseCompCondAlg.h.

◆ m_elecNoiseRAWContainer

VectorContainer CaloNoiseCompCondAlg::m_elecNoiseRAWContainer
private

Definition at line 267 of file CaloNoiseCompCondAlg.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_firstSample

UnsignedIntegerProperty CaloNoiseCompCondAlg::m_firstSample {this, "firstSample", 0}
private

Definition at line 200 of file CaloNoiseCompCondAlg.h.

◆ m_fSampl

float CaloNoiseCompCondAlg::m_fSampl {}
private

Definition at line 221 of file CaloNoiseCompCondAlg.h.

◆ m_fsamplcond

const ILArfSampl* CaloNoiseCompCondAlg::m_fsamplcond = nullptr
private

Definition at line 249 of file CaloNoiseCompCondAlg.h.

◆ m_fSamplKey

SG::ReadCondHandleKey<ILArfSampl> CaloNoiseCompCondAlg::m_fSamplKey {this,"fSamplKey","LArfSamplSym","SG Key of LArfSampl object"}
private

Definition at line 248 of file CaloNoiseCompCondAlg.h.

◆ m_highestGain

CaloGain::CaloGain CaloNoiseCompCondAlg::m_highestGain[m_nCalos] {}
private

Definition at line 167 of file CaloNoiseCompCondAlg.h.

◆ m_HighGainThresh

float CaloNoiseCompCondAlg::m_HighGainThresh[m_nCalos] {}
private

Definition at line 166 of file CaloNoiseCompCondAlg.h.

◆ m_idHash

int CaloNoiseCompCondAlg::m_idHash[5000][m_nGains] {}
private

Definition at line 173 of file CaloNoiseCompCondAlg.h.

◆ m_idSymmCaloHashContainer

std::vector<IdentifierHash> CaloNoiseCompCondAlg::m_idSymmCaloHashContainer
private

Definition at line 263 of file CaloNoiseCompCondAlg.h.

◆ m_indexContainer

std::vector<IdentifierHash> CaloNoiseCompCondAlg::m_indexContainer
private

Definition at line 260 of file CaloNoiseCompCondAlg.h.

◆ m_itReason

int CaloNoiseCompCondAlg::m_itReason[10][m_nGains] {}
private

Definition at line 172 of file CaloNoiseCompCondAlg.h.

◆ m_lar_em_id

const LArEM_Base_ID* CaloNoiseCompCondAlg::m_lar_em_id {}
private

Definition at line 183 of file CaloNoiseCompCondAlg.h.

◆ m_lar_fcal_id

const LArFCAL_Base_ID* CaloNoiseCompCondAlg::m_lar_fcal_id {}
private

Definition at line 185 of file CaloNoiseCompCondAlg.h.

◆ m_lar_hec_id

const LArHEC_Base_ID* CaloNoiseCompCondAlg::m_lar_hec_id {}
private

Definition at line 184 of file CaloNoiseCompCondAlg.h.

◆ m_LArHashMax

IdentifierHash CaloNoiseCompCondAlg::m_LArHashMax
private

Definition at line 191 of file CaloNoiseCompCondAlg.h.

◆ m_LArMinBiasObjKey

SG::ReadCondHandleKey<ILArMinBias> CaloNoiseCompCondAlg::m_LArMinBiasObjKey {this, "LArMinBiasKey", "LArMinBiasSym", "SG Key of LArMinBias"}
private

Definition at line 251 of file CaloNoiseCompCondAlg.h.

◆ m_LArOFCObjKey

SG::ReadCondHandleKey<ILArOFC> CaloNoiseCompCondAlg::m_LArOFCObjKey {this, "OFKey","LArOFC", "SG Key of LAr OFCs"}
private

Definition at line 242 of file CaloNoiseCompCondAlg.h.

◆ m_LowGainThresh

float CaloNoiseCompCondAlg::m_LowGainThresh[m_nCalos] {}
private

Definition at line 165 of file CaloNoiseCompCondAlg.h.

◆ m_minbias

const ILArMinBias* CaloNoiseCompCondAlg::m_minbias = nullptr
private

Definition at line 252 of file CaloNoiseCompCondAlg.h.

◆ m_MinBiasRMS

float CaloNoiseCompCondAlg::m_MinBiasRMS {}
private

Definition at line 223 of file CaloNoiseCompCondAlg.h.

◆ m_nCalos

constexpr int CaloNoiseCompCondAlg::m_nCalos =NCALOS
staticconstexprprivate

Definition at line 163 of file CaloNoiseCompCondAlg.h.

◆ m_nCellsWithProblem

int CaloNoiseCompCondAlg::m_nCellsWithProblem[m_nGains] {}
private

Definition at line 170 of file CaloNoiseCompCondAlg.h.

◆ m_nGains

constexpr int CaloNoiseCompCondAlg::m_nGains =NGAINS
staticconstexprprivate

Definition at line 164 of file CaloNoiseCompCondAlg.h.

◆ m_Nminbias

FloatProperty CaloNoiseCompCondAlg::m_Nminbias {this, "NMinBias", -1}
private

Definition at line 208 of file CaloNoiseCompCondAlg.h.

◆ m_noise

const ILArNoise* CaloNoiseCompCondAlg::m_noise =nullptr
private

Definition at line 237 of file CaloNoiseCompCondAlg.h.

◆ m_noiseKey

SG::ReadCondHandleKey<ILArNoise> CaloNoiseCompCondAlg::m_noiseKey {this,"NoiseKey","","SG Key of LArNoise object"}
private

Definition at line 236 of file CaloNoiseCompCondAlg.h.

◆ m_nReason

int CaloNoiseCompCondAlg::m_nReason[5000][m_nGains] {}
private

Definition at line 171 of file CaloNoiseCompCondAlg.h.

◆ m_nsamples

int CaloNoiseCompCondAlg::m_nsamples {}
private

Definition at line 219 of file CaloNoiseCompCondAlg.h.

◆ m_OFC

LArVectorProxy CaloNoiseCompCondAlg::m_OFC
private

Definition at line 214 of file CaloNoiseCompCondAlg.h.

◆ m_ofccond

const ILArOFC* CaloNoiseCompCondAlg::m_ofccond =nullptr
private

Definition at line 243 of file CaloNoiseCompCondAlg.h.

◆ m_outputElecKey

SG::WriteCondHandleKey<CaloNoise> CaloNoiseCompCondAlg::m_outputElecKey {this, "OutputElecKey", "elecNoise", "SG Key of resulting noise CDO"}
private

Definition at line 255 of file CaloNoiseCompCondAlg.h.

◆ m_outputPileupKey

SG::WriteCondHandleKey<CaloNoise> CaloNoiseCompCondAlg::m_outputPileupKey {this, "OutputPileupKey", "pileupNoise", "SG Key of resulting noise CDO"}
private

Definition at line 256 of file CaloNoiseCompCondAlg.h.

◆ m_ped

const ILArPedestal* CaloNoiseCompCondAlg::m_ped =nullptr
private

Definition at line 234 of file CaloNoiseCompCondAlg.h.

◆ m_pedestalKey

SG::ReadCondHandleKey<ILArPedestal> CaloNoiseCompCondAlg::m_pedestalKey {this,"PedestalKey","LArPedestal","SG Key of LArPedestal object"}
private

Definition at line 233 of file CaloNoiseCompCondAlg.h.

◆ m_pileupNoiseContainer

SingleContainer CaloNoiseCompCondAlg::m_pileupNoiseContainer
private

Definition at line 269 of file CaloNoiseCompCondAlg.h.

◆ m_reason

int CaloNoiseCompCondAlg::m_reason[5000][10][m_nGains] {}
private

Definition at line 174 of file CaloNoiseCompCondAlg.h.

◆ m_reasonName

std::string CaloNoiseCompCondAlg::m_reasonName[10]
private

Definition at line 176 of file CaloNoiseCompCondAlg.h.

◆ m_ReturnNoiseName

std::string CaloNoiseCompCondAlg::m_ReturnNoiseName
private

Definition at line 159 of file CaloNoiseCompCondAlg.h.

◆ m_RMSpedestal

float CaloNoiseCompCondAlg::m_RMSpedestal {}
private

Definition at line 218 of file CaloNoiseCompCondAlg.h.

◆ m_Shape

LArVectorProxy CaloNoiseCompCondAlg::m_Shape
private

Definition at line 215 of file CaloNoiseCompCondAlg.h.

◆ m_shapecond

const ILArShape* CaloNoiseCompCondAlg::m_shapecond =nullptr
private

Definition at line 246 of file CaloNoiseCompCondAlg.h.

◆ m_shapeKey

SG::ReadCondHandleKey<ILArShape> CaloNoiseCompCondAlg::m_shapeKey {this,"ShapeKey","LArShapeSym","SG Key of Shape conditions object"}
private

Definition at line 245 of file CaloNoiseCompCondAlg.h.

◆ m_SigmaNoise

float CaloNoiseCompCondAlg::m_SigmaNoise {}
private

Definition at line 220 of file CaloNoiseCompCondAlg.h.

◆ m_TileHashMax

IdentifierHash CaloNoiseCompCondAlg::m_TileHashMax
private

Definition at line 192 of file CaloNoiseCompCondAlg.h.

◆ m_UseSymmetry

BooleanProperty CaloNoiseCompCondAlg::m_UseSymmetry {this, "UseSymmetry", true}
private

Definition at line 201 of file CaloNoiseCompCondAlg.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< Algorithm > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
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
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
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
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
CaloNoiseCompCondAlg::m_UseSymmetry
BooleanProperty m_UseSymmetry
Definition: CaloNoiseCompCondAlg.h:201
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
LArFCAL_Base_ID::module
int module(const Identifier id) const
module [1,3]
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
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
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
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_AutoCorr
LArVectorProxy m_AutoCorr
Definition: CaloNoiseCompCondAlg.h:216
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
CaloNoiseCompCondAlg::m_shapeKey
SG::ReadCondHandleKey< ILArShape > m_shapeKey
Definition: CaloNoiseCompCondAlg.h:245
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
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
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
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
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
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
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
iADC2MEV
@ iADC2MEV
Definition: CaloNoiseCompCondAlg.h:38
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CaloNoiseCompCondAlg::m_atlas_id
const AtlasDetectorID * m_atlas_id
Definition: CaloNoiseCompCondAlg.h:179
CaloNoiseCompCondAlg::initElecNoise
StatusCode initElecNoise()
Definition: CaloNoiseCompCondAlg.cxx:512
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
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
AthCommonDataStore::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
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:321
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
ILArNoise::noise
virtual const float & noise(const HWIdentifier &id, int gain) const =0
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
CaloCell_Base_ID::sub_calo
int sub_calo(const Identifier id) const
returns an int taken from SUBCALO enum and describing the subCalo to which the Id belongs.
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:824
CaloCell_Base_ID::TILE
@ TILE
Definition: CaloCell_Base_ID.h:43
WriteCellNoiseToCool.igain
igain
Definition: WriteCellNoiseToCool.py:338
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
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
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
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
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
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
CaloNoiseCompCondAlg::m_DiagnosticHG
BooleanProperty m_DiagnosticHG
Definition: CaloNoiseCompCondAlg.h:202
CaloNoiseCompCondAlg::m_fSampl
float m_fSampl
Definition: CaloNoiseCompCondAlg.h:221
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
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
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
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,...
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
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
a
TList * a
Definition: liststreamerinfos.cxx:10
h
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)
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)
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
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
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
CaloNoiseCompCondAlg::calculateElecNoiseForLAR
std::vector< float > calculateElecNoiseForLAR(const IdentifierHash &idCaloHash)
Definition: CaloNoiseCompCondAlg.cxx:578
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:801
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
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
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
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
ServiceHandle< ICondSvc >
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
CaloNoiseCompCondAlg::m_AdcPerMev
double m_AdcPerMev
Definition: CaloNoiseCompCondAlg.h:222
Identifier
Definition: IdentifierFieldParser.cxx:14
Generated on Mon Sep 29 2025 21:29:58 for ATLAS Offline Software by   doxygen 1.8.18