#include <LArNoiseBursts.h>

Inheritance diagram for LArNoiseBursts:

Public Member Functions
	LArNoiseBursts (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor.
virtual	~LArNoiseBursts ()=default
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
	Finalize - delete any memory allocation from the heap.
virtual StatusCode	execute () override
	Execute - on event by event.
virtual StatusCode	clear ()
	Clear - clear CBNT members.
virtual StatusCode	sysInitialize () override
	Override sysInitialize.
virtual const DataObjIDColl &	extraOutputDeps () const override
	Return the list of extra output dependencies.
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	doTrigger ()
	methods called by execute()
StatusCode	doEventProperties ()
StatusCode	doLArNoiseBursts ()
int	GetPartitionLayerIndex (const Identifier &id)
StatusCode	fillCell (HWIdentifier onlID, float eCalo, float qfactor, CaloGain::CaloGain gain, const LArOnOffIdMapping cabling, const LArBadChannelCont bcCont, const CaloNoise &totalNoise, const CaloDetDescrManager *caloMgr)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
ServiceHandle< ITHistSvc >	m_thistSvc {this,"THistSvc","THistSvc"}
TTree *	m_tree
SG::ReadCondHandleKey< LArOnOffIdMapping >	m_cablingKey { this, "CablingKey","LArOnOffIdMap","SG Key of LArOnOffIdMapping object"}
SG::ReadCondHandleKey< LArBadChannelCont >	m_BCKey { this, "BadChanKey","LArBadChannel","SG Key of LArBadChannelCont object"}
SG::ReadCondHandleKey< CaloNoise >	m_totalNoiseKey { this, "TotalNoiseKey", "totalNoise", "SG key for total noise" }
SG::ReadCondHandleKey< BunchCrossingCondData >	m_bcDataKey {this, "BunchCrossingCondDataKey", "BunchCrossingData" ,"SG Key of BunchCrossing CDO"}
PublicToolHandle< Trig::TrigDecisionTool >	m_trigDec {this, "TrigDecisionTool", "", "Handle to the TrigDecisionTool"}
SG::ReadHandleKey< LArNoisyROSummary >	m_NoisyROKey { this, "LArNoisyROSummaryKey","LArNoisyROSummary","SG Key of LArNoisyROSummar object"}
const LArOnlineID *	m_LArOnlineIDHelper
const LArHVLineID *	m_LArHVLineIDHelper
const LArElectrodeID *	m_LArElectrodeIDHelper
const LArEM_ID *	m_LArEM_IDHelper
const LArFCAL_ID *	m_LArFCAL_IDHelper
const LArHEC_ID *	m_LArHEC_IDHelper
SG::ReadCondHandleKey< CaloDetDescrManager >	m_caloMgrKey
std::string	m_elecContainerName
double	m_sigmacut
bool	m_CosmicCaloStream
unsigned int	m_frontbunches
bool	m_keepOnlyCellID
int	m_nb_sat
int	m_lowqfactor
int	m_medqfactor
int	m_hiqfactor
long	m_noisycell
int	m_nt_larcellsize
int	m_nt_cellsize
int	m_nt_run
unsigned long	m_nt_evtId
int	m_nt_evtTime
int	m_nt_evtTime_ns
int	m_nt_lb
int	m_nt_bcid
int	m_nt_isbcidFilled
int	m_nt_isbcidInTrain
std::vector< int >	m_nt_isBunchesInFront
int	m_nt_bunchtype
float	m_nt_bunchtime
unsigned int	m_nt_atlasready
unsigned int	m_nt_stablebeams
std::vector< std::string >	m_nt_streamTagName
std::vector< std::string >	m_nt_streamTagType
bool	m_nt_larflag_badFEBs
bool	m_nt_larflag_mediumSaturatedDQ
bool	m_nt_larflag_tightSaturatedDQ
bool	m_nt_larflag_noiseBurstVeto
bool	m_nt_larflag_dataCorrupted
bool	m_nt_larflag_dataCorruptedVeto
bool	m_nt_larflag_badFEBS_w
bool	m_nt_larflag_mnbLoose
bool	m_nt_larflag_mnbTight
bool	m_nt_larflag_mnbTight_psveto
bool	m_nt_larflag_badHVlines
uint8_t	m_nt_badHVPartitions
std::vector< unsigned int >	m_nt_badHVlines
bool	m_nt_L1_J75
bool	m_nt_L1_J10_EMPTY
bool	m_nt_L1_J30_FIRSTEMPTY
bool	m_nt_L1_J30_EMPTY
bool	m_nt_L1_XE40
bool	m_nt_L1_XE50
bool	m_nt_L1_XE50_BGRP7
bool	m_nt_L1_XE70
bool	m_nt_EF_j165_u0uchad_LArNoiseBurst
bool	m_nt_EF_j30_u0uchad_empty_LArNoiseBurst
bool	m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst
bool	m_nt_EF_j55_u0uchad_empty_LArNoiseBurst
bool	m_nt_EF_xe45_LArNoiseBurst
bool	m_nt_EF_xe55_LArNoiseBurst
bool	m_nt_EF_xe60_LArNoiseBurst
bool	m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT
bool	m_nt_EF_j100_u0uchad_LArNoiseBurstT
bool	m_nt_EF_j165_u0uchad_LArNoiseBurstT
bool	m_nt_EF_j130_u0uchad_LArNoiseBurstT
bool	m_nt_EF_j35_u0uchad_empty_LArNoiseBurst
bool	m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst
bool	m_nt_EF_j80_u0uchad_LArNoiseBurstT
float	m_nt_ECTimeDiff
float	m_nt_ECTimeAvg
int	m_nt_nCellA
int	m_nt_nCellC
std::vector< float >	m_nt_energycell
std::vector< float >	m_nt_qfactorcell
std::vector< float >	m_nt_phicell
std::vector< float >	m_nt_etacell
std::vector< float >	m_nt_signifcell
std::vector< short >	m_nt_barrelec_noisy
std::vector< short >	m_nt_posneg_noisy
std::vector< short >	m_nt_ft_noisy
std::vector< short >	m_nt_slot_noisy
std::vector< short >	m_nt_channel_noisy
std::vector< short >	m_nt_cellpartlayerindex
std::vector< unsigned int >	m_nt_cellIdentifier
std::vector< unsigned int >	m_nt_onlIdentifier
std::vector< float >	m_nt_noisycellpart
std::vector< int >	m_nt_noisycellHVphi
std::vector< int >	m_nt_noisycellHVeta
std::vector< std::vector< short > >	m_nt_samples
std::vector< int >	m_nt_gain
std::vector< int >	m_nt_isbadcell
std::vector< int >	m_nt_partition
std::vector< int >	m_nt_layer
std::vector< int >	m_nt_isbadcell_sat
std::vector< int >	m_nt_barrelec_sat
std::vector< int >	m_nt_posneg_sat
std::vector< short >	m_nt_ft_sat
std::vector< short >	m_nt_slot_sat
std::vector< short >	m_nt_channel_sat
std::vector< int >	m_nt_partition_sat
std::vector< float >	m_nt_energy_sat
std::vector< float >	m_nt_phicell_sat
std::vector< float >	m_nt_etacell_sat
std::vector< int >	m_nt_layer_sat
std::vector< unsigned int >	m_nt_cellIdentifier_sat
DataObjIDColl	m_extendedExtraObjects
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

Detailed Description

Definition at line 56 of file LArNoiseBursts.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

◆ LArNoiseBursts()

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

Constructor.

Definition at line 84 of file LArNoiseBursts.cxx.

  : AthAlgorithm(name, pSvcLocator),
    m_tree(nullptr),
    m_LArOnlineIDHelper(nullptr),
    m_LArHVLineIDHelper(nullptr),
    m_LArElectrodeIDHelper(nullptr),
    m_LArEM_IDHelper(nullptr),
    m_LArFCAL_IDHelper(nullptr),
    m_LArHEC_IDHelper(nullptr),
    m_CosmicCaloStream(false),
    m_nb_sat(0),
    m_lowqfactor(0),
    m_medqfactor(0),
    m_hiqfactor(0),
    m_noisycell(0),
    m_nt_larcellsize(0),
    m_nt_cellsize(0),
    m_nt_run(0),
    m_nt_evtId(0),
    m_nt_evtTime(0),
    m_nt_evtTime_ns(0),
    m_nt_lb(0),
    m_nt_bcid(0),
    //m_nt_ntracks(0),
    m_nt_isbcidFilled(0),
    m_nt_isbcidInTrain(0),
    m_nt_isBunchesInFront(0),
    m_nt_bunchtype(0),
    m_nt_bunchtime(0),
    m_nt_atlasready(0),
    m_nt_stablebeams(0),
    m_nt_streamTagName(0),
    m_nt_streamTagType(0),
    m_nt_larflag_badFEBs(false),
    m_nt_larflag_mediumSaturatedDQ(false),
    m_nt_larflag_tightSaturatedDQ(false),
    m_nt_larflag_noiseBurstVeto(false),
    m_nt_larflag_dataCorrupted(false),
    m_nt_larflag_dataCorruptedVeto(false),
    m_nt_larflag_badFEBS_w(false),
    m_nt_larflag_mnbLoose(false),
    m_nt_larflag_mnbTight(false),
    m_nt_larflag_mnbTight_psveto(false),
    m_nt_larflag_badHVlines(false),
    m_nt_badHVPartitions(0),
    m_nt_L1_J75(false),
    m_nt_L1_J10_EMPTY(false),
    m_nt_L1_J30_FIRSTEMPTY(false),
    m_nt_L1_J30_EMPTY(false),
    m_nt_L1_XE40(false),
    m_nt_L1_XE50(false),
    m_nt_L1_XE50_BGRP7(false),
    m_nt_L1_XE70(false),
    m_nt_EF_j165_u0uchad_LArNoiseBurst(false),
    m_nt_EF_j30_u0uchad_empty_LArNoiseBurst(false),
    m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst(false),
    m_nt_EF_j55_u0uchad_empty_LArNoiseBurst(false),
    m_nt_EF_xe45_LArNoiseBurst(false),
    m_nt_EF_xe55_LArNoiseBurst(false),
    m_nt_EF_xe60_LArNoiseBurst(false),
    m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT(false),
    m_nt_EF_j100_u0uchad_LArNoiseBurstT(false),
    m_nt_EF_j165_u0uchad_LArNoiseBurstT(false),
    m_nt_EF_j130_u0uchad_LArNoiseBurstT(false),
    m_nt_EF_j35_u0uchad_empty_LArNoiseBurst(false),
    m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst(false),
    m_nt_EF_j80_u0uchad_LArNoiseBurstT(false),
    m_nt_ECTimeDiff(0),
    m_nt_ECTimeAvg(0),
    m_nt_nCellA(0),
    m_nt_nCellC(0),
    m_nt_energycell(0),
    m_nt_qfactorcell(0),
    m_nt_phicell(0),
    m_nt_etacell(0),
    m_nt_signifcell(0),
    //m_nt_noisycellpercent(0),
    m_nt_barrelec_noisy(0),
    m_nt_posneg_noisy(0),
    m_nt_ft_noisy(0),
    m_nt_slot_noisy(0),
    m_nt_channel_noisy(0),
    m_nt_cellpartlayerindex(0),
    m_nt_cellIdentifier(0),
    m_nt_onlIdentifier(0),
    m_nt_noisycellpart(0),
    m_nt_noisycellHVphi(0),
    m_nt_noisycellHVeta(0),
    m_nt_samples(0),
    m_nt_gain(0),
    m_nt_isbadcell(0),
    m_nt_partition(0),
    m_nt_layer(0),
    m_nt_isbadcell_sat(0),
    m_nt_barrelec_sat(0),
    m_nt_posneg_sat(0),
    m_nt_ft_sat(0),
    m_nt_slot_sat(0),
    m_nt_channel_sat(0),
    m_nt_partition_sat(0),
    m_nt_energy_sat(0),
    m_nt_phicell_sat(0),
    m_nt_etacell_sat(0),
    m_nt_layer_sat(0),
    m_nt_cellIdentifier_sat(0)
 {
 
   //event cuts
   declareProperty("SigmaCut", m_sigmacut = 3.0);
   declareProperty("NumberOfBunchesInFront",m_frontbunches = 36);
   
   // Keep cell properties
   declareProperty("KeepOnlyCellID",          m_keepOnlyCellID = false);
 }

◆ ~LArNoiseBursts()

virtual LArNoiseBursts::~LArNoiseBursts ( )

virtualdefault

Member Function Documentation

◆ clear()

StatusCode LArNoiseBursts::clear ( )

virtual

Clear - clear CBNT members.

For Athena-Aware NTuple

HV branches

Definition at line 377 of file LArNoiseBursts.cxx.

                                 {
 
  ATH_MSG_DEBUG ( "start clearing variables " );
  
  m_nb_sat     = 0;
  m_noisycell  = 0;
  m_lowqfactor = 0;
  m_medqfactor = 0;
  m_hiqfactor  = 0;
 
  m_nt_run        = 0;
  m_nt_evtId      = 0;
  m_nt_evtTime    = 0;
  m_nt_evtTime_ns = 0;
  m_nt_lb         = 0;
  m_nt_bcid       = -1;
 
  m_nt_streamTagName.clear();
  m_nt_streamTagType.clear();
  m_nt_isbcidFilled     = -1;
  m_nt_isbcidInTrain    = -1;
  m_nt_isBunchesInFront.clear();
  m_nt_bunchtype        = -1;
  m_nt_bunchtime        = -1.0;
  m_nt_atlasready       = -1;
  m_nt_stablebeams      = -1;
 
 
  ATH_MSG_DEBUG ( "clearing LAr event flags " );
 
  // lar bit event info
  m_nt_larflag_badFEBs = false;
  m_nt_larflag_mediumSaturatedDQ = false;
  m_nt_larflag_tightSaturatedDQ = false;
  m_nt_larflag_noiseBurstVeto = false;
  m_nt_larflag_dataCorrupted = false;
  m_nt_larflag_dataCorruptedVeto = false;
  m_nt_larflag_badFEBS_w = false;
  m_nt_larflag_mnbLoose = false;
  m_nt_larflag_mnbTight = false;
  m_nt_larflag_mnbTight_psveto = false;
  m_nt_larflag_badHVlines = false;
 
  m_nt_badHVPartitions = 0;
  m_nt_badHVlines.clear();
 
  ATH_MSG_DEBUG ( "clearing Pixel variables " );
 
  // Trigger flags
  m_nt_L1_J75 = true; // turned on for tests
  m_nt_L1_J10_EMPTY = false;
  m_nt_L1_J30_FIRSTEMPTY = false;
  m_nt_L1_J30_EMPTY = false;
  m_nt_L1_XE40 = false;
  m_nt_L1_XE50 = false;
  m_nt_L1_XE50_BGRP7 = false;
  m_nt_L1_XE70 = false;
  
  m_nt_EF_j165_u0uchad_LArNoiseBurst = false;
  m_nt_EF_j30_u0uchad_empty_LArNoiseBurst = false;
  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst = false;
  m_nt_EF_j55_u0uchad_empty_LArNoiseBurst = false;
  m_nt_EF_xe45_LArNoiseBurst = false;
  m_nt_EF_xe55_LArNoiseBurst = false;
  m_nt_EF_xe60_LArNoiseBurst = false;
  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT = false;
  m_nt_EF_j100_u0uchad_LArNoiseBurstT = false;
  m_nt_EF_j165_u0uchad_LArNoiseBurstT = false;
  m_nt_EF_j130_u0uchad_LArNoiseBurstT = false;
  m_nt_EF_j35_u0uchad_empty_LArNoiseBurst = false;
  m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst = false;
  m_nt_EF_j80_u0uchad_LArNoiseBurstT = false;
   
  ATH_MSG_DEBUG ( "clearing noisy cells variables " );
 
  //Quantities for noisy cells
  m_nt_energycell.clear();
  m_nt_qfactorcell.clear();
  m_nt_phicell.clear();
  m_nt_etacell.clear();
  m_nt_signifcell.clear();
  m_nt_isbadcell.clear();
  m_nt_partition.clear();
  m_nt_layer.clear();
  //m_nt_noisycellpercent = -1;
  m_nt_barrelec_noisy.clear();
  m_nt_posneg_noisy.clear();
  m_nt_ft_noisy.clear();
  m_nt_slot_noisy.clear();
  m_nt_channel_noisy.clear();
  m_nt_larcellsize = -1;
  m_nt_cellsize    = -1;
  m_nt_cellpartlayerindex.clear();
  m_nt_cellIdentifier.clear();
  m_nt_onlIdentifier.clear();
  m_nt_noisycellpart.clear();
  m_nt_samples.clear();
  m_nt_gain.clear();
  m_nt_noisycellHVphi.clear();
  m_nt_noisycellHVeta.clear();
 
  ATH_MSG_DEBUG ( "clearing saturated cell variables " );
 
  //clearing quantities for sat cells
  m_nt_barrelec_sat.clear();
  m_nt_posneg_sat.clear();
  m_nt_ft_sat.clear();
  m_nt_slot_sat.clear();
  m_nt_channel_sat.clear();
  m_nt_partition_sat.clear();
  m_nt_energy_sat.clear();
  m_nt_phicell_sat.clear();
  m_nt_etacell_sat.clear();
  m_nt_layer_sat.clear();
  m_nt_cellIdentifier_sat.clear();
  m_nt_isbadcell_sat.clear();
 
  ATH_MSG_DEBUG ( "clearing LArTimeDiff variables " );
  
  //DiffTime computed with LAR
  m_nt_ECTimeDiff  = 9999;
  m_nt_ECTimeAvg   = 9999;
  m_nt_nCellA      = -1;
  m_nt_nCellC      = -1;
 
  return StatusCode::SUCCESS;
}

◆ declareGaudiProperty()

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.

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

◆ declareProperty()

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

StoreGateSvc_t m_detStore

Definition AthCommonDataStore.h:393

◆ doEventProperties()

StatusCode LArNoiseBursts::doEventProperties ( )

private

Definition at line 655 of file LArNoiseBursts.cxx.

                                            {
  ATH_MSG_DEBUG ("in doEventProperties ");
 
  // Retrieve event info
  const xAOD::EventInfo* eventInfo = nullptr;
  ATH_CHECK( evtStore()->retrieve(eventInfo) );
 
  int run = eventInfo->runNumber();
  m_nt_run        = eventInfo->runNumber();
  m_nt_evtId      = eventInfo->eventNumber();
  m_nt_evtTime    = eventInfo->timeStamp();
  m_nt_evtTime_ns = eventInfo->timeStampNSOffset();
  m_nt_lb         = eventInfo->lumiBlock();
  m_nt_bcid       = eventInfo->bcid();
 
  ATH_MSG_DEBUG("Run Number: "<<run<<", event Id "<<m_nt_evtId<<", bcid = "<<m_nt_bcid);
  
  SG::ReadCondHandle<BunchCrossingCondData> bccd (m_bcDataKey);
  const BunchCrossingCondData* bunchCrossing=*bccd;
  if (!bunchCrossing) {
    ATH_MSG_ERROR("Failed to retrieve Bunch Crossing obj");
    return StatusCode::FAILURE;
  }
 
  m_nt_isbcidFilled = bunchCrossing->isFilled(m_nt_bcid);
  m_nt_isbcidInTrain = bunchCrossing->isInTrain(m_nt_bcid);
  m_nt_bunchtype = bunchCrossing->bcType(m_nt_bcid);
  ATH_MSG_DEBUG("BCID is Filled: "<<m_nt_isbcidFilled);
  ATH_MSG_DEBUG("BCID is in Train: "<<m_nt_isbcidInTrain);
  ATH_MSG_DEBUG("bunch type "<<m_nt_bunchtype);
 
  unsigned int distFromFront = bunchCrossing->distanceFromFront(m_nt_bcid,BunchCrossingCondData::BunchCrossings);
  if(m_frontbunches < distFromFront) distFromFront=m_frontbunches;
 
  bool checkfirstbunch = true;
  for(unsigned int i=1;i<=distFromFront;i++){
     bool isFilled=bunchCrossing->isFilled(m_nt_bcid-i);
     ATH_MSG_DEBUG("bunch "<<i<<" is Filled "<<isFilled);
     m_nt_isBunchesInFront.push_back(isFilled);
       if(isFilled){
         if(i!=1){
           if(checkfirstbunch){
             float time = 25.0*i;
             m_nt_bunchtime = time;
             ATH_MSG_DEBUG("next bunch time: "<<time<<" ns ");
             checkfirstbunch = false;
       }
     }
     }
  }
 
  m_CosmicCaloStream = false;
  //std::vector<TriggerInfo::StreamTag>::const_iterator streamInfoIt=myTriggerInfo->streamTags().begin();
  //std::vector<TriggerInfo::StreamTag>::const_iterator streamInfoIt_e=myTriggerInfo->streamTags().end();
  //for (;streamInfoIt!=streamInfoIt_e;streamInfoIt++) { 
  for (const auto& streamInfo : eventInfo->streamTags()) {
    const std::string& stream_name = streamInfo.name();
    const std::string& stream_type = streamInfo.type();
    m_nt_streamTagName.push_back(stream_name);
    m_nt_streamTagType.push_back(stream_type);
    ATH_MSG_DEBUG("event stream tag name "<<streamInfo.name());
    ATH_MSG_DEBUG("event stream tag type "<<streamInfo.type());
    if(streamInfo.name()=="CosmicCalo" && streamInfo.type()=="physics"){
      m_CosmicCaloStream = true;
    }
  }
  
 
   // LArEventInfo
 
  ATH_MSG_DEBUG ("NOISEBURSTVETO bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO) );
  ATH_MSG_DEBUG ("BADFEBS bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS));
  ATH_MSG_DEBUG ("TIGHTSATURATEDQ bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ));
 
  m_nt_larflag_badFEBs = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS);
  m_nt_larflag_mediumSaturatedDQ = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MEDIUMSATURATEDQ);
  m_nt_larflag_tightSaturatedDQ = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ);
  m_nt_larflag_noiseBurstVeto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO);
  m_nt_larflag_dataCorrupted = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::DATACORRUPTED);
  m_nt_larflag_dataCorruptedVeto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::DATACORRUPTEDVETO);
  m_nt_larflag_badFEBS_w =eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS_W);
  m_nt_larflag_mnbLoose = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTLOOSE);
  m_nt_larflag_mnbTight = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTTIGHT);
  m_nt_larflag_mnbTight_psveto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTTIGHT_PSVETO);
  m_nt_larflag_badHVlines = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADHVLINES);
  
 
  //const AthenaAttributeList* attrList(0);
  //ATH_CHECK( evtStore()->retrieve(attrList, "/TDAQ/RunCtrl/DataTakingMode") );
  //if (attrList != 0) {
  //  ATH_MSG_DEBUG ("ReadyForPhysics is: " << (*attrList)["ReadyForPhysics"].data<uint32_t>());
  //  //m_valueCache = ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
  //  m_nt_atlasready = (*attrList)["ReadyForPhysics"].data<uint32_t>();
  // }
 
   /*const AthenaAttributeList* fillstate(0);
  sc =  evtStore()->retrieve(fillstate, "/LHC/DCS/FILLSTATE");
  if (sc.isFailure()) {
     ATH_MSG_WARNING ("Unable to retrieve fillstate information; falling back to" );
     return StatusCode::SUCCESS;
   }
   if (fillstate != 0) {
     ATH_MSG_DEBUG ("Stable beams is: " << (*fillstate)["StableBeams"].data<uint32_t>());
     //m_valueCache = ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
     m_nt_stablebeams.push_back((*fillstate)["StableBeams"].data<uint32_t>());
     }*/
 
  
  // 29/11/10 : Debug messages removed by BT 
  //   mLog << MSG::INFO << "Event LAr flags " << std::hex
  //      << eventInfo->errorState(xAOD::EventInfo::LAr) << " "
  //      << std::hex << eventInfo->eventFlags(xAOD::EventInfo::LAr)
  //      << ", bit 0: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,0)
  //      << ", bit 1: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,1)
  //      << ", bit 2: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,2)
  //      << endmsg;
 
  // Retrieve LArCollision Timing information
  const LArCollisionTime *  larTime=nullptr;
  if (evtStore()->contains<LArCollisionTime>("LArCollisionTime")) {
     StatusCode sc =  evtStore()->retrieve(larTime,"LArCollisionTime");
     if( sc.isFailure()){
       ATH_MSG_WARNING  ( "Unable to retrieve LArCollisionTime event store" );
       //return StatusCode::SUCCESS; // Check if failure shd be returned. VB
     }else {
       ATH_MSG_DEBUG  ( "LArCollisionTime successfully retrieved from event store" );
     }
  }
  
  if (larTime) {
      m_nt_nCellA = larTime->ncellA();
      m_nt_nCellC = larTime->ncellC();
    if(m_nt_nCellA>0 && m_nt_nCellC>0){
      // Calculate the time diff between ECC and ECA
      m_nt_ECTimeDiff = larTime->timeC() - larTime->timeA();
      m_nt_ECTimeAvg  = (larTime->timeC() + larTime->timeA()) * 0.5;
      ATH_MSG_DEBUG  ( "LAr: Calculated time difference of " << m_nt_ECTimeDiff << " ns" );
    }
  }
 
  return StatusCode::SUCCESS;
}

