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:

Public Member Functions
	CaloNoiseCompCondAlg (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Athena-Algorithm Constructor.
virtual	~CaloNoiseCompCondAlg ()=default
	Default Destructor.
virtual StatusCode	initialize () override final
	standard Athena-Algorithm method
virtual StatusCode	execute (const EventContext &) const override final
	standard Athena-Algorithm method
virtual StatusCode	finalize () override final
	standard Athena-Algorithm method
virtual StatusCode	stop () override final
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 bool	isReEntrant () const override
	Avoid scheduling algorithm multiple times.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual bool	isClonable () const override
	Specify if the algorithm is clonable.
virtual unsigned int	cardinality () const override
	Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.
virtual StatusCode	sysExecute (const EventContext &ctx) override
	Execute an algorithm.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
virtual bool	filterPassed (const EventContext &ctx) const
virtual void	setFilterPassed (bool state, const EventContext &ctx) const
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard `StoreGateSvc` (event store) Returns (kind of) a pointer to the `StoreGateSvc`.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard `StoreGateSvc/DetectorStore` Returns (kind of) a pointer to the `StoreGateSvc`.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
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.

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>

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_Base_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}
BooleanProperty	m_isSC {this, "SuperCell", false}
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" }
SG::ReadCondHandleKey< CaloSuperCellDetDescrManager >	m_caloSCMgrKey {this,"CaloSuperCellDetDescrManager", "CaloSuperCellDetDescrManager", "SG Key for CaloSuperCellDetDescrManager in the Condition Store" }
const CaloDetDescrManager_Base *	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
	Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
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< Gaudi::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 24 of file CaloNoiseCompCondAlg.cxx.

                                                                                         :
  AthCondAlgorithm( name, pSvcLocator),
    m_atlas_id(nullptr),
    m_calo_id_man(nullptr),
    m_lar_em_id(nullptr),
    m_lar_hec_id(nullptr),
    m_lar_fcal_id(nullptr),
    m_calocell_id(nullptr),
    m_Adc2MeVFactor(0),
    m_RMSpedestal(0),
    m_nsamples(0),
    m_SigmaNoise(0.),
    m_fSampl(0),
    m_AdcPerMev(5.*GeV),
    m_MinBiasRMS(0)
 
{
}

◆ ~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 1256 of file CaloNoiseCompCondAlg.cxx.

{
 
  float factor=1.;
  IdentifierHash idCaloHash = caloDDE->calo_hash();
  CaloCell_ID::SUBCALO iCalo = this->caloNum(idCaloHash);
 
  if(iCalo==CaloCell_ID::LAREM || iCalo==CaloCell_ID::LARHEC)
  {      
    int index=this->index(idCaloHash);
    factor=(m_adc2mevContainer[index])[gain];
  }
  else if(iCalo==CaloCell_ID::LARFCAL)
  {
    int index=this->index(idCaloHash);
    factor=(m_adc2mevContainer[index])[gain];
  }  
  else if(iCalo==CaloCell_ID::TILE)
  {
    //TILE_PART
    ATH_MSG_WARNING("CaloNoiseCompCondAlg::adc2mev(id,gain) : NOT IMPLEMENTED !" <<"for TILE (-> returns 1. for the moment)" );    
    factor=1.; 
  }  
  else
  {
    MsgStream log( msgSvc(), name() );
    ATH_MSG_WARNING("CaloNoiseCompCondAlg::adc2mev(id,gain)  wrong id ! " <<m_lar_em_id->show_to_string(caloDDE->identify()) );
    factor=0.;
  }  
  return factor;
}

◆ adc2mev() [2/2]

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

Definition at line 1292 of file CaloNoiseCompCondAlg.cxx.

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

◆ calculateElecNoiseForLAR()

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

private

Definition at line 593 of file CaloNoiseCompCondAlg.cxx.

{ 
 /*  
 
E=SUMi { OFCi * (short[ (PulseShapei*Ehit/Adc2MeV(gain) + Noisei(gain)  
                       + pedestal) ]  
                 - pedestal) * Adc2Mev(gain) ] } 
   with Noisei =SUMj { cij*Rndm } * m_SigmaNoise
 
   NB:  without short and with cij=identity (no autocorrelation) 
        E=SUMi { NOISEi(gain)*Rndm } 
        with  NOISEi(gain) = Adc2MeV(gain) * OFCi * m_SigmaNoise(gain)        
 
   => Sigma^2=SUMi{NOISEi(gain)*NOISEj(gain)*cij} + quantification part
             =        NOISE(gain)                 +   REST
      Sigma  = std::sqrt( NOISE(gain) + REST) 
 
 
*/
 
  int maxgain =  m_isSC ? CaloGain::LARMEDIUMGAIN : CaloGain::LARNGAIN;
  std::vector<float> sigmaVector (maxgain,BADVALUE);
  float sigma;
 
  Identifier id = m_calocell_id->cell_id(idCaloHash);
 
  for(int igain=0;igain<maxgain;++igain) 
  {
    bool noiseOK=true;
    //::::::::::::::::::::::::::::::::::::::::::::::::::
    //==== retrieve the database ====
    //::::::::::::::::::::::::::::::::::::::::::::::::::
 
    std::vector<bool> retrieve(nDATABASE,false); 
    retrieve[iADC2MEV]=true;
    retrieve[iSIGMANOISE]=true;
    retrieve[iAUTOCORR]=true;
    retrieve[iOFC]=true;
    //retrieve[iSHAPE]=true;
    StatusCode sc=this->retrieveCellDatabase(idCaloHash,id,igain, retrieve);    
    //if(sc.isFailure()) continue;
      //NOTE: if an element of the database is empty, 
      //      leave the iteration (on gains) => value will be BADVALUE
      //the interfaces take care of that !   
 
    //::::::::::::::::::::::::::::::::::::::::::::::::::
    //==== calculations ====
    //::::::::::::::::::::::::::::::::::::::::::::::::::
 
    if(sc.isFailure()) {
      sigma=float(BADVALUE_TO_RETURN);
    }
    else    
    {
      float OFC_AC_OFC,OFC_OFC;
      this->commonCalculations(OFC_AC_OFC,OFC_OFC,1);
      //::::::::::::::::::::::::::::::::::::::
      float NOISE= OFC_AC_OFC*m_SigmaNoise*m_SigmaNoise ;
      float REST = OFC_OFC*(1./12.);// 12.=std::sqrt(12)*std::sqrt(12)
      sigma=(NOISE+REST) * m_Adc2MeVFactor*m_Adc2MeVFactor;   
      //::::::::::::::::::::::::::::::::::::::
      if(sigma>0) sigma=std::sqrt(sigma);
      else  
      {
        sigma=-std::sqrt(-sigma);
        //:::::::::::::::::
        //      if(igain==0) log << MSG::ERROR 
        //    <<m_lar_em_id->show_to_string(id)<<" gain "<<igain
        //    <<" : negative root square => WRONG noise "
        //    <<"(please check if OFC or AutoCorr are correct for this cell)"
        //    <<endreq;
      }
 
      //diagnostic    
      if(m_diagnostic[igain]) 
      {
        if(noiseOK && sigma<0)       
      this->updateDiagnostic(9,"sigma<0",igain, noiseOK);         
        if(!noiseOK) 
        {
      m_idHash[m_nCellsWithProblem[igain]][igain]=idCaloHash;
      ++m_nCellsWithProblem[igain];
      m_nReason[m_nCellsWithProblem[igain]][igain]=0;
        }      
      }
      //::::::::::::::::::::::::::::::::::::::
      if(noiseOK==false || sigma<0) sigma=float(BADVALUE_TO_RETURN);
    }
    sigmaVector[igain]=sigma;
 
  }//loop on gains
  
  return sigmaVector;  
}

◆ calculatePileUpNoise()

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

private

Definition at line 692 of file CaloNoiseCompCondAlg.cxx.

{
  if(Nminbias<=0.000001) return 0.;
    //only on WorkMode==1
  if(this->caloNum(idCaloHash)==CaloCell_ID::TILE) return 0.;
    //no pile-up for tiles, for the moment ...
 
  /*
    SigmaPileUp^2 = ( SigmaE * std::sqrt(Nmb) )^2 * Ipileup/Tc
    where:  
      - Ipileup = Tc * SUM(k=1->Nb) g(tk)^2 
      - Tc is the time between bunch crossings
      - Nb is the number of bunch crossings 
        (over which the response function is non-zero)
      - g is the shape
      - SigmaE is the RMS of the energy in 1 minimum bias event
      - Nmb is the number of minimum bias events (depending on the luminosity)
   */ 
  
  Identifier id = m_calocell_id->cell_id(idCaloHash);
 
  //::::::::::::::::::::::::::::::::::::::
 
  std::vector<bool> retrieve(nDATABASE,false);   
  retrieve[iAUTOCORR]=true;
  retrieve[iOFC]=true;
  retrieve[iSHAPE]=true;
  retrieve[iMINBIASRMS]=true;
  retrieve[iFSAMPL]=true;
  StatusCode sc=this->retrieveCellDatabase(idCaloHash,id,
                       CaloGain::LARHIGHGAIN,retrieve);    
  if(sc.isFailure()) return 0.;
 
  //::::::::::::::::::::::::::::::::::::::
 
  //in the database, RMS is at the scale of the Hits, 
  // so we need to scale it at the e.m scale using the sampling fraction ...
  m_MinBiasRMS /= m_fSampl;
 
  //::::::::::::::::::::::::::::::::::::::
 
// overall normalization factor
  float  PileUp=m_MinBiasRMS*std::sqrt(Nminbias);
 
  //::::::::::::::::::::::::::::::::::::::
 
  float OFC_AC_OFC,OFC_OFC; 
  unsigned int firstSample=m_firstSample; 
  // for HEC, always use firstSample=1 when the number of samples is 4 
  if (m_lar_hec_id->is_lar_hec(id) && m_nsamples==4 && m_firstSample==0u) firstSample=1; 
  this->commonCalculations(OFC_AC_OFC,OFC_OFC,2,firstSample); 
 
  //::::::::::::::::::::::::::::::::::::::
 
  PileUp*=std::sqrt(OFC_AC_OFC);
 
  return PileUp; 
}