◆ doLArNoiseBursts()

StatusCode LArNoiseBursts::doLArNoiseBursts ( )

private

Definition at line 805 of file LArNoiseBursts.cxx.

                                           {
  ATH_MSG_DEBUG ( "in doLarCellInfo " );
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  SG::ReadCondHandle<LArOnOffIdMapping> larCablingHdl (m_cablingKey, ctx);
  const LArOnOffIdMapping* cabling=*larCablingHdl;
  if(!cabling) {
     ATH_MSG_WARNING("Do not have cabling info, not storing LarCellInfo ");
     return StatusCode::SUCCESS;
  }
 
  SG::ReadCondHandle<LArBadChannelCont> bcHdl (m_BCKey, ctx);
  const LArBadChannelCont* bcCont=*bcHdl;
  if(!bcCont) {
     ATH_MSG_WARNING("Do not have bad chan info, not storing LarCellInfo ");
     return StatusCode::SUCCESS;
  }
 
  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey, ctx};
  ATH_CHECK(caloMgrHandle.isValid());
  const CaloDetDescrManager* caloMgr = *caloMgrHandle;
 
 // first fill HVline from NoisyROSummary object
  SG::ReadHandle<LArNoisyROSummary> noisyRO(m_NoisyROKey, ctx); 
  if(noisyRO.isValid()) {
     auto hwidlist = noisyRO->get_noisy_hvlines();
     for (auto hw : hwidlist) {
        m_nt_badHVlines.push_back(hw.get_identifier32().get_compact());
     }
     m_nt_badHVPartitions = noisyRO->HVlineFlaggedPartitions();
  } else {
     ATH_MSG_WARNING("Do not have LArNoisyROSummary object, no HVlines filled !!");
  }
 
 // Retrieve LAr calocells container
 // or LArRawChannel container, whatsever available...
  const CaloCellContainer* caloTES=nullptr;
  const LArRawChannelContainer* LArTES=nullptr;
  const LArRawChannelContainer* LArTES_dig=nullptr;
  if(evtStore()->contains<CaloCellContainer>("AllCalo")) {
     ATH_CHECK(evtStore()->retrieve( caloTES, "AllCalo"));
  } else if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels") || evtStore()->contains<LArRawChannelContainer>("LArRawChannels_fB")) {
         if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels")) {
            ATH_CHECK(evtStore()->retrieve( LArTES_dig, "LArRawChannels"));
         }
         if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels_fB")) {
            ATH_CHECK(evtStore()->retrieve( LArTES, "LArRawChannels_fB"));
         }
  }
 
  if (caloTES==nullptr && LArTES==nullptr) {
    ATH_MSG_WARNING ( "Neither CaloCell nor LArRawChannel Containers found!" );
    return StatusCode::SUCCESS;
  }
 
  m_nb_sat = 0;
  m_noisycell =0;
  nlarcell = 0;
  v_barrelec_noisy.clear(); v_posneg_noisy.clear();
  v_ft_noisy.clear();v_slot_noisy.clear();v_channel_noisy.clear();
  v_isbarrel.clear();v_isendcap.clear();v_isfcal.clear();v_ishec.clear();
  v_layer.clear();v_partition.clear();v_energycell.clear();v_qfactorcell.clear(); 
  v_phicell.clear();v_etacell.clear();v_signifcell.clear();v_isbadcell.clear();
  v_IdHash.clear();v_noisycellHVeta.clear();v_noisycellHVphi.clear();
  v_cellpartlayerindex.clear();v_cellIdentifier.clear();v_onlIdentifier.clear();
 
  float eCalo;
  float qfactor;
  CaloGain::CaloGain gain;
 
  SG::ReadCondHandle<CaloNoise> totalNoise (m_totalNoiseKey, ctx);
 
  if(caloTES) {
     for (const CaloCell* cell : *caloTES) {
       const CaloDetDescrElement* caloDDE = cell->caloDDE();
       if (caloDDE->is_tile())continue;
       HWIdentifier onlID;
       try {onlID = cabling->createSignalChannelID(cell->ID());}
       catch(LArID_Exception& except) {
         ATH_MSG_ERROR  ( "LArID_Exception " << m_LArEM_IDHelper->show_to_string(cell->ID()) << " " << (std::string) except );
         ATH_MSG_ERROR  ( "LArID_Exception " << m_LArHEC_IDHelper->show_to_string(cell->ID()) );
         ATH_MSG_ERROR  ( "LArID_Exception " << m_LArFCAL_IDHelper->show_to_string(cell->ID()) );
         continue;
       }
       bool connected = cabling->isOnlineConnected(onlID);
       if(!connected) continue;
       eCalo = cell->energy();
       qfactor = cell->quality();
       gain = cell->gain();
       //if(qfactor > 0. || cell->ID() == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cell->ID()<<" : "<<eCalo<<" "<<qfactor<<" "<<gain<<" prov.: "<<cell->provenance());
       ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
     }//loop over cells
     ATH_MSG_DEBUG("Done cells "<<nlarcell);
  } else {
     std::vector<HWIdentifier> chdone; 
     if (LArTES_dig) {
       LArRawChannelContainer::const_iterator caloItr;
       for(caloItr=LArTES_dig->begin();caloItr!=LArTES_dig->end();++caloItr){
         HWIdentifier onlID=caloItr->identify();
         bool connected = cabling->isOnlineConnected(onlID);
         if(!connected) continue;
         eCalo = caloItr->energy();
         qfactor = caloItr->quality();
         gain = caloItr->gain();
         //if(qfactor>0 || cabling->cnvToIdentifier((*caloItr).identify()) == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cabling->cnvToIdentifier((*caloItr).identify())<<" : "<<eCalo<<" "<<qfactor<<" "<<gain);
         ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
         chdone.push_back(onlID);
       }//loop over raw channels
     }  
     ATH_MSG_DEBUG("Done raw chan. from digi "<<nlarcell);
     // dirty hack, if we are already complete:
     if (nlarcell < 182468 && LArTES) { // add those raw channels, which were not from dig.
       LArRawChannelContainer::const_iterator caloItr;
       for(caloItr=LArTES->begin();caloItr!=LArTES->end();++caloItr){
         HWIdentifier onlID=caloItr->identify();
         if(std::find(chdone.begin(), chdone.end(), onlID) != chdone.end()) continue;
         bool connected = cabling->isOnlineConnected(onlID);
         if(!connected) continue;
         eCalo = caloItr->energy();
         qfactor = caloItr->quality();
         gain = caloItr->gain();
         //if(qfactor>0 || cabling->cnvToIdentifier((*caloItr).identify()) == Identifier((IDENTIFIER_TYPE)0x33c9500000000000)  ) ATH_MSG_DEBUG(cabling->cnvToIdentifier((*caloItr).identify())<<" : "<<eCalo<<" "<<qfactor<<" "<<gain);
         ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
       }//loop over raw channels
     }  
     ATH_MSG_DEBUG("Done raw chan. "<<nlarcell);
  } // if raw chanels
  
  m_nt_larcellsize = nlarcell;
  if(caloTES) {
    m_nt_cellsize    = caloTES->size();
  }
  else if (LArTES) {
     m_nt_cellsize = LArTES->size();
  }
  ATH_MSG_DEBUG ("lar cell size = "<<int(nlarcell));
  if(caloTES) ATH_MSG_DEBUG ("all cell size = "<<int(caloTES->size()));
  else {
     if(LArTES_dig) ATH_MSG_DEBUG ("all LArRawCh. from digi size = "<<int(LArTES_dig->size()));
     if(LArTES) ATH_MSG_DEBUG ("all LArRawCh. size = "<<int(LArTES->size()));
  }
 
  //if (nlarcell > 0)
  //  m_nt_noisycellpercent = 100.0*double(n_noisycell)/double(nlarcell);
  //else
  //  m_nt_noisycellpercent = 0;
 
  bool checknoise = false;
  //ratio of noisy cells per partition
  for(unsigned int i=0;i<8;i++){
    float noise  =  100.0*(double(n_noisy_cell_part[i])/double(n_cell_part[i]));
    m_nt_noisycellpart.push_back(noise);
    if(noise> 1.0){
      checknoise = true;
      ATH_MSG_DEBUG ("noise burst in this  event ");
    }   
  }
 
  const LArDigitContainer* LArDigitCont=nullptr;
  if (evtStore()->contains<LArDigitContainer>("FREE")) ATH_CHECK(evtStore()->retrieve( LArDigitCont, "FREE"));
  if(!LArDigitCont) {
     if (evtStore()->contains<LArDigitContainer>("LArDigitContainer_Thinned")) ATH_CHECK(evtStore()->retrieve( LArDigitCont, "LArDigitContainer_Thinned"));
  }
  if (!LArDigitCont) {
    ATH_MSG_WARNING ( "LArDigitContainer Container not found!" );
    return StatusCode::SUCCESS;
  }    
 
  bool store_condition = false;
  // CosmicCalo stream : Store detailed infos of cells only if Y3Sigma>1% or burst found by LArNoisyRO
  if(m_CosmicCaloStream){
    if(checknoise==true || m_nt_larflag_badFEBs || m_nt_larflag_tightSaturatedDQ){
      store_condition = true;
    }
  }
  // Not cosmicCalo stream : Store detailed infos of cells only if burst found by LArNoisyRO
  if(!m_CosmicCaloStream){
    if(m_nt_larflag_badFEBs || m_nt_larflag_tightSaturatedDQ){
      store_condition = true;
    }
  }
 
  //store the information of the noisy cell only when %noisycells > 1%.
  if(store_condition){
    std::vector<short> samples;
    samples.clear();
    for(unsigned int k=0;k<v_etacell.size();k++){
      m_nt_samples.push_back(samples);
      m_nt_gain.push_back(0);
    }
    for (const LArDigit* pLArDigit : *LArDigitCont) {
         HWIdentifier id2 = pLArDigit->hardwareID();
         IdentifierHash hashid2 = m_LArOnlineIDHelper->channel_Hash(id2);
          for(unsigned int j=0;j<v_IdHash.size();j++){
            if (hashid2 == v_IdHash[j] ){
              ATH_MSG_DEBUG ( "find a IdentifierHash of the noisy cell in LArDigit container " );
              samples = pLArDigit->samples();
              int gain=-1;
              if (pLArDigit->gain() == CaloGain::LARHIGHGAIN)   gain = 0;
              if (pLArDigit->gain() == CaloGain::LARMEDIUMGAIN) gain = 1;
              if (pLArDigit->gain() == CaloGain::LARLOWGAIN)    gain = 2;
              m_nt_gain.at(j)= gain;
              m_nt_samples.at(j) = samples;
              ATH_MSG_DEBUG ( "I got the samples!" );
              break;
        }  
     }
     }
    for(unsigned int i=0;i<v_etacell.size();i++){
      m_nt_energycell.push_back( v_energycell[i]);
      m_nt_qfactorcell.push_back( v_qfactorcell[i]);
      m_nt_signifcell.push_back( v_signifcell[i]);
      m_nt_partition.push_back( v_partition[i]);   
      m_nt_cellIdentifier.push_back(v_cellIdentifier[i].get_identifier32().get_compact());
      m_nt_onlIdentifier.push_back(v_onlIdentifier[i].get_identifier32().get_compact());
      if(!m_keepOnlyCellID){
        m_nt_barrelec_noisy.push_back( v_barrelec_noisy[i]);
        m_nt_posneg_noisy.push_back( v_posneg_noisy[i]);
        m_nt_ft_noisy.push_back( v_ft_noisy[i]);
        m_nt_slot_noisy.push_back( v_slot_noisy[i]);
        m_nt_channel_noisy.push_back( v_channel_noisy[i]);
   
        /*
        m_nt_isbarrel.push_back( v_isbarrel[i]);
        m_nt_isendcap.push_back( v_isendcap[i]);
        m_nt_isfcal.push_back( v_isfcal[i]);
        m_nt_ishec.push_back( v_ishec[i]);
        */
   
        m_nt_layer.push_back( v_layer[i]);
        m_nt_phicell.push_back( v_phicell[i]);
        m_nt_etacell.push_back( v_etacell[i]);
        m_nt_isbadcell.push_back( v_isbadcell[i]);
        m_nt_noisycellHVphi.push_back(v_noisycellHVphi[i]);     
        m_nt_noisycellHVeta.push_back(v_noisycellHVeta[i]);
        m_nt_cellpartlayerindex.push_back(v_cellpartlayerindex[i]);
      }
    }         
    ATH_MSG_DEBUG ("leaving if checknoise and larnoisyro");
 
  }//if(checknoisy==true ..)
 
  return StatusCode::SUCCESS;
  
}