◆ caloNum()

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

inlineprivate

Definition at line 327 of file CaloNoiseCompCondAlg.h.

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

◆ cardinality()

unsigned int AthCommonReentrantAlgorithm< Gaudi::Algorithm >::cardinality ( ) const

overridevirtualinherited

Cardinality (Maximum number of clones that can exist) special value 0 means that algorithm is reentrant.

Override this to return 0 for reentrant algorithms.

Definition at line 75 of file AthCommonReentrantAlgorithm.cxx.

{
  return 0;
}

◆ checkCellDatabase()

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

private

Definition at line 896 of file CaloNoiseCompCondAlg.cxx.

{
  StatusCode StatusDatabase=StatusCode::SUCCESS;
 
  ATH_MSG_DEBUG("checkCellDatabase starts for "<<id.get_identifier32().get_compact()<<" gain: "<<igain);
  bool dummy=false;
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //ADC2MEV
  if(retrieve[iADC2MEV]) {
    if(std::fabs(m_Adc2MeVFactor)<0.000001) {
      StatusDatabase=StatusCode::FAILURE;
      if(m_diagnostic[igain]) 
    this->updateDiagnostic(0,"m_Adc2MeVFactor=0",igain,dummy);
    }
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //SIGMANOISE
  if(retrieve[iSIGMANOISE]) {
    if(std::fabs(m_SigmaNoise)<0.000001) {
      StatusDatabase=StatusCode::FAILURE;
      if(m_diagnostic[igain]) 
    this->updateDiagnostic(1,"m_SigmaNoise=0",igain,dummy); 
    }
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //AUTOCORR
  if(retrieve[iAUTOCORR])
  {
    if (!m_AutoCorr.valid()) 
    {
      ATH_MSG_WARNING( " AutoCorr invalid for " <<m_lar_em_id->show_to_string(id)<<" at gain "<<igain);
      StatusDatabase=StatusCode::FAILURE;
    }
    if (m_AutoCorr.size()==0) 
    {
      StatusDatabase=StatusCode::FAILURE;
      if(m_diagnostic[igain]) this->updateDiagnostic(2,"AC empty",igain,dummy);
    }
      // autocorr can be null (and it is for low-gain !), so allow it !
      m_nsamples=m_AutoCorr.size()+1;
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //OFC
  if(retrieve[iOFC])
  {
    if (!m_OFC.valid()) 
    {
      ATH_MSG_WARNING( "  OFC pointer null for " <<m_lar_em_id->show_to_string(id)<<" at gain "<<igain);
      StatusDatabase=StatusCode::FAILURE;
    }
    if (m_OFC.size()==0) 
    {
      StatusDatabase=StatusCode::FAILURE;
      if(m_diagnostic[igain]) this->updateDiagnostic(4,"OFC empty",igain,dummy);
    }
    else
      if(m_diagnostic[igain]) 
      {
    unsigned int n_OFCnull=0;
    for(auto ofc : m_OFC)
      if(std::fabs(ofc)<0.000001) ++n_OFCnull;
    if(n_OFCnull==m_OFC.size()) this->updateDiagnostic(5,"OFC=0",igain,dummy);
      }
    m_nsamples=m_OFC.size();
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //SHAPE
  if(retrieve[iSHAPE])
  {
    if (!m_Shape.valid()) 
    {
      ATH_MSG_WARNING( "  Shape pointer null -> PileUp will be 0 for " <<m_lar_em_id->show_to_string(id) );
      StatusDatabase=StatusCode::FAILURE;
    }
    if (m_Shape.size()==0) 
    {      
      //      log<<MSG::WARNING
      //       <<"  Shape vector empty -> PileUp will be 0 for "
      //       <<m_lar_em_id->show_to_string(id)<<endreq;
      StatusDatabase=StatusCode::FAILURE;
      if(m_diagnostic[igain]) this->updateDiagnostic(6,"Shape empty",igain,dummy);
    }
    else
      if(m_diagnostic[igain]) 
      {
    unsigned int n_SHAPEnull=0;
    for(auto shp : m_Shape)
      if(std::fabs(shp)<0.000001) ++n_SHAPEnull;
    if(n_SHAPEnull==m_Shape.size())    
      this->updateDiagnostic(7,"Shape=0",igain,dummy);
      } 
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //NSAMPLES
  if(retrieve[iOFC] && retrieve[iAUTOCORR] 
     && m_OFC.size()!=m_AutoCorr.size()+1)
  {
    m_nsamples=std::min(m_OFC.size(),m_AutoCorr.size()+1);
    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 !" );
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  if(retrieve[iOFC] && retrieve[iSHAPE] && m_OFC.size()==m_Shape.size())
  {
    float scalar=0;
    for(unsigned int i=0;i<m_Shape.size();++i)
      scalar+=m_Shape[i]*m_OFC[i];
    if((scalar-1)>0.05)
      this->updateDiagnostic(8,"[Shape].[OFC] not 1",igain,dummy);
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //SAMPLING FRACTION
  if(retrieve[iFSAMPL])
  {
    if (m_fSampl<0.000001) 
    {
      ATH_MSG_WARNING("  fSampl null -> PileUp will be 0 for " <<m_lar_em_id->show_to_string(id) );
      StatusDatabase=StatusCode::FAILURE;
    }
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  ATH_MSG_DEBUG("checkCellDatabase "<<id.get_identifier32().get_compact()<<" status: "<<StatusDatabase);
  return StatusDatabase;
}

◆ checkIfConnected()

bool CaloNoiseCompCondAlg::checkIfConnected ( const Identifier & id )

private

Definition at line 425 of file CaloNoiseCompCondAlg.cxx.

{
  try
  {
    HWIdentifier hwid = m_cabling->createSignalChannelID(id);
    if(!m_cabling->isOnlineConnected(hwid)) 
    {
      return false;
    }
  }
  catch(LArID_Exception & except) 
    {return false;}
  return true;
}

◆ commonCalculations()

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

private

Definition at line 755 of file CaloNoiseCompCondAlg.cxx.

{
 
  // case 1 electronic noise
  if (icase==1) {
     //calculate the matrix of autocorrelation
     for(int i=0;i<m_nsamples;++i) 
       for(int j=0;j<m_nsamples;++j)  
       { 
         if(i==j)               m_c[i][j] = 1.; 
         for(int k=1;k<m_nsamples;++k) 
       if(i==j-k || i==j+k) 
         m_c[i][j] = m_AutoCorr[k-1];
       }
  }
// other case: pileup noise
  else {
     for (int i=0;i<m_nsamples;i++) {
      for (int j=0;j<m_nsamples;j++)
      {
        m_c[i][j]=0.;
        int nsize = m_Shape.size();
        for (int k=0;k<nsize;k++) {
           if ((j-i+k)>=0 && (j-i+k)<nsize) {
             int ibunch=0;
             if ((i+firstSample-k)%m_deltaBunch == 0 ) ibunch=1;
             m_c[i][j] += ((double) (ibunch)) * (m_Shape[k]) * (m_Shape[j-i+k]);
           }
        }
      }
     }
  }
 
  //::::::::::::::::::::::::::::::::::::::
  OFC_AC_OFC=0;
  OFC_OFC=0;
  
  float tmp;
  for(int i=0;i<m_nsamples;++i) 
  {   
    tmp=0.; 
    for(int j=0;j<m_nsamples;++j)     
      tmp+=m_c[i][j]*m_OFC[j]; 
    tmp*=m_OFC[i]; 
    OFC_AC_OFC+=tmp;  
    OFC_OFC+= m_OFC[i] * m_OFC[i]; 
  }
  //::::::::::::::::::::::::::::::::::::::
}

◆ declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< Gaudi::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.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

◆ declareProperty()

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

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::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; }

AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_detStore

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ elecNoiseRMS() [1/2]

float CaloNoiseCompCondAlg::elecNoiseRMS ( const CaloCell * caloCell )

Definition at line 1150 of file CaloNoiseCompCondAlg.cxx.

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

◆ elecNoiseRMS() [2/2]

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

Definition at line 1053 of file CaloNoiseCompCondAlg.cxx.

{  
 
 
  float sigma=0.;
 
  const IdentifierHash idCaloHash = caloDDE->calo_hash();
  //CaloCell_ID::SUBCALO iCalo = this->caloNum(idCaloHash);
  CaloCell_ID::SUBCALO iCalo = caloDDE->getSubCalo();
  int index=this->index(idCaloHash);
 
  
  int igain=static_cast<int>(gain);//for LAr  
  if(iCalo==CaloCell_ID::TILE)     //for Tile 
  {
    CaloGain::CaloGain convertedGain;
    switch(gain)
    {
  //convert Tile gain into LAr gain (the one used to store the noise in arrays)
    case CaloGain::TILEHIGHHIGH : convertedGain=CaloGain::LARHIGHGAIN;   break;
    case CaloGain::TILEHIGHLOW :  convertedGain=CaloGain::LARMEDIUMGAIN; break;
    case CaloGain::TILELOWHIGH :  convertedGain=CaloGain::LARMEDIUMGAIN; break;
    case CaloGain::TILELOWLOW :   convertedGain=CaloGain::LARLOWGAIN;    break;
    case CaloGain::TILEONEHIGH :  convertedGain=CaloGain::LARHIGHGAIN;   break;
    case CaloGain::TILEONELOW :   convertedGain=CaloGain::LARLOWGAIN;    break;
    default: convertedGain = CaloGain::INVALIDGAIN;
    }
    igain=static_cast<int>(convertedGain);
  } 
 
  if (gain==CaloGain::INVALIDGAIN || gain==CaloGain::UNKNOWNGAIN) {
    ATH_MSG_WARNING( " ask noise for invalid/unknown gain, will return noise for high gain " );
    igain=static_cast<int>(CaloGain::LARHIGHGAIN);
  }
 
  if (iCalo<0 || index<0)
  {
    ATH_MSG_WARNING( "CaloNoiseCompCondAlg::elecNoiseRMS  wrong id ! " << "iCalo="<<iCalo << "index="<<index << "id:" << m_lar_em_id->show_to_string(caloDDE->identify()) );
    return 0.;
  } 
  else 
  {         
    const std::vector<float>* sigmaVector = 0;
    sigmaVector = &m_elecNoiseCELLContainer[index];
 
    bool retry=true;
    int shift_gain=0;
    int gain_wanted=igain;    
    int gain_shifted=gain_wanted;
 
    while(retry)
    {      
      //:::::::::::::::::
      retry=false;
      //:::::::::::::::::
      gain_shifted=gain_wanted-shift_gain;
      //:::::::::::::::::
      sigma = (*sigmaVector)[gain_shifted];
      //:::::::::::::::::
      sigma = this->calculateElecNoiseForLAR(idCaloHash) [gain_shifted];
      //:::::::::::::::::
      if(this->isBadValue(sigma)) 
      {
    ++shift_gain;
    if(shift_gain<=igain) retry=true;
    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<<")" );
      }
      //:::::::::::::::::
    }
    return sigma;   
  }  
}

◆ elecNoiseRMS3gains()

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

Definition at line 1131 of file CaloNoiseCompCondAlg.cxx.

{  
  std::vector<float> sigma;
  int maxgain =  m_isSC ? CaloGain::LARMEDIUMGAIN : CaloGain::LARNGAIN;
  sigma.reserve (maxgain);
  for(int igain=0;igain<maxgain;++igain)
    sigma.push_back(this->elecNoiseRMS(caloDDE,
                       static_cast<CaloGain::CaloGain>(igain)));
  for(int igain=0;igain<maxgain;++igain)
    if(this->isBadValue(sigma[igain]) && 
       igain!=CaloGain::LARHIGHGAIN) 
      sigma[igain]=sigma[igain-1];//take the next gain (low->medium->high)
  return sigma;
}

◆ 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()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< Gaudi::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; }

AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

virtual StatusCode CaloNoiseCompCondAlg::execute ( const EventContext & ) const

inlinefinaloverridevirtual

standard Athena-Algorithm method

Definition at line 72 of file CaloNoiseCompCondAlg.h.

72{return StatusCode::SUCCESS;};

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< Gaudi::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 & AthCommonReentrantAlgorithm< Gaudi::Algorithm >::extraOutputDeps ( ) const

overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 94 of file AthCommonReentrantAlgorithm.cxx.

{
  // If we didn't find any symlinks to add, just return the collection
  // from the base class.  Otherwise, return the extended collection.
  if (!m_extendedExtraObjects.empty()) {
    return m_extendedExtraObjects;
  }
  return BaseAlg::extraOutputDeps();
}

◆ filterPassed()

virtual bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::filterPassed ( const EventContext & ctx ) const

inlinevirtualinherited

Definition at line 96 of file AthCommonReentrantAlgorithm.h.

                                                           {
    return execState( ctx ).filterPassed();
  }

◆ 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 443 of file CaloNoiseCompCondAlg.cxx.

{
  return m_indexContainer[idCaloHash];
}

◆ initAdc2MeV()

StatusCode CaloNoiseCompCondAlg::initAdc2MeV ( const LArADC2MeV * adc2mev )

private

Definition at line 494 of file CaloNoiseCompCondAlg.cxx.

{
  ATH_MSG_INFO( "initAdc2MeV() begin " );
  for (unsigned int it=0; it<m_adc2mevContainer.size(); ++it)
  { 
    CaloCell_ID::SUBCALO iCalo = this->caloNum(m_idSymmCaloHashContainer[it]);
    Identifier id=m_calocell_id->cell_id(m_idSymmCaloHashContainer[it]);
    //::::::::::::::::::::::::::::::::::::::
    //::::::::::::::::::::::::::::::::::::::
    if(iCalo!=CaloCell_ID::TILE) 
    {
      std::vector<float>& adc2mevVector = m_adc2mevContainer[it];
      unsigned int maxgain =  m_isSC ? CaloGain::LARMEDIUMGAIN : CaloGain::LARNGAIN;
      adc2mevVector.reserve (maxgain);
      for(unsigned int igain=0;igain<maxgain;++igain)
      {
        auto polynom_adc2mev = adc2mev->ADC2MEV(id,igain);
        if(polynom_adc2mev.size()==0)
          adc2mevVector.push_back(0.);
        else 
          adc2mevVector.push_back(polynom_adc2mev[1]);
      }
    }
    //::::::::::::::::::::::::::::::::::::::
  } 
  ATH_MSG_INFO( "initAdc2MeV() end " );
  return StatusCode::SUCCESS;
}

◆ initContainers()

StatusCode CaloNoiseCompCondAlg::initContainers ( )

private

Definition at line 274 of file CaloNoiseCompCondAlg.cxx.

{
  //initialize the maps m_ElecNoiseContainer and m_ScaleContainer 
  //(assuming type of elements of the containers is the same for LAr)
 
  ATH_MSG_INFO( "initContainers() begin " );
 
  // intialise indices
  ATH_CHECK(this->initIndex()); 
 
  //::::::::::::::::::::::::::::::::::::::     
  m_elecNoiseRAWContainer.resize(m_idSymmCaloHashContainer.size());
  m_elecNoiseCELLContainer.resize(m_idSymmCaloHashContainer.size());
  m_pileupNoiseContainer.resize(m_idSymmCaloHashContainer.size());
  m_adc2mevContainer.resize(m_idSymmCaloHashContainer.size());
  //::::::::::::::::::::::::::::::::::::::
  ATH_MSG_INFO( "initContainers() end : " <<" size of containers = " <<m_idSymmCaloHashContainer.size() );
  return StatusCode::SUCCESS;
}

◆ initData()

StatusCode CaloNoiseCompCondAlg::initData ( const LArADC2MeV * adc2mev )

private

Definition at line 452 of file CaloNoiseCompCondAlg.cxx.

{
 
  StatusCode sc ;
  sc = this->initContainers();
  if (sc.isFailure()) {
    ATH_MSG_WARNING( "initContainers failed" ) ;
    return sc;
  }
 
  // reset diagnostics
  int maxgain =  m_isSC ? CaloGain::LARMEDIUMGAIN : CaloGain::LARNGAIN;
  for(int igain=0;igain<maxgain;++igain)
  {
    m_nCellsWithProblem[igain]=0;
    for(int i=0;i<5000;++i) m_nReason[i][igain]=0;
    for(int i=0;i<10;++i)   m_itReason[i][igain]=0;
  }
 
 
  //stores the Adc2MeV factors 
  sc = this->initAdc2MeV(adc2mev);
  if (!sc.isSuccess())  
    ATH_MSG_ERROR( "initData(): error with initAdc2MeV() " ); 
 
  //calculates and stores the electronic noise
  sc = this->initElecNoise(); 
  if (!sc.isSuccess())  
    ATH_MSG_ERROR( "initData(): error with initElecNoise() " );
 
  //calculates and stores the pileup noise
  sc = this->initPileUpNoise();
  if (!sc.isSuccess())  
    ATH_MSG_ERROR( "initData(): error with initPileUpNoise() ");
  
 
  return StatusCode::SUCCESS;
}

◆ initElecNoise()

StatusCode CaloNoiseCompCondAlg::initElecNoise ( )

private

Definition at line 526 of file CaloNoiseCompCondAlg.cxx.

{
  // initialize the parameters (the same for each event for each Identifier) 
  // for the calculation of the electronic noise
 
 
  MsgStream log( msgSvc(), name() );
  ATH_MSG_DEBUG( "initElecNoise() begin " );
 
  for (unsigned int it=0; it<m_elecNoiseCELLContainer.size(); ++it)
  {
    //::::::::::::::::::::::::::::::::::::::        
    m_elecNoiseCELLContainer[it] =
    this->calculateElecNoiseForLAR(m_idSymmCaloHashContainer[it]);
    //::::::::::::::::::::::::::::::::::::::
  }
  ATH_MSG_INFO("it filled");
 
  //print diagnostic
  int maxgain =  m_isSC ? CaloGain::LARMEDIUMGAIN : CaloGain::LARNGAIN;
  for(int igain=0;igain<maxgain;++igain)
    if(m_diagnostic[igain])
    {
      ATH_MSG_INFO("===== Diagnostic for  gain "<<igain<<" =====");
      for(int i=0;i<m_nCellsWithProblem[igain];++i)
      {
        Identifier id = m_calocell_id->cell_id(m_idHash[i][igain]);
        log<<MSG::DEBUG<<m_idHash[i][igain]<<" "
           <<m_lar_em_id->show_to_string(id)
           <<" "<<m_nReason[i][igain]<<" : ";
        for(int j=0;j<m_nReason[i][igain];++j)
          log<<MSG::DEBUG<<m_reasonName[m_reason[i][j][igain]]<<" ";
        log << MSG::DEBUG<<endmsg;
      }
      log<<MSG::DEBUG<<endmsg;
      ATH_MSG_INFO("N cells with problem(s) = " <<m_nCellsWithProblem[igain]);
      for(int i=0;i<10;++i)
      if(m_itReason[i][igain]>0) 
        ATH_MSG_INFO( i<<" "<<m_reasonName[i] <<": for "<<m_itReason[i][igain]<<" cells" );
    }
 
  ATH_MSG_DEBUG( "initElecNoise() end " );
  return StatusCode::SUCCESS;
}

◆ initialize()

StatusCode CaloNoiseCompCondAlg::initialize ( )

finaloverridevirtual

standard Athena-Algorithm method

Definition at line 46 of file CaloNoiseCompCondAlg.cxx.

                                 {
 
   ATH_CHECK( detStore()->retrieve( m_calo_id_man ) );
   m_calosupercell_id = m_calo_id_man->getCaloCell_SuperCell_ID();
   m_lar_em_id   = m_isSC ? static_cast<const LArEM_Base_ID*>(m_calosupercell_id->em_idHelper()) : 
                            static_cast<const LArEM_Base_ID*>(m_calo_id_man->getEM_ID());
   m_lar_hec_id  = m_isSC ? static_cast<const LArHEC_Base_ID*>(m_calosupercell_id->hec_idHelper()) : 
                            static_cast<const LArHEC_Base_ID*>(m_calo_id_man->getHEC_ID());
   m_lar_fcal_id = m_isSC ? static_cast<const LArFCAL_Base_ID*>(m_calosupercell_id->fcal_idHelper()) : 
                            static_cast<const LArFCAL_Base_ID*>(m_calo_id_man->getFCAL_ID());
 
   ATH_CHECK(m_LArOFCObjKey.initialize());
   ATH_CHECK(m_shapeKey.initialize());
   ATH_CHECK(m_fSamplKey.initialize());
   ATH_CHECK(m_LArMinBiasObjKey.initialize());
   ATH_CHECK(m_cablingKey.initialize());
   ATH_CHECK(m_adc2mevKey.initialize());
   ATH_CHECK(m_pedestalKey.initialize(m_noiseKey.empty()));
   ATH_CHECK(m_noiseKey.initialize(!m_noiseKey.empty()));
   ATH_CHECK(m_acorrKey.initialize());
 
   //diagnostic
   m_diagnostic[CaloGain::LARHIGHGAIN]  =m_DiagnosticHG;
   m_diagnostic[CaloGain::LARMEDIUMGAIN]=m_DiagnosticMG;
   m_diagnostic[CaloGain::LARLOWGAIN]   =m_DiagnosticLG;  
 
   //set calohash maximums
   m_LArHashMax =0;
   m_LArHashMax  =   m_lar_em_id->channel_hash_max()
                     + m_lar_hec_id->channel_hash_max()
                     + m_lar_fcal_id->channel_hash_max();
   m_CaloHashMax = m_LArHashMax;
 
   //set calohash minimum
   m_CaloHashMin = 0;
 
   ATH_MSG_DEBUG( " => CaloHashMin= " <<m_CaloHashMin << " CaloHashMax= " <<m_CaloHashMax ); 
   //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
   //gain-thresholds 
   m_LowGainThresh[CaloCell_ID::LAREM]    = 3900;//ADC counts in MediumGain 
   m_HighGainThresh[CaloCell_ID::LAREM]   = 1300;//ADC counts in MediumGain
   m_LowGainThresh[CaloCell_ID::LARHEC]   = 2500;//ADC counts in MediumGain 
   m_HighGainThresh[CaloCell_ID::LARHEC]  = 0;//-> high-gain never used for HEC
 
   m_LowGainThresh[CaloCell_ID::LARFCAL]  = 2000.;//ADC counts
   m_HighGainThresh[CaloCell_ID::LARFCAL] = 1100.;//ADC counts
 
   m_LowGainThresh[CaloCell_ID::TILE]  = 0.;// unit ?
   m_HighGainThresh[CaloCell_ID::TILE] = 0.;//
   //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
   m_highestGain[CaloCell_ID::LAREM]   = CaloGain::LARHIGHGAIN;
   m_highestGain[CaloCell_ID::LARHEC]  = CaloGain::LARMEDIUMGAIN;
   m_highestGain[CaloCell_ID::LARFCAL] = CaloGain::LARHIGHGAIN;
   m_highestGain[CaloCell_ID::TILE]    = CaloGain::TILEHIGHHIGH;
 
   //::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
 
   ATH_CHECK(m_outputElecKey.initialize());
   ATH_CHECK(m_outputPileupKey.initialize());
 
   ATH_CHECK( m_caloMgrKey.initialize() );
   ATH_CHECK( m_caloSCMgrKey.initialize(m_isSC) );
 
   return StatusCode::SUCCESS;
}

◆ initIndex()

StatusCode CaloNoiseCompCondAlg::initIndex ( )

private

Definition at line 297 of file CaloNoiseCompCondAlg.cxx.

                                {
  //::::::::::::::::::::::::::::::::::::::
  m_indexContainer.clear();
  m_indexContainer.resize(m_CaloHashMax,
                          static_cast<unsigned int> (-1));
 
  //maybe the other container sould be reset
  m_idSymmCaloHashContainer.clear();
  m_idSymmCaloHashContainer.reserve(5000);
 
  
  
  for (unsigned int intIdCaloHash=m_CaloHashMin; intIdCaloHash<m_CaloHashMax;
       ++intIdCaloHash)
  {  
    
 
    IdentifierHash idCaloHash=static_cast<IdentifierHash>(intIdCaloHash);
 
    // initialize the vector of indexes (big vector without symmetry)
 
 
 
 
    // o idCaloHash -> id -> idSymm (symmetry phi->0 and z->|z|)
    // o idSymm -> idSymmCaloHash
    // o idSymmCaloHash stored in m_idSymmCaloHashContainer
    // o an index is associated to an idSymmCaloHash
    // o index stored in m_indexContainer
    
    CaloCell_ID::SUBCALO iCalo = this->caloNum(idCaloHash); 
    Identifier     id    = m_calocell_id->cell_id(idCaloHash);
    Identifier     regId;
    Identifier     idSymm;
    IdentifierHash idSymmCaloHash;
 
    if(m_UseSymmetry){
      if(iCalo==CaloCell_ID::LAREM) 
      {
        int barrel_ec = m_lar_em_id->barrel_ec(id);
        int sampling  = m_lar_em_id->sampling(id);
        int region    = m_lar_em_id->region(id);
        int eta       = m_lar_em_id->eta(id);
        regId         = m_lar_em_id->region_id(abs(barrel_ec),sampling,region);
        idSymm        = m_lar_em_id->channel_id(regId,
                                                eta,
                                                m_calocell_id->phi_min(regId));
        idSymmCaloHash= m_calocell_id->calo_cell_hash(idSymm);
      }
      else if(iCalo==CaloCell_ID::LARHEC) 
      {
        int pos_neg  = m_lar_hec_id->pos_neg(id);
        int sampling = m_lar_hec_id->sampling(id);
        int region   = m_lar_hec_id->region(id);
        int eta      = m_lar_hec_id->eta(id);
        regId        = m_lar_hec_id->region_id(abs(pos_neg),sampling,region);
        idSymm       = m_lar_hec_id->channel_id(regId,
                                                eta,
                                                m_calocell_id->phi_min(regId));
        idSymmCaloHash= m_calocell_id->calo_cell_hash(idSymm);
      }
      else if(iCalo==CaloCell_ID::LARFCAL) 
      {
        int pos_neg = m_lar_fcal_id->pos_neg(id);
        int module  = m_lar_fcal_id->module(id);
        int eta     = m_lar_fcal_id->eta(id);
        int phi     = m_lar_fcal_id->phi(id);
        if(phi>7) phi = phi-8; //as in LArMCSymTool
        regId       = m_lar_fcal_id->module_id(abs(pos_neg),module);
        idSymm      = m_lar_fcal_id->channel_id(regId,
                                                eta,
                                                phi);
        idSymmCaloHash= m_calocell_id->calo_cell_hash(idSymm);
      }
      else if(iCalo==CaloCell_ID::TILE) 
      {
        idSymm         = id;
        idSymmCaloHash = m_calocell_id->calo_cell_hash(idSymm);
      }
      else
      {
        ATH_MSG_WARNING("CaloNoiseCompCondAlg::chooseIndex  wrong id ! " << m_lar_em_id->show_to_string(id));
        continue ;
      }
 
      assert (idSymmCaloHash < m_CaloHashMax);
      if (m_indexContainer[idSymmCaloHash] != static_cast<unsigned int>(-1)) {
        m_indexContainer[idCaloHash] = m_indexContainer[idSymmCaloHash];
        continue;
      }
    }
    else idSymmCaloHash=idCaloHash;// no symmetry
 
 
    if(iCalo!=CaloCell_ID::TILE) {
      if(this->checkIfConnected(id)==false) {
        continue; 
      }
    }
 
 
    /* cabling eta= 0 -> 0.8  (for private debug)
       int samp  = m_lar_em_id->sampling(id);
       int region= m_lar_em_id->region(id);
       int eta   = m_lar_em_id->eta(id);
       int phi   = m_lar_em_id->phi(id);
       if(samp==1 && eta>=256) return;
       if(samp==1 && eta==0) return;
       if(samp==2 && eta>=32) return;
       if(samp==3 && eta>=16) return;
       if(region>0) return;
    */
  
 
    //we come here if idSymmHash is not yet indexed (and is connected)   
    m_indexContainer[idCaloHash] = 
      m_indexContainer[idSymmCaloHash] =
      m_idSymmCaloHashContainer.size();
  
    m_idSymmCaloHashContainer.push_back(idSymmCaloHash);
  }// loop on all cells
 
  return StatusCode::SUCCESS;
}

◆ initPileUpNoise()

StatusCode CaloNoiseCompCondAlg::initPileUpNoise ( )

private

Definition at line 574 of file CaloNoiseCompCondAlg.cxx.

{
  // initialize the parameters (the same for each event for each Identifier) 
  // for the calculation of the PileUp noise
 
  ATH_MSG_DEBUG( "initPileUpNoise() begin " );
  ATH_MSG_INFO( "N events of Minimum Bias per bunch crossing =  " << m_Nminbias);
  //::::::::::::::::::::::::::::::::::::::
  for (unsigned int it=0; it<m_pileupNoiseContainer.size(); ++it)  
    m_pileupNoiseContainer[it]
      =this->calculatePileUpNoise(m_idSymmCaloHashContainer[it],m_Nminbias);
  //::::::::::::::::::::::::::::::::::::::
  ATH_MSG_DEBUG( "initPileUpNoise() end " );
  return StatusCode::SUCCESS;
}

◆ inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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 318 of file CaloNoiseCompCondAlg.h.

{
  if(tested_value<BADVALUE+1) return true;
  return false;
}

◆ isClonable()

bool AthCommonReentrantAlgorithm< Gaudi::Algorithm >::isClonable ( ) const

overridevirtualinherited

Specify if the algorithm is clonable.

Reentrant algorithms are clonable.

Reimplemented in InDet::GNNSeedingTrackMaker, InDet::SCT_Clusterization, InDet::SiSPGNNTrackMaker, InDet::SiSPSeededTrackFinder, InDet::SiTrackerSpacePointFinder, ITkPixelCablingAlg, ITkStripCablingAlg, RoIBResultToxAOD, SCT_ByteStreamErrorsTestAlg, SCT_CablingCondAlgFromCoraCool, SCT_CablingCondAlgFromText, SCT_ConditionsParameterTestAlg, SCT_ConditionsSummaryTestAlg, SCT_ConfigurationConditionsTestAlg, SCT_FlaggedConditionTestAlg, SCT_LinkMaskingTestAlg, SCT_MajorityConditionsTestAlg, SCT_ModuleVetoTestAlg, SCT_MonitorConditionsTestAlg, SCT_PrepDataToxAOD, SCT_RawDataToxAOD, SCT_ReadCalibChipDataTestAlg, SCT_ReadCalibDataTestAlg, SCT_RODVetoTestAlg, SCT_SensorsTestAlg, SCT_SiliconConditionsTestAlg, SCT_StripVetoTestAlg, SCT_TdaqEnabledTestAlg, SCT_TestCablingAlg, SCTEventFlagWriter, SCTRawDataProvider, SCTSiLorentzAngleTestAlg, SCTSiPropertiesTestAlg, and Simulation::BeamEffectsAlg.

Definition at line 68 of file AthCommonReentrantAlgorithm.cxx.

{
  // Reentrant algorithms are clonable.
  return true;
}

◆ isReEntrant()

virtual bool AthCondAlgorithm::isReEntrant ( ) const

inlineoverridevirtualinherited

Avoid scheduling algorithm multiple times.

With multiple concurrent events, conditions objects often expire simultaneously for all slots. To avoid that the scheduler runs the CondAlg in each slot, we declare it as "non-reentrant". This ensures that the conditions objects are only created once.

In case a particular CondAlg should behave differently, it can override this method again and return true.

See also: ATEAM-836

Definition at line 39 of file AthCondAlgorithm.h.

39{ return false; }

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

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

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

◆ outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< Gaudi::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 1158 of file CaloNoiseCompCondAlg.cxx.

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

◆ pileupNoiseRMS() [2/2]

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

Definition at line 1181 of file CaloNoiseCompCondAlg.cxx.

{
 
 
  const IdentifierHash idCaloHash = caloDDE->calo_hash();
  CaloCell_ID::SUBCALO iCalo = this->caloNum(idCaloHash);
  
  if(iCalo!=CaloCell_ID::TILE)
  {
    int index=this->index(idCaloHash);
    float PileUp;
    // check if noise stored in container was calcualted with this Nminbias
    if ((Nminbias==m_Nminbias) || (Nminbias<=0)) //default 
      PileUp=m_pileupNoiseContainer[index];
    else
      PileUp=this->calculatePileUpNoise(idCaloHash,Nminbias);//slower !!
    return PileUp;
  }
  else//TILE
  {
    return 0.;   
  }
}

◆ 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< Gaudi::Algorithm > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

◆ renounceArray()

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

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

◆ retrieveCellDatabase()

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

private

Definition at line 808 of file CaloNoiseCompCondAlg.cxx.

{
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //ADC2MEV
  if(retrieve[iADC2MEV])
  {
    {      
      int index=this->index(idCaloHash);
      m_Adc2MeVFactor = (m_adc2mevContainer[index])[igain];       
    } 
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //SIGMANOISE
  if(retrieve[iSIGMANOISE])
  {
    if(m_ped) { 
       m_RMSpedestal = m_ped->pedestalRMS(m_cabling->createSignalChannelID(id),igain);
       if(m_RMSpedestal>(1.0+LArElecCalib::ERRORCODE)) 
         m_SigmaNoise = m_RMSpedestal;
       else
       {     
         m_SigmaNoise = 0.;
       }
    } else {
       m_SigmaNoise = m_noise->noise(m_cabling->createSignalChannelID(id),igain);
 
    }
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //AUTOCORR
  if(retrieve[iAUTOCORR])
  {
    m_AutoCorr = m_acorr->autoCorr(m_cabling->createSignalChannelID(id),igain);
    ATH_MSG_VERBOSE("AutoCorr= ");
      for(unsigned int i=0;i<m_AutoCorr.size();++i)                
    ATH_MSG_VERBOSE(m_AutoCorr[i]<<" ");
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //OFC
  if(retrieve[iOFC])
  {
    m_OFC = m_ofccond->OFC_a(m_cabling->createSignalChannelID(id), igain) ;
    ATH_MSG_VERBOSE("OFC= ");
      for(unsigned int i=0;i<m_OFC.size();++i) 
    ATH_MSG_VERBOSE(m_OFC[i]<<" ");
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //SHAPE
  if(retrieve[iSHAPE])
  {
    m_Shape = m_shapecond->Shape(m_cabling->createSignalChannelID(id),0);
    ATH_MSG_VERBOSE("Shape= ");
      for(unsigned int i=0;i<m_Shape.size();++i) 
    ATH_MSG_VERBOSE(m_Shape[i]<<" ");
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //MinimumBias RMS 
  if(retrieve[iMINBIASRMS])
  {
    m_MinBiasRMS = m_minbias->minBiasRMS(m_cabling->createSignalChannelID(id));
    ATH_MSG_VERBOSE("MinBiasRMS="<<m_MinBiasRMS);
  }
 
  //:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
  //SAMPLING FRACTION
  if(retrieve[iFSAMPL])
  {
    m_fSampl = m_fsamplcond->FSAMPL(m_cabling->createSignalChannelID(id));
    ATH_MSG_VERBOSE("fSampl="<<m_fSampl);
  }
 
  return this->checkCellDatabase(id,igain, retrieve);
}

◆ setFilterPassed()

virtual void AthCommonReentrantAlgorithm< Gaudi::Algorithm >::setFilterPassed	(	bool	state,
		const EventContext &	ctx ) const

inlinevirtualinherited

Definition at line 100 of file AthCommonReentrantAlgorithm.h.

                                                                            {
    execState( ctx ).setFilterPassed( state );
  }

◆ stop()

StatusCode CaloNoiseCompCondAlg::stop ( )

finaloverridevirtual

Definition at line 115 of file CaloNoiseCompCondAlg.cxx.

                           {
 
   const EventContext& ctx = Gaudi::Hive::currentContext();
   
   if(m_isSC) {
      SG::ReadCondHandle<CaloSuperCellDetDescrManager> caloSCMgrHandle{m_caloSCMgrKey};
      if(!caloSCMgrHandle.isValid()) {
         ATH_MSG_ERROR( "Do not have CaloSuperCellDetDescrMgr");
         return StatusCode::FAILURE;
      }
 
      m_calo_dd_man  = static_cast<const CaloDetDescrManager_Base*>(*caloSCMgrHandle);
 
   } else {
      SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
      if(!caloMgrHandle.isValid()) {
         ATH_MSG_ERROR( "Do not have CaloDetDescrMgr");
         return StatusCode::FAILURE;
      }
 
      m_calo_dd_man  = static_cast<const CaloDetDescrManager_Base*>(*caloMgrHandle);
   }
   m_calocell_id = m_calo_dd_man->getCaloCell_ID();
 
 
   //Set up write handles
   SG::WriteCondHandle<CaloNoise> writeElecHandle{m_outputElecKey,ctx};
   SG::WriteCondHandle<CaloNoise> writePileupHandle{m_outputPileupKey,ctx};
 
   if (writeElecHandle.isValid() && writePileupHandle.isValid()) {
     ATH_MSG_DEBUG("Found valid write handles");
     return StatusCode::SUCCESS;
   }
 
   //Start with infinite range and narrow it down
   const EventIDRange fullRange=IOVInfiniteRange::infiniteMixed();
   writeElecHandle.addDependency (fullRange);
   writePileupHandle.addDependency (fullRange);
 
   // Read input conditions
   auto cablingHdl = SG::ReadCondHandle<LArOnOffIdMapping>(m_cablingKey, ctx);
   if(!cablingHdl.isValid()) {
      ATH_MSG_ERROR( "Do not have cabling");
      return StatusCode::FAILURE;
   }
   m_cabling=*cablingHdl;
   writeElecHandle.addDependency (cablingHdl);
   writePileupHandle.addDependency (cablingHdl);
 
   SG::ReadCondHandle<LArADC2MeV> adc2mevHdl (m_adc2mevKey, ctx);
   const LArADC2MeV* adc2mev{*adc2mevHdl};
   if(!adc2mev) {
      ATH_MSG_ERROR( "Do not have adc2mev");
      return StatusCode::FAILURE;
   }
   writeElecHandle.addDependency (adc2mevHdl);
   writePileupHandle.addDependency (adc2mevHdl);
 
   if(m_noiseKey.empty()) {
      auto pedHdl=SG::ReadCondHandle<ILArPedestal>(m_pedestalKey, ctx);
      if(!pedHdl.isValid()){
         ATH_MSG_ERROR( "Do not have pedestals");
         return StatusCode::FAILURE;
      }
      m_ped=*pedHdl;
      writeElecHandle.addDependency (pedHdl);
   } else {
      auto noiseHdl=SG::ReadCondHandle<ILArNoise>(m_noiseKey, ctx);
      if(!noiseHdl.isValid()){
         ATH_MSG_ERROR( "Do not have noise");
         return StatusCode::FAILURE;
      }
      m_noise=*noiseHdl;
      writeElecHandle.addDependency (noiseHdl);
 
   }
 
   auto acorrHdl=SG::ReadCondHandle<ILArAutoCorr>(m_acorrKey, ctx);
   if(!acorrHdl.isValid()){
      ATH_MSG_ERROR( "Do not have autocorr");
      return StatusCode::FAILURE;
   }
   m_acorr=*acorrHdl;
   writeElecHandle.addDependency (acorrHdl);
 
   auto ofcHdl=SG::ReadCondHandle<ILArOFC>(m_LArOFCObjKey, ctx);
   if(!ofcHdl.isValid()){
      ATH_MSG_ERROR( "Do not have ofc");
      return StatusCode::FAILURE;
   }
   m_ofccond=*ofcHdl;
   writeElecHandle.addDependency (ofcHdl);
   writePileupHandle.addDependency (ofcHdl);
 
   auto shapeHdl=SG::ReadCondHandle<ILArShape>(m_shapeKey, ctx);
   if(!shapeHdl.isValid()){
      ATH_MSG_ERROR( "Do not have shape");
      return StatusCode::FAILURE;
   }
   m_shapecond=*shapeHdl;
   writeElecHandle.addDependency (shapeHdl);
   writePileupHandle.addDependency (shapeHdl);
 
   auto fsamplHdl=SG::ReadCondHandle<ILArfSampl>(m_fSamplKey, ctx);
   if(!fsamplHdl.isValid()){
      ATH_MSG_ERROR( "Do not have fSampl");
      return StatusCode::FAILURE;
   }
   m_fsamplcond=*fsamplHdl;
   writePileupHandle.addDependency (fsamplHdl);
 
 
   auto minbiasHdl=SG::ReadCondHandle<ILArMinBias>(m_LArMinBiasObjKey, ctx);
   if(!minbiasHdl.isValid()){
      ATH_MSG_ERROR( "Do not have minbias");
      return StatusCode::FAILURE;
   }
   m_minbias=*minbiasHdl;
   writePileupHandle.addDependency (minbiasHdl);
 
   ATH_CHECK(this->initData(adc2mev));
 
   //Create the CaloNoise CDO:
   std::unique_ptr<CaloNoise> elecNoiseObj=std::make_unique<CaloNoise>(m_LArHashMax,m_nGains, 0,4,
                                       m_calocell_id,CaloNoise::ELEC);
   std::unique_ptr<CaloNoise> pileupNoiseObj=std::make_unique<CaloNoise>(m_LArHashMax,m_nGains, 0,4,
                                       m_calocell_id,CaloNoise::PILEUP);
   //Get writeable access to underlying storage (boost::multi_array)
   auto& elecnoise =  elecNoiseObj->larStorage();
   auto& pileupnoise =  pileupNoiseObj->larStorage();
 
   for(unsigned ihash=m_CaloHashMin; ihash < m_CaloHashMax; ++ihash) {
 
      Identifier id=m_calocell_id->cell_id(ihash);
      auto dde=m_calo_dd_man->get_element(id);
      auto elec3gains = elecNoiseRMS3gains(dde);
      auto pns = pileupNoiseRMS(dde,m_Nminbias);
 
      for (unsigned igain=0;igain<m_nGains;++igain) {
        elecnoise[igain][ihash] = elec3gains[igain]; 
        pileupnoise[igain][ihash] = pns;
      }
   }
 
   // store output
   ATH_CHECK(writeElecHandle.record(std::move(elecNoiseObj)));
   ATH_MSG_INFO("recorded new CaloNoise object with key " << writeElecHandle.key() << " and range " << writeElecHandle.getRange());
 
   ATH_CHECK(writePileupHandle.record(std::move(pileupNoiseObj)));
   ATH_MSG_INFO("recorded new CaloNoise object with key " << writePileupHandle.key() << " and range " << writePileupHandle.getRange());
 
   return StatusCode::SUCCESS;
}

◆ sysExecute()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::sysExecute ( const EventContext & ctx )

overridevirtualinherited

Execute an algorithm.

We override this in order to work around an issue with the Algorithm base class storing the event context in a member variable that can cause crashes in MT jobs.

Definition at line 85 of file AthCommonReentrantAlgorithm.cxx.

{
  return BaseAlg::sysExecute (ctx);
}

◆ sysInitialize()

StatusCode AthCommonReentrantAlgorithm< Gaudi::Algorithm >::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< Gaudi::Algorithm > >.

Reimplemented in HypoBase, and InputMakerBase.

Definition at line 61 of file AthCommonReentrantAlgorithm.cxx.

                                                               {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<BaseAlg>>::sysInitialize();
 
  if (sc.isFailure()) {
    return sc;
  }
  
  ServiceHandle<ICondSvc> cs("CondSvc",name());
  for (auto h : outputHandles()) {
    if (h->isCondition() && h->mode() == Gaudi::DataHandle::Writer) {
      // do this inside the loop so we don't create the CondSvc until needed
      if ( cs.retrieve().isFailure() ) {
        ATH_MSG_WARNING("no CondSvc found: won't autoreg WriteCondHandles");
        return StatusCode::SUCCESS;
      }      
      if (cs->regHandle(this,*h).isFailure()) {
        sc = StatusCode::FAILURE;
        ATH_MSG_ERROR("unable to register WriteCondHandle " << h->fullKey()
                      << " with CondSvc");
      }
    }
  }
  return sc;  
}

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< Gaudi::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 1166 of file CaloNoiseCompCondAlg.cxx.

                                       {
  float elecNoiseRMS_tmp   = this->elecNoiseRMS(theCell);
  float pileupNoiseRMS_tmp = this->pileupNoiseRMS(theCell,Nminbias);
  
  if(elecNoiseRMS_tmp>=0)
    return std::sqrt((elecNoiseRMS_tmp*elecNoiseRMS_tmp) + (pileupNoiseRMS_tmp*pileupNoiseRMS_tmp));
  return(-1);
}

◆ totalNoiseRMS() [2/2]

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

Definition at line 1211 of file CaloNoiseCompCondAlg.cxx.

{
  float elecNoiseRMS_tmp   = this->elecNoiseRMS(caloDDE,gain);
  float pileupNoiseRMS_tmp = this->pileupNoiseRMS(caloDDE,Nminbias);
  
  float totalNoiseRMS = -1;
  
  // checks that elecNoise is valid
  if(elecNoiseRMS_tmp>0) 
    totalNoiseRMS= std::sqrt((elecNoiseRMS_tmp*elecNoiseRMS_tmp) + (pileupNoiseRMS_tmp*pileupNoiseRMS_tmp) );
  
  return totalNoiseRMS;
}

◆ totalNoiseRMSHighestGain() [1/2]

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

Definition at line 1230 of file CaloNoiseCompCondAlg.cxx.

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

◆ totalNoiseRMSHighestGain() [2/2]

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

Definition at line 1239 of file CaloNoiseCompCondAlg.cxx.

{
  //getSubCalo can return 999999 (CaloCell_ID::SUBCALO::NOT_VALID)
  CaloCell_ID::SUBCALO iCalo = caloDDE->getSubCalo();
  if (iCalo ==  CaloCell_ID::SUBCALO::NOT_VALID){
    throw std::runtime_error("Invalid CaloID in CaloNoiseCompCondAlg::totalNoiseRMSHighestGain");
  }
  CaloGain::CaloGain highestGain=m_highestGain[iCalo];
  return this->totalNoiseRMS(caloDDE,highestGain,Nminbias);
}

◆ updateDiagnostic()

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

private

Definition at line 1031 of file CaloNoiseCompCondAlg.cxx.

{
  int nTmp=m_nCellsWithProblem[igain];
  if (nTmp >= 5000) return;
  int nr = m_nReason[nTmp][igain];
  if (nr >= 10) return;
  m_reason[nTmp][nr][igain]=ireason;
  m_reasonName[ireason]=nameReason;
  ++m_nReason[nTmp][igain];
  ++m_itReason[ireason][igain]; 
  noiseOK=false;
}

◆ updateVHKA()

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

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

◆ m_acorr

const ILArAutoCorr* CaloNoiseCompCondAlg::m_acorr =nullptr

private

Definition at line 244 of file CaloNoiseCompCondAlg.h.

◆ m_acorrKey

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

private

Definition at line 243 of file CaloNoiseCompCondAlg.h.

243{this,"AutocorrKey","LArAutoCorrSym","SG Key of LArAutoCorr object"};

◆ m_adc2mevContainer

VectorContainer CaloNoiseCompCondAlg::m_adc2mevContainer

private

Definition at line 274 of file CaloNoiseCompCondAlg.h.

◆ m_Adc2MeVFactor

float CaloNoiseCompCondAlg::m_Adc2MeVFactor {}

private

Definition at line 216 of file CaloNoiseCompCondAlg.h.

216{};

◆ m_adc2mevKey

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

private

Definition at line 235 of file CaloNoiseCompCondAlg.h.

235{this, "ADC2MeVKey", "LArADC2MeV", "SG Key of the LArADC2MeV CDO" };

◆ m_AdcPerMev

double CaloNoiseCompCondAlg::m_AdcPerMev {}

private

Definition at line 225 of file CaloNoiseCompCondAlg.h.

225{};

◆ m_atlas_id

const AtlasDetectorID* CaloNoiseCompCondAlg::m_atlas_id {}

private

Definition at line 182 of file CaloNoiseCompCondAlg.h.

182{};

◆ m_AutoCorr

LArVectorProxy CaloNoiseCompCondAlg::m_AutoCorr

private

Definition at line 219 of file CaloNoiseCompCondAlg.h.

◆ m_c

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

private

Definition at line 220 of file CaloNoiseCompCondAlg.h.

220{};

◆ m_cabling

const LArOnOffIdMapping* CaloNoiseCompCondAlg::m_cabling =nullptr

private

Definition at line 233 of file CaloNoiseCompCondAlg.h.

◆ m_cablingKey

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

private

Definition at line 232 of file CaloNoiseCompCondAlg.h.

232{this,"CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"};

◆ m_calo_dd_man

const CaloDetDescrManager_Base* CaloNoiseCompCondAlg::m_calo_dd_man =nullptr

private

Definition at line 230 of file CaloNoiseCompCondAlg.h.

◆ m_calo_id_man

const CaloIdManager* CaloNoiseCompCondAlg::m_calo_id_man {}

private

Definition at line 184 of file CaloNoiseCompCondAlg.h.

184{};

◆ m_calocell_id

const CaloCell_Base_ID* CaloNoiseCompCondAlg::m_calocell_id {}

private

Definition at line 190 of file CaloNoiseCompCondAlg.h.

190{};

◆ m_CaloHashMax

IdentifierHash CaloNoiseCompCondAlg::m_CaloHashMax

private

Definition at line 195 of file CaloNoiseCompCondAlg.h.

◆ m_CaloHashMin

IdentifierHash CaloNoiseCompCondAlg::m_CaloHashMin

private

Definition at line 196 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 228 of file CaloNoiseCompCondAlg.h.

228{this,"CaloDetDescrManager", "CaloDetDescrManager", "SG Key for CaloDetDescrManager in the Condition Store" };

◆ m_caloSCMgrKey

SG::ReadCondHandleKey<CaloSuperCellDetDescrManager> CaloNoiseCompCondAlg::m_caloSCMgrKey {this,"CaloSuperCellDetDescrManager", "CaloSuperCellDetDescrManager", "SG Key for CaloSuperCellDetDescrManager in the Condition Store" }

private

Definition at line 229 of file CaloNoiseCompCondAlg.h.

229{this,"CaloSuperCellDetDescrManager", "CaloSuperCellDetDescrManager", "SG Key for CaloSuperCellDetDescrManager in the Condition Store" };

◆ m_calosupercell_id

const CaloCell_SuperCell_ID* CaloNoiseCompCondAlg::m_calosupercell_id {}

private

Definition at line 191 of file CaloNoiseCompCondAlg.h.

191{};

◆ m_deltaBunch

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

private

Definition at line 201 of file CaloNoiseCompCondAlg.h.

201{this, "deltaBunch", 1};

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< Gaudi::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 172 of file CaloNoiseCompCondAlg.h.

172{};

◆ m_DiagnosticHG

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

private

Definition at line 204 of file CaloNoiseCompCondAlg.h.

204{this, "DiagnosticHG", false};

◆ m_DiagnosticLG

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

private

Definition at line 206 of file CaloNoiseCompCondAlg.h.

206{this, "DiagnosticLG", false};

◆ m_DiagnosticMG

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

private

Definition at line 205 of file CaloNoiseCompCondAlg.h.

205{this, "DiagnosticMG", false};

◆ m_DumpDatabaseHG

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

private

Definition at line 207 of file CaloNoiseCompCondAlg.h.

207{this, "DumpDatabaseHG", false};

◆ m_DumpDatabaseLG

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

private

Definition at line 209 of file CaloNoiseCompCondAlg.h.

209{this, "DumpDatabaseLG", false};

◆ m_DumpDatabaseMG

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

private

Definition at line 208 of file CaloNoiseCompCondAlg.h.

208{this, "DumpDatabaseMG", false};

◆ m_elecNoiseCELLContainer

VectorContainer CaloNoiseCompCondAlg::m_elecNoiseCELLContainer

private

Definition at line 272 of file CaloNoiseCompCondAlg.h.

◆ m_elecNoiseRAWContainer

VectorContainer CaloNoiseCompCondAlg::m_elecNoiseRAWContainer

private

Definition at line 271 of file CaloNoiseCompCondAlg.h.

◆ m_evtStore

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

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthCommonReentrantAlgorithm< Gaudi::Algorithm >::m_extendedExtraObjects

privateinherited

Extra output dependency collection, extended by AthAlgorithmDHUpdate to add symlinks.

Empty if no symlinks were found.

Definition at line 114 of file AthCommonReentrantAlgorithm.h.

◆ m_firstSample

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

private

Definition at line 202 of file CaloNoiseCompCondAlg.h.

202{this, "firstSample", 0};

◆ m_fSampl

float CaloNoiseCompCondAlg::m_fSampl {}

private

Definition at line 224 of file CaloNoiseCompCondAlg.h.

224{};

◆ m_fsamplcond

const ILArfSampl* CaloNoiseCompCondAlg::m_fsamplcond = nullptr

private

Definition at line 253 of file CaloNoiseCompCondAlg.h.

◆ m_fSamplKey

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

private

Definition at line 252 of file CaloNoiseCompCondAlg.h.

252{this,"fSamplKey","LArfSamplSym","SG Key of LArfSampl object"};

◆ m_highestGain

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

private

Definition at line 170 of file CaloNoiseCompCondAlg.h.

170{};

◆ m_HighGainThresh

float CaloNoiseCompCondAlg::m_HighGainThresh[m_nCalos] {}

private

Definition at line 169 of file CaloNoiseCompCondAlg.h.

169{};

◆ m_idHash

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

private

Definition at line 176 of file CaloNoiseCompCondAlg.h.

176{};

◆ m_idSymmCaloHashContainer

std::vector<IdentifierHash> CaloNoiseCompCondAlg::m_idSymmCaloHashContainer

private

Definition at line 267 of file CaloNoiseCompCondAlg.h.

◆ m_indexContainer

std::vector<IdentifierHash> CaloNoiseCompCondAlg::m_indexContainer

private

Definition at line 264 of file CaloNoiseCompCondAlg.h.

◆ m_isSC

BooleanProperty CaloNoiseCompCondAlg::m_isSC {this, "SuperCell", false}

private

Definition at line 211 of file CaloNoiseCompCondAlg.h.

211{this, "SuperCell", false};

◆ m_itReason

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

private

Definition at line 175 of file CaloNoiseCompCondAlg.h.

175{};

◆ m_lar_em_id

const LArEM_Base_ID* CaloNoiseCompCondAlg::m_lar_em_id {}

private

Definition at line 186 of file CaloNoiseCompCondAlg.h.

186{};

◆ m_lar_fcal_id

const LArFCAL_Base_ID* CaloNoiseCompCondAlg::m_lar_fcal_id {}

private

Definition at line 188 of file CaloNoiseCompCondAlg.h.

188{};

◆ m_lar_hec_id

const LArHEC_Base_ID* CaloNoiseCompCondAlg::m_lar_hec_id {}

private

Definition at line 187 of file CaloNoiseCompCondAlg.h.

187{};

◆ m_LArHashMax

IdentifierHash CaloNoiseCompCondAlg::m_LArHashMax

private

Definition at line 193 of file CaloNoiseCompCondAlg.h.

◆ m_LArMinBiasObjKey

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

private

Definition at line 255 of file CaloNoiseCompCondAlg.h.

255{this, "LArMinBiasKey", "LArMinBiasSym", "SG Key of LArMinBias"};

◆ m_LArOFCObjKey

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

private

Definition at line 246 of file CaloNoiseCompCondAlg.h.

246{this, "OFKey","LArOFC", "SG Key of LAr OFCs"};

◆ m_LowGainThresh

float CaloNoiseCompCondAlg::m_LowGainThresh[m_nCalos] {}

private

Definition at line 168 of file CaloNoiseCompCondAlg.h.

168{};

◆ m_minbias

const ILArMinBias* CaloNoiseCompCondAlg::m_minbias = nullptr

private

Definition at line 256 of file CaloNoiseCompCondAlg.h.

◆ m_MinBiasRMS

float CaloNoiseCompCondAlg::m_MinBiasRMS {}

private

Definition at line 226 of file CaloNoiseCompCondAlg.h.

226{};

◆ m_nCalos

int CaloNoiseCompCondAlg::m_nCalos =NCALOS

staticconstexprprivate

Definition at line 166 of file CaloNoiseCompCondAlg.h.

◆ m_nCellsWithProblem

int CaloNoiseCompCondAlg::m_nCellsWithProblem[m_nGains] {}

private

Definition at line 173 of file CaloNoiseCompCondAlg.h.

173{};

◆ m_nGains

int CaloNoiseCompCondAlg::m_nGains =NGAINS

staticconstexprprivate

Definition at line 167 of file CaloNoiseCompCondAlg.h.

◆ m_Nminbias

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

private

Definition at line 210 of file CaloNoiseCompCondAlg.h.

210{this, "NMinBias", -1};

◆ m_noise

const ILArNoise* CaloNoiseCompCondAlg::m_noise =nullptr

private

Definition at line 241 of file CaloNoiseCompCondAlg.h.

◆ m_noiseKey

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

private

Definition at line 240 of file CaloNoiseCompCondAlg.h.

240{this,"NoiseKey","","SG Key of LArNoise object"};

◆ m_nReason

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

private

Definition at line 174 of file CaloNoiseCompCondAlg.h.

174{};

◆ m_nsamples

int CaloNoiseCompCondAlg::m_nsamples {}

private

Definition at line 222 of file CaloNoiseCompCondAlg.h.

222{};

◆ m_OFC

LArVectorProxy CaloNoiseCompCondAlg::m_OFC

private

Definition at line 217 of file CaloNoiseCompCondAlg.h.

◆ m_ofccond

const ILArOFC* CaloNoiseCompCondAlg::m_ofccond =nullptr

private

Definition at line 247 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 259 of file CaloNoiseCompCondAlg.h.

259{this, "OutputElecKey", "elecNoise", "SG Key of resulting noise CDO"};

◆ m_outputPileupKey

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

private

Definition at line 260 of file CaloNoiseCompCondAlg.h.

260{this, "OutputPileupKey", "pileupNoise", "SG Key of resulting noise CDO"};

◆ m_ped

const ILArPedestal* CaloNoiseCompCondAlg::m_ped =nullptr

private

Definition at line 238 of file CaloNoiseCompCondAlg.h.

◆ m_pedestalKey

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

private

Definition at line 237 of file CaloNoiseCompCondAlg.h.

237{this,"PedestalKey","LArPedestal","SG Key of LArPedestal object"};

◆ m_pileupNoiseContainer

SingleContainer CaloNoiseCompCondAlg::m_pileupNoiseContainer

private

Definition at line 273 of file CaloNoiseCompCondAlg.h.

◆ m_reason

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

private

Definition at line 177 of file CaloNoiseCompCondAlg.h.

177{};

◆ m_reasonName

std::string CaloNoiseCompCondAlg::m_reasonName[10]

private

Definition at line 179 of file CaloNoiseCompCondAlg.h.

◆ m_ReturnNoiseName

std::string CaloNoiseCompCondAlg::m_ReturnNoiseName

private

Definition at line 162 of file CaloNoiseCompCondAlg.h.

◆ m_RMSpedestal

float CaloNoiseCompCondAlg::m_RMSpedestal {}

private

Definition at line 221 of file CaloNoiseCompCondAlg.h.

221{};

◆ m_Shape

LArVectorProxy CaloNoiseCompCondAlg::m_Shape

private

Definition at line 218 of file CaloNoiseCompCondAlg.h.

◆ m_shapecond

const ILArShape* CaloNoiseCompCondAlg::m_shapecond =nullptr

private

Definition at line 250 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 249 of file CaloNoiseCompCondAlg.h.

249{this,"ShapeKey","LArShapeSym","SG Key of Shape conditions object"};

◆ m_SigmaNoise

float CaloNoiseCompCondAlg::m_SigmaNoise {}

private

Definition at line 223 of file CaloNoiseCompCondAlg.h.

223{};

◆ m_TileHashMax

IdentifierHash CaloNoiseCompCondAlg::m_TileHashMax

private

Definition at line 194 of file CaloNoiseCompCondAlg.h.

◆ m_UseSymmetry

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

private

Definition at line 203 of file CaloNoiseCompCondAlg.h.

203{this, "UseSymmetry", true};

◆ m_varHandleArraysDeclared

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

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ CaloNoiseCompCondAlg()

◆ ~CaloNoiseCompCondAlg()

Member Function Documentation

◆ adc2mev() [1/2]

◆ adc2mev() [2/2]

◆ calculateElecNoiseForLAR()

◆ calculatePileUpNoise()

◆ caloNum()

◆ cardinality()

◆ checkCellDatabase()

◆ checkIfConnected()

◆ commonCalculations()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ elecNoiseRMS() [1/2]

◆ elecNoiseRMS() [2/2]

◆ elecNoiseRMS3gains()

◆ estimatedGain() [1/3]

◆ estimatedGain() [2/3]

◆ estimatedGain() [3/3]

◆ estimatedLArGain()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ filterPassed()

◆ finalize()

◆ index()

◆ initAdc2MeV()

◆ initContainers()

◆ initData()

◆ initElecNoise()

◆ initialize()

◆ initIndex()

◆ initPileUpNoise()

◆ inputHandles()

◆ isBadValue()

◆ isClonable()

◆ isReEntrant()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ pileupNoiseRMS() [1/2]

◆ pileupNoiseRMS() [2/2]

◆ renounce()

◆ renounceArray()

◆ retrieveCellDatabase()

◆ setFilterPassed()

◆ stop()

◆ sysExecute()

◆ sysInitialize()

◆ sysStart()

◆ totalNoiseRMS() [1/2]

◆ totalNoiseRMS() [2/2]

◆ totalNoiseRMSHighestGain() [1/2]

◆ totalNoiseRMSHighestGain() [2/2]

◆ updateDiagnostic()

◆ updateVHKA()

Member Data Documentation

◆ m_acorr

◆ m_acorrKey

◆ m_adc2mevContainer

◆ m_Adc2MeVFactor

◆ m_adc2mevKey

◆ m_AdcPerMev

◆ m_atlas_id

◆ m_AutoCorr

◆ m_c

◆ m_cabling