◆ doTrigger()

StatusCode LArNoiseBursts::doTrigger ( )

private

methods called by execute()

Definition at line 555 of file LArNoiseBursts.cxx.

                                    {
  ATH_MSG_DEBUG ("in doTrigger ");
  
  std::string mychain( "L1_J75" );
  if( ! m_trigDec->getListOfTriggers(mychain).empty() ){
    m_nt_L1_J75 = m_trigDec->isPassed( mychain );
  }
  mychain = "L1_J10_EMPTY";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_L1_J10_EMPTY =  m_trigDec->isPassed( mychain );
  }
  mychain = "L1_J30_FIRSTEMPTY";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_L1_J30_FIRSTEMPTY =  m_trigDec->isPassed( mychain );
  }
  mychain = "L1_J30_EMPTY";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_L1_J30_EMPTY =  m_trigDec->isPassed( mychain );
  }
  mychain = "L1_XE40";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_L1_XE40 =  m_trigDec->isPassed( mychain );
  }
  mychain = "L1_XE50";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_L1_XE50 =  m_trigDec->isPassed( mychain );
  }
  mychain = "L1_XE50_BGRP7";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_L1_XE50_BGRP7 =  m_trigDec->isPassed( mychain );
  }
  mychain = "L1_XE70";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_L1_XE70 =  m_trigDec->isPassed( mychain );
  }
 
  // EF
  mychain = "EF_j165_u0uchad_LArNoiseBurst";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j165_u0uchad_LArNoiseBurst =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j30_u0uchad_empty_LArNoiseBurst";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j30_u0uchad_empty_LArNoiseBurst =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j55_u0uchad_firstempty_LArNoiseBurst";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j55_u0uchad_empty_LArNoiseBurst";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j55_u0uchad_empty_LArNoiseBurst =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_xe45_LArNoiseBurst";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_xe45_LArNoiseBurst =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_xe55_LArNoiseBurst";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_xe55_LArNoiseBurst =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_xe60_LArNoiseBurst";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_xe60_LArNoiseBurst =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j55_u0uchad_firstempty_LArNoiseBurstT";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j100_u0uchad_LArNoiseBurstT";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j100_u0uchad_LArNoiseBurstT =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j165_u0uchad_LArNoiseBurstT";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j165_u0uchad_LArNoiseBurstT =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j130_u0uchad_LArNoiseBurstT";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j130_u0uchad_LArNoiseBurstT =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j35_u0uchad_empty_LArNoiseBurst";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j35_u0uchad_empty_LArNoiseBurst =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j35_u0uchad_firstempty_LArNoiseBurst";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst =  m_trigDec->isPassed( mychain );
  }
  mychain = "EF_j80_u0uchad_LArNoiseBurstT";
  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
    m_nt_EF_j80_u0uchad_LArNoiseBurstT =  m_trigDec->isPassed( mychain );
  }
 
  return StatusCode::SUCCESS;
}

◆ evtStore()

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; }

AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore

StoreGateSvc_t m_evtStore

Definition AthCommonDataStore.h:390

◆ execute()

StatusCode LArNoiseBursts::execute ( )

overridevirtual

Execute - on event by event.

Definition at line 511 of file LArNoiseBursts.cxx.

                                   {
  ATH_MSG_DEBUG ( "in execute()" );
 
  StatusCode sc = clear();
  if(sc.isFailure()) {
    ATH_MSG_WARNING ( "The method clear() failed" );
    return StatusCode::SUCCESS;
  }
  
  if(!m_trigDec.empty()){
 
     sc = doTrigger();
     if(sc.isFailure()) {
       ATH_MSG_WARNING ( "The method doTrigger() failed" );
       return StatusCode::SUCCESS;
     }
  }
 
  sc = doEventProperties();
  if(sc.isFailure()) {
    ATH_MSG_WARNING ( "The method doEventProperties() failed" );
    return StatusCode::SUCCESS;
  }
 
  sc = doLArNoiseBursts();
  if (sc.isFailure()) {
    ATH_MSG_WARNING ( "The method doLArNoiseBursts() failed" );
    return StatusCode::SUCCESS;
  }
 
//  sc = doPhysicsObjects();
//  if (sc.isFailure()) {
//    ATH_MSG_WARNING ( "The method doPhysicsObjects() failed" );
//    return StatusCode::SUCCESS;
//  }
  
  m_tree->Fill();
 
  return StatusCode::SUCCESS;
}

◆ 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.

{
  // 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 Algorithm::extraOutputDeps();
}

◆ fillCell()

StatusCode LArNoiseBursts::fillCell	(	HWIdentifier	onlID,
		float	eCalo,
		float	qfactor,
		CaloGain::CaloGain	gain,
		const LArOnOffIdMapping *	cabling,
		const LArBadChannelCont *	bcCont,
		const CaloNoise &	totalNoise,
		const CaloDetDescrManager *	caloMgr )

private

Definition at line 1051 of file LArNoiseBursts.cxx.

{
    const Identifier idd = cabling->cnvToIdentifier(onlID);
    nlarcell++;
    IdentifierHash channelHash = m_LArOnlineIDHelper->channel_Hash(onlID);
    const CaloDetDescrElement *caloDDE = caloMgr->get_element(idd);
    int layer = caloDDE->getLayer();
    //    CaloCell_ID::CaloSample sampling = (*caloItr)->caloDDE()->getSampling();
    float phi = caloDDE->phi();
    float noise  = totalNoise.getNoise (idd, gain);
    float significance = eCalo / noise ;
    float eta = caloDDE->eta();
    bool badcell = ! (bcCont->status(onlID)).good();
    unsigned int partition = 0;
    bool is_lar_em_barrel = caloDDE->is_lar_em_barrel();
    if(is_lar_em_barrel){
       if(eta<0){
          partition = 0;
        }else{
          partition = 1;
        }
    }//barrel
    bool is_lar_em_endcap = caloDDE->is_lar_em_endcap();
    if(is_lar_em_endcap){
        if(eta<0){
          partition = 2;
        }else{
          partition = 3;
    }
    }//endcap
    bool is_lar_fcal   = caloDDE->is_lar_fcal();
    if(is_lar_fcal){
        if(eta<0){
          partition = 4;
        }else{
          partition = 5;
    }
    }//fcal
    bool is_lar_hec    = caloDDE->is_lar_hec();
    if(is_lar_hec){
      if(eta<0){
        partition = 6;
      }else{
        partition = 7;
      }
    }//hec
    for(unsigned int k=0;k<8;k++){
       if(partition==k){
          n_cell_part[k]++;
       }
    }
    if(qfactor <1000)                  {m_lowqfactor++;}
    if(qfactor>=1000 && qfactor<10000) {m_medqfactor++;}
    if(qfactor>=10000 && qfactor<65535){m_hiqfactor++;}
    if(qfactor==65535){
      ATH_MSG_DEBUG ("Satured cell at eta: "<<eta<<", phi: "<<phi<<", energy: "<<eCalo<<", partition: "<<partition);
       m_nb_sat = m_nb_sat +1;
       m_nt_partition_sat.push_back(partition);
       m_nt_energy_sat.push_back(eCalo);
       m_nt_cellIdentifier_sat.push_back((cabling->cnvToIdentifier(onlID)).get_identifier32().get_compact());
       if(!m_keepOnlyCellID){
         m_nt_barrelec_sat.push_back(m_LArOnlineIDHelper->barrel_ec(onlID));
         m_nt_posneg_sat.push_back(m_LArOnlineIDHelper->pos_neg(onlID));
         m_nt_ft_sat.push_back(m_LArOnlineIDHelper->feedthrough(onlID));
         m_nt_slot_sat.push_back(m_LArOnlineIDHelper->slot(onlID));
         m_nt_channel_sat.push_back(m_LArOnlineIDHelper->channel(onlID));
         m_nt_phicell_sat.push_back(phi);
         m_nt_etacell_sat.push_back(eta);
         m_nt_layer_sat.push_back(layer);
         m_nt_isbadcell_sat.push_back(badcell);
       }
    }
    // Store all cells in positive and negative 3 sigma tails...
    if(significance > m_sigmacut || qfactor > 4000){
      v_barrelec_noisy.push_back(m_LArOnlineIDHelper->barrel_ec(onlID));
      v_posneg_noisy.push_back(m_LArOnlineIDHelper->pos_neg(onlID));
      v_ft_noisy.push_back(m_LArOnlineIDHelper->feedthrough(onlID));
      v_slot_noisy.push_back(m_LArOnlineIDHelper->slot(onlID));
      v_channel_noisy.push_back(m_LArOnlineIDHelper->channel(onlID));
 
      /*
      v_isbarrel.push_back(is_lar_em_barrel);
      v_isendcap.push_back(is_lar_em_endcap);
      v_isfcal.push_back(is_lar_fcal);
      v_ishec.push_back(is_lar_hec);
      */
 
      v_layer.push_back(layer);
      v_energycell.push_back(eCalo);
      v_qfactorcell.push_back(qfactor);
      v_phicell.push_back(phi);
      v_etacell.push_back(eta);
      v_signifcell.push_back(significance);
      v_isbadcell.push_back(badcell);
      v_partition.push_back(partition);
      v_IdHash.push_back(channelHash);
      v_cellIdentifier.push_back(cabling->cnvToIdentifier(onlID));
      v_onlIdentifier.push_back(onlID);
    // ...but count only cells in positive 3 sigma tails!
      if (significance > m_sigmacut){
    m_noisycell++;
        ATH_MSG_DEBUG ("Noisy cell: "<<m_noisycell<<" "<<cabling->cnvToIdentifier(onlID)<<" q: "<<qfactor<<" sign.: "<<significance<<" noise: "<<noise);
    for(unsigned int k=0;k<8;k++){
      if(partition==k){
        n_noisy_cell_part[k]++;
      }
    }
      }
      int caloindex = GetPartitionLayerIndex(idd);
      v_cellpartlayerindex.push_back(caloindex);
      v_noisycellHVphi.push_back(m_LArElectrodeIDHelper->hv_phi(onlID));
      v_noisycellHVeta.push_back(m_LArElectrodeIDHelper->hv_eta(onlID));
 
      
    }   
    return StatusCode::SUCCESS;
}    

◆ finalize()

StatusCode LArNoiseBursts::finalize ( )

overridevirtual

Finalize - delete any memory allocation from the heap.

Definition at line 370 of file LArNoiseBursts.cxx.

                                    {
  ATH_MSG_DEBUG ( "in finalize()" );
  return StatusCode::SUCCESS;
}

◆ GetPartitionLayerIndex()

int LArNoiseBursts::GetPartitionLayerIndex ( const Identifier & id )

private

Definition at line 1176 of file LArNoiseBursts.cxx.

{
  // O.Simard -- GetPartitionLayer index [0,32]:
  // Returns a single integer code that corresponds to the
  // mapping of CaloCells in CaloMonitoring histogram frames.
 
  int caloindex = -1;
  int bc = 0;
  int sampling = 0;
 
  if(m_LArEM_IDHelper->is_lar_em(id)){ // EMB
    bc = m_LArEM_IDHelper->barrel_ec(id);
    sampling = m_LArEM_IDHelper->sampling(id);
    if(abs(bc)==1){
      if(bc<0) caloindex = sampling+4;
      else caloindex = sampling;
    } else { // EMEC
      if(bc<0) caloindex = sampling+12;
      else caloindex = sampling+8;
    }
  } else if(m_LArHEC_IDHelper->is_lar_hec(id)) { // LAr HEC
    bc = m_LArHEC_IDHelper->pos_neg(id);
    sampling = m_LArHEC_IDHelper->sampling(id);
    if(bc<0) caloindex = sampling+20;
    else caloindex = sampling+16;
  } else if(m_LArFCAL_IDHelper->is_lar_fcal(id)) { // LAr FCAL
    bc = m_LArFCAL_IDHelper->pos_neg(id);
    sampling = (int)m_LArFCAL_IDHelper->module(id); // module instead of sampling
    if(bc<0) caloindex = sampling+26;
    else caloindex = sampling+23;
  }
 
  return caloindex;
}

◆ initialize()

StatusCode LArNoiseBursts::initialize ( )

overridevirtual

get a handle on the NTuple and histogramming service

Prepare TTree

NEW Identifier of the cell

Definition at line 200 of file LArNoiseBursts.cxx.

                                      {
 
  ATH_MSG_DEBUG ( "Initializing LArNoiseBursts" );
 
  // Trigger Decision Tool
  ATH_CHECK( m_trigDec.retrieve() );
  
  ATH_CHECK( m_cablingKey.initialize() );
  ATH_CHECK( m_BCKey.initialize() );
  ATH_CHECK( m_totalNoiseKey.initialize() );
  ATH_CHECK( m_bcDataKey.initialize() );
  ATH_CHECK( m_NoisyROKey.initialize() );
 
  // Retrieve online ID helper
  const LArOnlineID* LArOnlineIDHelper = nullptr;
  ATH_CHECK( detStore()->retrieve(LArOnlineIDHelper, "LArOnlineID") );
  m_LArOnlineIDHelper = LArOnlineIDHelper;
  ATH_MSG_DEBUG( " Found LArOnline Helper");
 
  // Retrieve HV line ID helper
  const LArHVLineID* LArHVLineIDHelper = nullptr;
    ATH_CHECK( detStore()->retrieve(LArHVLineIDHelper, "LArHVLineID") );
  m_LArHVLineIDHelper = LArHVLineIDHelper;
  ATH_MSG_DEBUG( " Found LArOnlineIDHelper Helper");
 
  // Retrieve HV electrode ID helper
  const LArElectrodeID* LArElectrodeIDHelper = nullptr;
  ATH_CHECK( detStore()->retrieve(LArElectrodeIDHelper, "LArElectrodeID") );
  m_LArElectrodeIDHelper = LArElectrodeIDHelper;
  ATH_MSG_DEBUG( " Found LArElectrodeIDHelper Helper");
 
  ATH_CHECK(m_caloMgrKey.initialize());
 
  // Retrieve ID helpers
  const CaloCell_ID* idHelper = nullptr;
  ATH_CHECK( detStore()->retrieve (idHelper, "CaloCell_ID") );
  m_LArEM_IDHelper   = idHelper->em_idHelper();
  m_LArHEC_IDHelper  = idHelper->hec_idHelper();
  m_LArFCAL_IDHelper = idHelper->fcal_idHelper();
  
  ATH_CHECK( m_thistSvc.retrieve() );
 
  m_tree = new TTree( "CollectionTree", "CollectionTree" );
  std::string treeName =  "/TTREE/CollectionTree" ;
  ATH_CHECK( m_thistSvc->regTree(treeName, m_tree) );
 
  // General properties of events
  m_tree->Branch("Run",&m_nt_run,"Run/I");// Event ID
  m_tree->Branch("EventId",&m_nt_evtId,"EventId/l");// Event ID
  m_tree->Branch("EventTime",&m_nt_evtTime,"EventTime/I");// Event time
  m_tree->Branch("EventTime_ns",&m_nt_evtTime_ns,"EventTime_ns/I");// Event time in nanosecond
  m_tree->Branch("LumiBlock",&m_nt_lb,"LumiBlock/I"); // LB
  m_tree->Branch("BCID",&m_nt_bcid,"BCID/I"); // BCID
  m_tree->Branch("StreamTagName",&m_nt_streamTagName);// stream tag name
  m_tree->Branch("StreamTagType",&m_nt_streamTagType); // stream tag type 
  m_tree->Branch("IsBCIDFilled", &m_nt_isbcidFilled,"IsBCIDFilled/I"); // check if bunch is filled
  m_tree->Branch("IsBCIDInTrain",&m_nt_isbcidInTrain,"ISBCIDInTrain/I"); // check if bunch belong to a train
  m_tree->Branch("BunchesInFront",&m_nt_isBunchesInFront); // check front bunches
  m_tree->Branch("BunchType",&m_nt_bunchtype,"BunchType/I");// Empty = 0, FirstEmpty=1,&middleEmpty=2, Single=100,Front=200,&middle=201,Tail=202 
  m_tree->Branch("TimeAfterBunch",&m_nt_bunchtime,"TimeAfterBunch/F"); //time "distance" between the colliding bunch and the nearest one.
  m_tree->Branch("ATLASIsReady",&m_nt_atlasready,"AtlasIsReady/I"); //check if atlas is ready for physics 
  m_tree->Branch("StableBeams",&m_nt_stablebeams,"StableBeams/I");//check stablebeams
 
  // LAr event bit info
  m_tree->Branch("larflag_badFEBs",&m_nt_larflag_badFEBs,"larflag_badFEBs/O");
  m_tree->Branch("larflag_mediumSaturatedDQ",&m_nt_larflag_mediumSaturatedDQ,"larflag_mediumSaturatedDQ/O");
  m_tree->Branch("larflag_tightSaturatedDQ",&m_nt_larflag_tightSaturatedDQ,"larflag_tightSaturatedDQ/O");
  m_tree->Branch("larflag_noiseBurstVeto",&m_nt_larflag_noiseBurstVeto,"larflag_noiseBurstVeto/O");
  m_tree->Branch("larflag_dataCorrupted",&m_nt_larflag_dataCorrupted,"larflag_dataCorrupted/O");
  m_tree->Branch("larflag_dataCorruptedVeto",&m_nt_larflag_dataCorruptedVeto,"larflag_dataCorruptedVeto/O");
  m_tree->Branch("larflag_badFEBS_w",&m_nt_larflag_badFEBS_w,"larflag_badFEBS_w/O");
  m_tree->Branch("larflag_mnbLoose",&m_nt_larflag_mnbLoose,"larflag_mnbLoose/O");
  m_tree->Branch("larflag_mnbTight",&m_nt_larflag_mnbTight,"larflag_mnbTight/O");
  m_tree->Branch("larflag_mnbTight_psveto",&m_nt_larflag_mnbTight_psveto,"larflag_mnbTight_psveto/O");
  m_tree->Branch("larflag_badHVlines",&m_nt_larflag_badHVlines,"larflag_badHVlines/O");
 
  m_tree->Branch("badHVlinesPartitions",&m_nt_badHVPartitions,"badHVlinesPartitions/b");
  // Bad HVlines vector
  m_tree->Branch("badHVlines",&m_nt_badHVlines);
 
  // trigger flags
  m_tree->Branch("L1_J75",&m_nt_L1_J75,"L1_J75/O");
  m_tree->Branch("L1_J10_EMPTY",&m_nt_L1_J10_EMPTY,"L1_J10_EMPTY/O");
  m_tree->Branch("L1_J30_FIRSTEMPTY",&m_nt_L1_J30_FIRSTEMPTY,"L1_J30_FIRSTEMPTY/O");
  m_tree->Branch("L1_J30_EMPTY",&m_nt_L1_J30_EMPTY,"L1_J30_EMPTY/O");
  m_tree->Branch("L1_XE40",&m_nt_L1_XE40,"L1_XE40/O");
  m_tree->Branch("L1_XE50",&m_nt_L1_XE50,"L1_XE50/O");
  m_tree->Branch("L1_XE50_BGRP7",&m_nt_L1_XE50_BGRP7,"L1_XE50_BGRP7/O");
  m_tree->Branch("L1_XE70",&m_nt_L1_XE70,"L1_XE70/O");
  
  m_tree->Branch("EF_j165_u0uchad_LArNoiseBurst",&m_nt_EF_j165_u0uchad_LArNoiseBurst,"EF_j165_u0uchad_LArNoiseBurst/O");
  m_tree->Branch("EF_j30_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j30_u0uchad_empty_LArNoiseBurst,"EF_j30_u0uchad_empty_LArNoiseBurst/O");
  m_tree->Branch("EF_j55_u0uchad_firstempty_LArNoiseBurst",&m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst,"EF_j55_u0uchad_firstempty_LArNoiseBurst/O");
  m_tree->Branch("EF_j55_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j55_u0uchad_empty_LArNoiseBurst,"EF_j55_u0uchad_empty_LArNoiseBurst/O");
  m_tree->Branch("EF_xe45_LArNoiseBurst",&m_nt_EF_xe45_LArNoiseBurst,"EF_xe45_LArNoiseBurst/O");
  m_tree->Branch("EF_xe55_LArNoiseBurst",&m_nt_EF_xe55_LArNoiseBurst,"EF_xe55_LArNoiseBurst/O");
  m_tree->Branch("EF_xe60_LArNoiseBurst",&m_nt_EF_xe60_LArNoiseBurst,"EF_xe60_LArNoiseBurst/O");
  m_tree->Branch("EF_j55_u0uchad_firstempty_LArNoiseBurstT",&m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT,"EF_j55_u0uchad_firstempty_LArNoiseBurstT/O");
  m_tree->Branch("EF_j100_u0uchad_LArNoiseBurstT",&m_nt_EF_j100_u0uchad_LArNoiseBurstT,"EF_j100_u0uchad_LArNoiseBurstT/O");
  m_tree->Branch("EF_j165_u0uchad_LArNoiseBurstT",&m_nt_EF_j165_u0uchad_LArNoiseBurstT,"EF_j165_u0uchad_LArNoiseBurstT/O");
  m_tree->Branch("EF_j130_u0uchad_LArNoiseBurstT",&m_nt_EF_j130_u0uchad_LArNoiseBurstT,"EF_j130_u0uchad_LArNoiseBurstT/O");
  m_tree->Branch("EF_j35_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j35_u0uchad_empty_LArNoiseBurst,"EF_j35_u0uchad_empty_LArNoiseBurst/O");
  m_tree->Branch("EF_j35_u0uchad_firstempty_LArNoiseBurst",&m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst,"EF_j35_u0uchad_firstempty_LArNoiseBurst/O");
  m_tree->Branch("EF_j80_u0uchad_LArNoiseBurstT",&m_nt_EF_j80_u0uchad_LArNoiseBurstT,"EF_j80_u0uchad_LArNoiseBurstT/O");
  
  // 
  m_tree->Branch("LArCellSize", &m_nt_larcellsize,"LArCellSize/I"); // NEW number of online conected LAr cells
  m_tree->Branch("CaloCellSize",&m_nt_cellsize,"CaloCellSize/I");// NEW number of total cells.
  // LAr time difference as computed by LArCollisionTime info
  m_tree->Branch("LArTime_Diff",&m_nt_ECTimeDiff,"LArTime_Diff/F"); // time diff between 2 endcaps
  m_tree->Branch("LArTime_Avg",&m_nt_ECTimeAvg,"LArTime_Avg/F"); // time average of 2 endcaps
  m_tree->Branch("LArTime_nCellA",&m_nt_nCellA,"LArTime_nCellA/I"); // nb of cells used to compute endcap A time
  m_tree->Branch("LArTime_nCellC",&m_nt_nCellC,"LArTime_nCellC/I"); // nb of cells used to compute endcap C time
 
  // Event properties related to yield of channels in 3 sigma tails 
  //m_tree->Branch("PerCentNoisyCell",&m_nt_noisycellpercent,"PerCentNoisyCell/F"); // Yield of channels in 3sigma tails in whole LAr
  m_tree->Branch("PerCentNoisyCellPartition",&m_nt_noisycellpart); // Yield in each partition:0:embc 1:emba 2:emecc 3:emeca 4:fcalc 5:fcala 6:hecc 7:heca
 
 
  // Properties of cells with fabs(energy/noise)>3
  m_tree->Branch("NoisyCellPartitionLayerIndex",&m_nt_cellpartlayerindex); 
  m_tree->Branch("NoisyCellIdentifier",&m_nt_cellIdentifier); // Identifier of the noisy cell
  m_tree->Branch("NoisyCellOnlineIdentifier",&m_nt_onlIdentifier); // Identifier of the noisy cell
  m_tree->Branch("NoisyCellPartition",&m_nt_partition); // Partition in 1 integer: 0:embc 1:emba 2:emecc 3:emeca 4:fcalc 5:fcala 6:hecc 7:heca
  m_tree->Branch("NoisyCellBarrelEc",&m_nt_barrelec_noisy);            // BC 
  m_tree->Branch("NoisyCellPosNeg",&m_nt_posneg_noisy);                // side 
  m_tree->Branch("NoisyCellFT",&m_nt_ft_noisy);                        // FT 
  m_tree->Branch("NoisyCellSlot",&m_nt_slot_noisy);                    // Slot
  m_tree->Branch("NoisyCellChannel",&m_nt_channel_noisy);              // Channel
  m_tree->Branch("NoisyCellADCvalues", &m_nt_samples);                 // ADC values
  m_tree->Branch("NoisyCellGain",&m_nt_gain);                          // Gain
  m_tree->Branch("NoisyCellPhi",&m_nt_phicell);                        // Phi
  m_tree->Branch("NoisyCellEta",&m_nt_etacell);                        // Eta
  m_tree->Branch("NoisyCellLayer", &m_nt_layer);                       // layer
  m_tree->Branch("NoisyCellHVphi", &m_nt_noisycellHVphi);              // Phi of HV
  m_tree->Branch("NoisyCellHVeta", &m_nt_noisycellHVeta);              // Eta of HV
  m_tree->Branch("NoisyCellEnergy",&m_nt_energycell);                  // Energy
  m_tree->Branch("NoisyCellSignificance",&m_nt_signifcell);            // Significance (energy/noise)
  m_tree->Branch("NoisyCellQFactor",&m_nt_qfactorcell);                // Q factor
  m_tree->Branch("NoisyCellIsBad",&m_nt_isbadcell);                    // Bad channel status
  // Event properties related to q factor
  m_tree->Branch("nbLowQFactor", &m_lowqfactor,"m_lowqfactor/i"); // Nb of cells per event with q factor<1000
  m_tree->Branch("nbMedQFactor", &m_medqfactor,"m_medqfactor/i"); // Nb of cells per event with 1000<q factor<10000
  m_tree->Branch("nbHighQFactor", &m_hiqfactor,"m_hiqfactor/i");  // Nb of cells per event with q 10000<factor<65535
  m_tree->Branch("nbSatQFactor",&m_nb_sat,"nbSat/i"); // Nb of cells per event with saturated q factor (65535) 
  // Properties of cells with q factor saturated
  m_tree->Branch("SatCellPartition",&m_nt_partition_sat);
  m_tree->Branch("SatCellBarrelEc",&m_nt_barrelec_sat);
  m_tree->Branch("SatCellPosNeg",&m_nt_posneg_sat);
  m_tree->Branch("SatCellFT",&m_nt_ft_sat);
  m_tree->Branch("SatCellSlot",&m_nt_slot_sat);
  m_tree->Branch("SatCellChannel",&m_nt_channel_sat);
  m_tree->Branch("SatCellEnergy",&m_nt_energy_sat);
  m_tree->Branch("SatCellPhi", &m_nt_phicell_sat);
  m_tree->Branch("SatCellEta",&m_nt_etacell_sat);
  m_tree->Branch("SatCellLayer",&m_nt_layer_sat);
  m_tree->Branch("SatCellIsBad", &m_nt_isbadcell_sat);
  m_tree->Branch("SatCellOnlineIdentifier",&m_nt_cellIdentifier_sat);
 
 
  ATH_MSG_DEBUG ( "End of Initializing LArNoiseBursts" );
 
  return StatusCode::SUCCESS;
}

◆ 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.

◆ msg()

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

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

◆ msgLvl()

bool AthCommonMsg< 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< 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.

◆ 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.

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

◆ 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.

                                                          {
    handlesArray.renounce();
  }

◆ 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, AthHistogramAlgorithm, and PyAthena::Alg.

Definition at line 66 of file AthAlgorithm.cxx.

                                       {
  StatusCode sc=AthCommonDataStore<AthCommonMsg<Algorithm>>::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< 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.

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< 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_bcDataKey

SG::ReadCondHandleKey<BunchCrossingCondData> LArNoiseBursts::m_bcDataKey {this, "BunchCrossingCondDataKey", "BunchCrossingData" ,"SG Key of BunchCrossing CDO"}

private

Definition at line 97 of file LArNoiseBursts.h.

98{this, "BunchCrossingCondDataKey", "BunchCrossingData" ,"SG Key of BunchCrossing CDO"};

◆ m_BCKey

SG::ReadCondHandleKey<LArBadChannelCont> LArNoiseBursts::m_BCKey { this, "BadChanKey","LArBadChannel","SG Key of LArBadChannelCont object"}

private

Definition at line 94 of file LArNoiseBursts.h.

94{ this, "BadChanKey","LArBadChannel","SG Key of LArBadChannelCont object"};

◆ m_cablingKey

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

private

Definition at line 93 of file LArNoiseBursts.h.

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

◆ m_caloMgrKey

SG::ReadCondHandleKey<CaloDetDescrManager> LArNoiseBursts::m_caloMgrKey

private

Initial value:

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

Definition at line 110 of file LArNoiseBursts.h.

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

◆ m_CosmicCaloStream

bool LArNoiseBursts::m_CosmicCaloStream

private

Definition at line 121 of file LArNoiseBursts.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_elecContainerName

std::string LArNoiseBursts::m_elecContainerName

private

Definition at line 117 of file LArNoiseBursts.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_frontbunches

unsigned int LArNoiseBursts::m_frontbunches

private

Definition at line 122 of file LArNoiseBursts.h.

◆ m_hiqfactor

int LArNoiseBursts::m_hiqfactor

private

Definition at line 129 of file LArNoiseBursts.h.

◆ m_keepOnlyCellID

bool LArNoiseBursts::m_keepOnlyCellID

private

Definition at line 123 of file LArNoiseBursts.h.

◆ m_LArElectrodeIDHelper

const LArElectrodeID* LArNoiseBursts::m_LArElectrodeIDHelper

private

Definition at line 106 of file LArNoiseBursts.h.

◆ m_LArEM_IDHelper

const LArEM_ID* LArNoiseBursts::m_LArEM_IDHelper

private

Definition at line 107 of file LArNoiseBursts.h.

◆ m_LArFCAL_IDHelper

const LArFCAL_ID* LArNoiseBursts::m_LArFCAL_IDHelper

private

Definition at line 108 of file LArNoiseBursts.h.

◆ m_LArHEC_IDHelper

const LArHEC_ID* LArNoiseBursts::m_LArHEC_IDHelper

private

Definition at line 109 of file LArNoiseBursts.h.

◆ m_LArHVLineIDHelper

const LArHVLineID* LArNoiseBursts::m_LArHVLineIDHelper

private

Definition at line 105 of file LArNoiseBursts.h.

◆ m_LArOnlineIDHelper

const LArOnlineID* LArNoiseBursts::m_LArOnlineIDHelper

private

Definition at line 104 of file LArNoiseBursts.h.

◆ m_lowqfactor

int LArNoiseBursts::m_lowqfactor

private

Definition at line 127 of file LArNoiseBursts.h.

◆ m_medqfactor

int LArNoiseBursts::m_medqfactor

private

Definition at line 128 of file LArNoiseBursts.h.

◆ m_nb_sat

int LArNoiseBursts::m_nb_sat

private

Definition at line 126 of file LArNoiseBursts.h.

◆ m_noisycell

long LArNoiseBursts::m_noisycell

private

Definition at line 130 of file LArNoiseBursts.h.

◆ m_NoisyROKey

SG::ReadHandleKey<LArNoisyROSummary> LArNoiseBursts::m_NoisyROKey { this, "LArNoisyROSummaryKey","LArNoisyROSummary","SG Key of LArNoisyROSummar object"}

private

Definition at line 102 of file LArNoiseBursts.h.

102{ this, "LArNoisyROSummaryKey","LArNoisyROSummary","SG Key of LArNoisyROSummar object"};

◆ m_nt_atlasready

unsigned int LArNoiseBursts::m_nt_atlasready

private

Definition at line 145 of file LArNoiseBursts.h.

◆ m_nt_badHVlines

std::vector<unsigned int> LArNoiseBursts::m_nt_badHVlines

private

Definition at line 165 of file LArNoiseBursts.h.

◆ m_nt_badHVPartitions

uint8_t LArNoiseBursts::m_nt_badHVPartitions

private

Definition at line 163 of file LArNoiseBursts.h.

◆ m_nt_barrelec_noisy

std::vector<short> LArNoiseBursts::m_nt_barrelec_noisy

private

Definition at line 206 of file LArNoiseBursts.h.

◆ m_nt_barrelec_sat

std::vector<int> LArNoiseBursts::m_nt_barrelec_sat

private

Definition at line 226 of file LArNoiseBursts.h.

◆ m_nt_bcid

int LArNoiseBursts::m_nt_bcid

private

Definition at line 138 of file LArNoiseBursts.h.

◆ m_nt_bunchtime

float LArNoiseBursts::m_nt_bunchtime

private

Definition at line 144 of file LArNoiseBursts.h.

◆ m_nt_bunchtype

int LArNoiseBursts::m_nt_bunchtype

private

Definition at line 143 of file LArNoiseBursts.h.

◆ m_nt_cellIdentifier

std::vector< unsigned int > LArNoiseBursts::m_nt_cellIdentifier

private

Definition at line 212 of file LArNoiseBursts.h.

◆ m_nt_cellIdentifier_sat

std::vector<unsigned int> LArNoiseBursts::m_nt_cellIdentifier_sat

private

Definition at line 236 of file LArNoiseBursts.h.

◆ m_nt_cellpartlayerindex

std::vector<short> LArNoiseBursts::m_nt_cellpartlayerindex

private

Definition at line 211 of file LArNoiseBursts.h.

◆ m_nt_cellsize

int LArNoiseBursts::m_nt_cellsize

private

Definition at line 132 of file LArNoiseBursts.h.

◆ m_nt_channel_noisy

std::vector<short> LArNoiseBursts::m_nt_channel_noisy

private

Definition at line 210 of file LArNoiseBursts.h.

◆ m_nt_channel_sat

std::vector<short> LArNoiseBursts::m_nt_channel_sat

private

Definition at line 230 of file LArNoiseBursts.h.

◆ m_nt_ECTimeAvg

float LArNoiseBursts::m_nt_ECTimeAvg

private

Definition at line 194 of file LArNoiseBursts.h.

◆ m_nt_ECTimeDiff

float LArNoiseBursts::m_nt_ECTimeDiff

private

Definition at line 193 of file LArNoiseBursts.h.

◆ m_nt_EF_j100_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j100_u0uchad_LArNoiseBurstT

private

Definition at line 185 of file LArNoiseBursts.h.

◆ m_nt_EF_j130_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j130_u0uchad_LArNoiseBurstT

private

Definition at line 187 of file LArNoiseBursts.h.

◆ m_nt_EF_j165_u0uchad_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurst

private

Definition at line 177 of file LArNoiseBursts.h.

◆ m_nt_EF_j165_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurstT

private

Definition at line 186 of file LArNoiseBursts.h.

◆ m_nt_EF_j30_u0uchad_empty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j30_u0uchad_empty_LArNoiseBurst

private

Definition at line 178 of file LArNoiseBursts.h.

◆ m_nt_EF_j35_u0uchad_empty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j35_u0uchad_empty_LArNoiseBurst

private

Definition at line 188 of file LArNoiseBursts.h.

◆ m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst

private

Definition at line 189 of file LArNoiseBursts.h.

◆ m_nt_EF_j55_u0uchad_empty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j55_u0uchad_empty_LArNoiseBurst

private

Definition at line 180 of file LArNoiseBursts.h.

◆ m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst

private

Definition at line 179 of file LArNoiseBursts.h.

◆ m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT

private

Definition at line 184 of file LArNoiseBursts.h.

◆ m_nt_EF_j80_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j80_u0uchad_LArNoiseBurstT

private

Definition at line 190 of file LArNoiseBursts.h.

◆ m_nt_EF_xe45_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_xe45_LArNoiseBurst

private

Definition at line 181 of file LArNoiseBursts.h.

◆ m_nt_EF_xe55_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_xe55_LArNoiseBurst

private

Definition at line 182 of file LArNoiseBursts.h.

◆ m_nt_EF_xe60_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_xe60_LArNoiseBurst

private

Definition at line 183 of file LArNoiseBursts.h.

◆ m_nt_energy_sat

std::vector<float> LArNoiseBursts::m_nt_energy_sat

private

Definition at line 232 of file LArNoiseBursts.h.

◆ m_nt_energycell

std::vector<float> LArNoiseBursts::m_nt_energycell

private

Definition at line 200 of file LArNoiseBursts.h.

◆ m_nt_etacell

std::vector<float> LArNoiseBursts::m_nt_etacell

private

Definition at line 203 of file LArNoiseBursts.h.

◆ m_nt_etacell_sat

std::vector<float> LArNoiseBursts::m_nt_etacell_sat

private

Definition at line 234 of file LArNoiseBursts.h.

◆ m_nt_evtId

unsigned long LArNoiseBursts::m_nt_evtId

private

Definition at line 134 of file LArNoiseBursts.h.

◆ m_nt_evtTime

int LArNoiseBursts::m_nt_evtTime

private

Definition at line 135 of file LArNoiseBursts.h.

◆ m_nt_evtTime_ns

int LArNoiseBursts::m_nt_evtTime_ns

private

Definition at line 136 of file LArNoiseBursts.h.

◆ m_nt_ft_noisy

std::vector<short> LArNoiseBursts::m_nt_ft_noisy

private

Definition at line 208 of file LArNoiseBursts.h.

◆ m_nt_ft_sat

std::vector<short> LArNoiseBursts::m_nt_ft_sat

private

Definition at line 228 of file LArNoiseBursts.h.

◆ m_nt_gain

std::vector<int> LArNoiseBursts::m_nt_gain

private

Definition at line 218 of file LArNoiseBursts.h.

◆ m_nt_isbadcell

std::vector<int> LArNoiseBursts::m_nt_isbadcell

private

Definition at line 219 of file LArNoiseBursts.h.

◆ m_nt_isbadcell_sat

std::vector<int> LArNoiseBursts::m_nt_isbadcell_sat

private

Definition at line 225 of file LArNoiseBursts.h.

◆ m_nt_isbcidFilled

int LArNoiseBursts::m_nt_isbcidFilled

private

Definition at line 140 of file LArNoiseBursts.h.

◆ m_nt_isbcidInTrain

int LArNoiseBursts::m_nt_isbcidInTrain

private

Definition at line 141 of file LArNoiseBursts.h.

◆ m_nt_isBunchesInFront

std::vector<int> LArNoiseBursts::m_nt_isBunchesInFront

private

Definition at line 142 of file LArNoiseBursts.h.

◆ m_nt_L1_J10_EMPTY

bool LArNoiseBursts::m_nt_L1_J10_EMPTY

private

Definition at line 169 of file LArNoiseBursts.h.

◆ m_nt_L1_J30_EMPTY

bool LArNoiseBursts::m_nt_L1_J30_EMPTY

private

Definition at line 171 of file LArNoiseBursts.h.

◆ m_nt_L1_J30_FIRSTEMPTY

bool LArNoiseBursts::m_nt_L1_J30_FIRSTEMPTY

private

Definition at line 170 of file LArNoiseBursts.h.

◆ m_nt_L1_J75

bool LArNoiseBursts::m_nt_L1_J75

private

Definition at line 168 of file LArNoiseBursts.h.

◆ m_nt_L1_XE40

bool LArNoiseBursts::m_nt_L1_XE40

private

Definition at line 172 of file LArNoiseBursts.h.

◆ m_nt_L1_XE50

bool LArNoiseBursts::m_nt_L1_XE50

private

Definition at line 173 of file LArNoiseBursts.h.

◆ m_nt_L1_XE50_BGRP7

bool LArNoiseBursts::m_nt_L1_XE50_BGRP7

private

Definition at line 174 of file LArNoiseBursts.h.

◆ m_nt_L1_XE70

bool LArNoiseBursts::m_nt_L1_XE70

private

Definition at line 175 of file LArNoiseBursts.h.

◆ m_nt_larcellsize

int LArNoiseBursts::m_nt_larcellsize

private

Definition at line 131 of file LArNoiseBursts.h.

◆ m_nt_larflag_badFEBs

bool LArNoiseBursts::m_nt_larflag_badFEBs

private

Definition at line 151 of file LArNoiseBursts.h.

◆ m_nt_larflag_badFEBS_w

bool LArNoiseBursts::m_nt_larflag_badFEBS_w

private

Definition at line 157 of file LArNoiseBursts.h.

◆ m_nt_larflag_badHVlines

bool LArNoiseBursts::m_nt_larflag_badHVlines

private

Definition at line 161 of file LArNoiseBursts.h.

◆ m_nt_larflag_dataCorrupted

bool LArNoiseBursts::m_nt_larflag_dataCorrupted

private

Definition at line 155 of file LArNoiseBursts.h.

◆ m_nt_larflag_dataCorruptedVeto

bool LArNoiseBursts::m_nt_larflag_dataCorruptedVeto

private

Definition at line 156 of file LArNoiseBursts.h.

◆ m_nt_larflag_mediumSaturatedDQ

bool LArNoiseBursts::m_nt_larflag_mediumSaturatedDQ

private

Definition at line 152 of file LArNoiseBursts.h.

◆ m_nt_larflag_mnbLoose

bool LArNoiseBursts::m_nt_larflag_mnbLoose

private

Definition at line 158 of file LArNoiseBursts.h.

◆ m_nt_larflag_mnbTight

bool LArNoiseBursts::m_nt_larflag_mnbTight

private

Definition at line 159 of file LArNoiseBursts.h.

◆ m_nt_larflag_mnbTight_psveto

bool LArNoiseBursts::m_nt_larflag_mnbTight_psveto

private

Definition at line 160 of file LArNoiseBursts.h.

◆ m_nt_larflag_noiseBurstVeto

bool LArNoiseBursts::m_nt_larflag_noiseBurstVeto

private

Definition at line 154 of file LArNoiseBursts.h.

◆ m_nt_larflag_tightSaturatedDQ

bool LArNoiseBursts::m_nt_larflag_tightSaturatedDQ

private

Definition at line 153 of file LArNoiseBursts.h.

◆ m_nt_layer

std::vector<int> LArNoiseBursts::m_nt_layer

private

Definition at line 222 of file LArNoiseBursts.h.

◆ m_nt_layer_sat

std::vector<int> LArNoiseBursts::m_nt_layer_sat

private

Definition at line 235 of file LArNoiseBursts.h.

◆ m_nt_lb

int LArNoiseBursts::m_nt_lb

private

Definition at line 137 of file LArNoiseBursts.h.

◆ m_nt_nCellA

int LArNoiseBursts::m_nt_nCellA

private

Definition at line 195 of file LArNoiseBursts.h.

◆ m_nt_nCellC

int LArNoiseBursts::m_nt_nCellC

private

Definition at line 196 of file LArNoiseBursts.h.

◆ m_nt_noisycellHVeta

std::vector<int> LArNoiseBursts::m_nt_noisycellHVeta

private

Definition at line 216 of file LArNoiseBursts.h.

◆ m_nt_noisycellHVphi

std::vector<int> LArNoiseBursts::m_nt_noisycellHVphi

private

Definition at line 215 of file LArNoiseBursts.h.

◆ m_nt_noisycellpart

std::vector<float> LArNoiseBursts::m_nt_noisycellpart

private

Definition at line 214 of file LArNoiseBursts.h.

◆ m_nt_onlIdentifier

std::vector< unsigned int > LArNoiseBursts::m_nt_onlIdentifier

private

Definition at line 213 of file LArNoiseBursts.h.

◆ m_nt_partition

std::vector<int> LArNoiseBursts::m_nt_partition

private

Definition at line 221 of file LArNoiseBursts.h.

◆ m_nt_partition_sat

std::vector<int> LArNoiseBursts::m_nt_partition_sat

private

Definition at line 231 of file LArNoiseBursts.h.

◆ m_nt_phicell

std::vector<float> LArNoiseBursts::m_nt_phicell

private

Definition at line 202 of file LArNoiseBursts.h.

◆ m_nt_phicell_sat

std::vector<float> LArNoiseBursts::m_nt_phicell_sat

private

Definition at line 233 of file LArNoiseBursts.h.

◆ m_nt_posneg_noisy

std::vector<short> LArNoiseBursts::m_nt_posneg_noisy

private

Definition at line 207 of file LArNoiseBursts.h.

◆ m_nt_posneg_sat

std::vector<int> LArNoiseBursts::m_nt_posneg_sat

private

Definition at line 227 of file LArNoiseBursts.h.

◆ m_nt_qfactorcell

std::vector<float> LArNoiseBursts::m_nt_qfactorcell

private

Definition at line 201 of file LArNoiseBursts.h.

◆ m_nt_run

int LArNoiseBursts::m_nt_run

private

Definition at line 133 of file LArNoiseBursts.h.

◆ m_nt_samples

std::vector<std::vector<short> > LArNoiseBursts::m_nt_samples

private

Definition at line 217 of file LArNoiseBursts.h.

◆ m_nt_signifcell

std::vector<float> LArNoiseBursts::m_nt_signifcell

private

Definition at line 204 of file LArNoiseBursts.h.

◆ m_nt_slot_noisy

std::vector<short> LArNoiseBursts::m_nt_slot_noisy

private

Definition at line 209 of file LArNoiseBursts.h.

◆ m_nt_slot_sat

std::vector<short> LArNoiseBursts::m_nt_slot_sat

private

Definition at line 229 of file LArNoiseBursts.h.

◆ m_nt_stablebeams

unsigned int LArNoiseBursts::m_nt_stablebeams

private

Definition at line 146 of file LArNoiseBursts.h.

◆ m_nt_streamTagName

std::vector<std::string> LArNoiseBursts::m_nt_streamTagName

private

Definition at line 147 of file LArNoiseBursts.h.

◆ m_nt_streamTagType

std::vector<std::string> LArNoiseBursts::m_nt_streamTagType

private

Definition at line 148 of file LArNoiseBursts.h.

◆ m_sigmacut

double LArNoiseBursts::m_sigmacut

private

Definition at line 120 of file LArNoiseBursts.h.

◆ m_thistSvc

ServiceHandle<ITHistSvc> LArNoiseBursts::m_thistSvc {this,"THistSvc","THistSvc"}

private

Definition at line 89 of file LArNoiseBursts.h.

89{this,"THistSvc","THistSvc"};

◆ m_totalNoiseKey

SG::ReadCondHandleKey<CaloNoise> LArNoiseBursts::m_totalNoiseKey { this, "TotalNoiseKey", "totalNoise", "SG key for total noise" }

private

Definition at line 95 of file LArNoiseBursts.h.

96{ this, "TotalNoiseKey", "totalNoise", "SG key for total noise" };

◆ m_tree

TTree* LArNoiseBursts::m_tree

private

Definition at line 91 of file LArNoiseBursts.h.

◆ m_trigDec

PublicToolHandle< Trig::TrigDecisionTool > LArNoiseBursts::m_trigDec {this, "TrigDecisionTool", "", "Handle to the TrigDecisionTool"}

private

Definition at line 100 of file LArNoiseBursts.h.

100{this, "TrigDecisionTool", "", "Handle to the TrigDecisionTool"};

◆ 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:

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ StoreGateSvc_t

Constructor & Destructor Documentation

◆ LArNoiseBursts()

◆ ~LArNoiseBursts()

Member Function Documentation

◆ clear()

◆ declareGaudiProperty()

◆ declareProperty()

◆ detStore()

◆ doEventProperties()

◆ doLArNoiseBursts()

◆ doTrigger()

◆ evtStore()

◆ execute()

◆ extraDeps_update_handler()

◆ extraOutputDeps()

◆ fillCell()

◆ finalize()

◆ GetPartitionLayerIndex()

◆ initialize()

◆ inputHandles()

◆ msg()

◆ msgLvl()

◆ outputHandles()

◆ renounce()

◆ renounceArray()

◆ sysInitialize()

◆ sysStart()

◆ updateVHKA()

Member Data Documentation

◆ m_bcDataKey

◆ m_BCKey

◆ m_cablingKey

◆ m_caloMgrKey

◆ m_CosmicCaloStream

◆ m_detStore

◆ m_elecContainerName

◆ m_evtStore

◆ m_extendedExtraObjects

◆ m_frontbunches

◆ m_hiqfactor

◆ m_keepOnlyCellID

◆ m_LArElectrodeIDHelper

◆ m_LArEM_IDHelper

◆ m_LArFCAL_IDHelper

◆ m_LArHEC_IDHelper

◆ m_LArHVLineIDHelper

◆ m_LArOnlineIDHelper

◆ m_lowqfactor

◆ m_medqfactor

◆ m_nb_sat

◆ m_noisycell

◆ m_NoisyROKey

◆ m_nt_atlasready

◆ m_nt_badHVlines

◆ m_nt_badHVPartitions

◆ m_nt_barrelec_noisy

◆ m_nt_barrelec_sat

◆ m_nt_bcid

◆ m_nt_bunchtime

◆ m_nt_bunchtype

◆ m_nt_cellIdentifier

◆ m_nt_cellIdentifier_sat

◆ m_nt_cellpartlayerindex

◆ m_nt_cellsize

◆ m_nt_channel_noisy

◆ m_nt_channel_sat

◆ m_nt_ECTimeAvg

◆ m_nt_ECTimeDiff

◆ m_nt_EF_j100_u0uchad_LArNoiseBurstT

◆ m_nt_EF_j130_u0uchad_LArNoiseBurstT

◆ m_nt_EF_j165_u0uchad_LArNoiseBurst

◆ m_nt_EF_j165_u0uchad_LArNoiseBurstT