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

#include <LArNoiseBursts.h>

Inheritance diagram for LArNoiseBursts:
Collaboration diagram for LArNoiseBursts:

Public Member Functions

 LArNoiseBursts (const std::string &name, ISvcLocator *pSvcLocator)
 Constructor. More...
 
virtual ~LArNoiseBursts ()
 Destructor - check up memory allocation delete any memory allocation on the heap. More...
 
virtual StatusCode initialize () override
 Initialize initialize StoreGate get a handle on the analysis tools book histograms. More...
 
virtual StatusCode finalize () override
 Finalize - delete any memory allocation from the heap. More...
 
virtual StatusCode execute () override
 Execute - on event by event. More...
 
virtual StatusCode clear ()
 Clear - clear CBNT members. More...
 
virtual StatusCode sysInitialize () override
 Override sysInitialize. More...
 
virtual const DataObjIDColl & extraOutputDeps () const override
 Return the list of extra output dependencies. More...
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 

Protected Member Functions

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

Private Types

typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

StatusCode doTrigger ()
 methods called by execute() More...
 
StatusCode doEventProperties ()
 
StatusCode doLArNoiseBursts ()
 
StatusCode doPhysicsObjects ()
 
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 > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

ITHistSvc * m_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"}
 
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
 
short m_nt_larnoisyro
 
short m_nt_larnoisyro_opt
 
short m_nt_larnoisyro_satTwo
 
short m_nt_larmnbnoisy
 
short m_nt_larmnbnoisy_sat
 
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_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) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
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 86 of file LArNoiseBursts.cxx.

88  : AthAlgorithm(name, pSvcLocator),
89  m_thistSvc(nullptr),
90  m_tree(nullptr),
91  m_LArOnlineIDHelper(nullptr),
92  m_LArHVLineIDHelper(nullptr),
93  m_LArElectrodeIDHelper(nullptr),
94  m_LArEM_IDHelper(nullptr),
95  m_LArFCAL_IDHelper(nullptr),
96  m_LArHEC_IDHelper(nullptr),
97  m_CosmicCaloStream(false),
98  m_nb_sat(0),
99  m_lowqfactor(0),
100  m_medqfactor(0),
101  m_hiqfactor(0),
102  m_noisycell(0),
103  m_nt_larcellsize(0),
104  m_nt_cellsize(0),
105  m_nt_run(0),
106  m_nt_evtId(0),
107  m_nt_evtTime(0),
108  m_nt_evtTime_ns(0),
109  m_nt_lb(0),
110  m_nt_bcid(0),
111  //m_nt_ntracks(0),
112  m_nt_isbcidFilled(0),
113  m_nt_isbcidInTrain(0),
114  m_nt_isBunchesInFront(0),
115  m_nt_bunchtype(0),
116  m_nt_bunchtime(0),
117  m_nt_atlasready(0),
118  m_nt_stablebeams(0),
119  m_nt_streamTagName(0),
120  m_nt_streamTagType(0),
121  m_nt_larnoisyro(0),
122  m_nt_larnoisyro_opt(0),
123  m_nt_larnoisyro_satTwo(0),
124  m_nt_larmnbnoisy(0),
125  m_nt_larmnbnoisy_sat(0),
126 // m_nt_veto_mbts(0),
127 // //m_nt_veto_indet(0),
128 // m_nt_veto_bcm(0),
129 // m_nt_veto_lucid(0),
130 // m_nt_veto_pixel(0),
131 // m_nt_veto_sct(0),
132 // m_nt_veto_mbtstdHalo(0),
133 // m_nt_veto_mbtstdCol(0),
134 // m_nt_veto_lartdHalo(0),
135 // m_nt_veto_lartdCol(0),
136 // m_nt_veto_csctdHalo(0),
137 // m_nt_veto_csctdCol(0),
138 // m_nt_veto_bcmtHalo(0),
139 // m_nt_veto_bcmtCol(0),
140 // m_nt_veto_muontCol(0),
141 // m_nt_veto_muontCosmic(0),
142  m_nt_larflag_badFEBs(false),
143  m_nt_larflag_mediumSaturatedDQ(false),
144  m_nt_larflag_tightSaturatedDQ(false),
145  m_nt_larflag_noiseBurstVeto(false),
146  m_nt_larflag_dataCorrupted(false),
147  m_nt_larflag_dataCorruptedVeto(false),
148  m_nt_L1_J75(false),
149  m_nt_L1_J10_EMPTY(false),
150  m_nt_L1_J30_FIRSTEMPTY(false),
151  m_nt_L1_J30_EMPTY(false),
152  m_nt_L1_XE40(false),
153  m_nt_L1_XE50(false),
154  m_nt_L1_XE50_BGRP7(false),
155  m_nt_L1_XE70(false),
156  m_nt_EF_j165_u0uchad_LArNoiseBurst(false),
157  m_nt_EF_j30_u0uchad_empty_LArNoiseBurst(false),
158  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst(false),
159  m_nt_EF_j55_u0uchad_empty_LArNoiseBurst(false),
160  m_nt_EF_xe45_LArNoiseBurst(false),
161  m_nt_EF_xe55_LArNoiseBurst(false),
162  m_nt_EF_xe60_LArNoiseBurst(false),
163  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT(false),
164  m_nt_EF_j100_u0uchad_LArNoiseBurstT(false),
165  m_nt_EF_j165_u0uchad_LArNoiseBurstT(false),
166  m_nt_EF_j130_u0uchad_LArNoiseBurstT(false),
167  m_nt_EF_j35_u0uchad_empty_LArNoiseBurst(false),
168  m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst(false),
169  m_nt_EF_j80_u0uchad_LArNoiseBurstT(false),
170  m_nt_ECTimeDiff(0),
171  m_nt_ECTimeAvg(0),
172  m_nt_nCellA(0),
173  m_nt_nCellC(0),
174  m_nt_energycell(0),
175  m_nt_qfactorcell(0),
176  m_nt_phicell(0),
177  m_nt_etacell(0),
178  m_nt_signifcell(0),
179  //m_nt_noisycellpercent(0),
180  m_nt_barrelec_noisy(0),
181  m_nt_posneg_noisy(0),
182  m_nt_ft_noisy(0),
183  m_nt_slot_noisy(0),
184  m_nt_channel_noisy(0),
185  m_nt_cellpartlayerindex(0),
186  m_nt_cellIdentifier(0),
187  m_nt_onlIdentifier(0),
188  m_nt_noisycellpart(0),
189  m_nt_noisycellHVphi(0),
190  m_nt_noisycellHVeta(0),
191  m_nt_samples(0),
192  m_nt_gain(0),
193  m_nt_isbadcell(0),
194  m_nt_partition(0),
195  m_nt_layer(0),
196  m_nt_isbadcell_sat(0),
197  m_nt_barrelec_sat(0),
198  m_nt_posneg_sat(0),
199  m_nt_ft_sat(0),
200  m_nt_slot_sat(0),
201  m_nt_channel_sat(0),
202  m_nt_partition_sat(0),
203  m_nt_energy_sat(0),
204  m_nt_phicell_sat(0),
205  m_nt_etacell_sat(0),
206  m_nt_layer_sat(0),
207  m_nt_cellIdentifier_sat(0)
208  {
209 
210  //event cuts
211  declareProperty("SigmaCut", m_sigmacut = 3.0);
212  declareProperty("NumberOfBunchesInFront",m_frontbunches = 36);
213 
214  // Keep cell properties
215  declareProperty("KeepOnlyCellID", m_keepOnlyCellID = false);
216  }

◆ ~LArNoiseBursts()

LArNoiseBursts::~LArNoiseBursts ( )
virtual

Destructor - check up memory allocation delete any memory allocation on the heap.

Definition at line 222 of file LArNoiseBursts.cxx.

222 {}

Member Function Documentation

◆ clear()

StatusCode LArNoiseBursts::clear ( )
virtual

Clear - clear CBNT members.

For Athena-Aware NTuple

HV branches

Definition at line 452 of file LArNoiseBursts.cxx.

452  {
454 
455  ATH_MSG_DEBUG ( "start clearing variables " );
456 
457  m_nb_sat = 0;
458  m_noisycell = 0;
459  m_lowqfactor = 0;
460  m_medqfactor = 0;
461  m_hiqfactor = 0;
462 
463  m_nt_run = 0;
464  m_nt_evtId = 0;
465  m_nt_evtTime = 0;
466  m_nt_evtTime_ns = 0;
467  m_nt_lb = 0;
468  m_nt_bcid = -1;
469 
470  m_nt_streamTagName.clear();
471  m_nt_streamTagType.clear();
472  m_nt_isbcidFilled = -1;
473  m_nt_isbcidInTrain = -1;
474  m_nt_isBunchesInFront.clear();
475  m_nt_bunchtype = -1;
476  m_nt_bunchtime = -1.0;
477  m_nt_atlasready = -1;
478  m_nt_stablebeams = -1;
479  m_nt_larnoisyro = -1;
480  m_nt_larnoisyro_opt = -1;
481  m_nt_larnoisyro_satTwo= -1;
482  m_nt_larmnbnoisy = -1;
483  m_nt_larmnbnoisy_sat = -1;
484 
485  ATH_MSG_DEBUG ( "clearing event info veto variables " );
486 
487  //clearing event info veto variables
488 // m_nt_veto_mbts = -1;
489 // m_nt_veto_pixel = -1;
490 // m_nt_veto_sct = -1;
491 // m_nt_veto_bcm = -1;
492 // m_nt_veto_lucid = -1;
493 // m_nt_veto_mbtstdHalo = -1;
494 // m_nt_veto_mbtstdCol = -1;
495 // m_nt_veto_lartdHalo = -1;
496 // m_nt_veto_lartdCol = -1;
497 // m_nt_veto_csctdHalo = -1;
498 // m_nt_veto_csctdCol = -1;
499 // m_nt_veto_bcmtHalo = -1;
500 // m_nt_veto_bcmtCol = -1;
501 // m_nt_veto_muontCol = -1;
502 // m_nt_veto_muontCosmic = -1;
503 //
504 // mLog << MSG::DEBUG << "clearing LAr event flags " << endmsg;
505 
506  ATH_MSG_DEBUG ( "clearing LAr event flags " );
507 
508  // lar bit event info
509  m_nt_larflag_badFEBs = false;
510  m_nt_larflag_mediumSaturatedDQ = false;
511  m_nt_larflag_tightSaturatedDQ = false;
512  m_nt_larflag_noiseBurstVeto = false;
513  m_nt_larflag_dataCorrupted = false;
514  m_nt_larflag_dataCorruptedVeto = false;
515 
516  ATH_MSG_DEBUG ( "clearing Pixel variables " );
517 
518  // Trigger flags
519  m_nt_L1_J75 = true; // turned on for tests
520  m_nt_L1_J10_EMPTY = false;
521  m_nt_L1_J30_FIRSTEMPTY = false;
522  m_nt_L1_J30_EMPTY = false;
523  m_nt_L1_XE40 = false;
524  m_nt_L1_XE50 = false;
525  m_nt_L1_XE50_BGRP7 = false;
526  m_nt_L1_XE70 = false;
527 
528  m_nt_EF_j165_u0uchad_LArNoiseBurst = false;
529  m_nt_EF_j30_u0uchad_empty_LArNoiseBurst = false;
530  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst = false;
531  m_nt_EF_j55_u0uchad_empty_LArNoiseBurst = false;
532  m_nt_EF_xe45_LArNoiseBurst = false;
533  m_nt_EF_xe55_LArNoiseBurst = false;
534  m_nt_EF_xe60_LArNoiseBurst = false;
535  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT = false;
536  m_nt_EF_j100_u0uchad_LArNoiseBurstT = false;
537  m_nt_EF_j165_u0uchad_LArNoiseBurstT = false;
538  m_nt_EF_j130_u0uchad_LArNoiseBurstT = false;
539  m_nt_EF_j35_u0uchad_empty_LArNoiseBurst = false;
540  m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst = false;
541  m_nt_EF_j80_u0uchad_LArNoiseBurstT = false;
542 
543  ATH_MSG_DEBUG ( "clearing trigger flags " );
544 
545  ATH_MSG_DEBUG ( "clearing noisy cells variables " );
546 
547  //Quantities for noisy cells
548  m_nt_energycell.clear();
549  m_nt_qfactorcell.clear();
550  m_nt_phicell.clear();
551  m_nt_etacell.clear();
552  m_nt_signifcell.clear();
553  m_nt_isbadcell.clear();
554  m_nt_partition.clear();
555  m_nt_layer.clear();
556  //m_nt_noisycellpercent = -1;
557  m_nt_barrelec_noisy.clear();
558  m_nt_posneg_noisy.clear();
559  m_nt_ft_noisy.clear();
560  m_nt_slot_noisy.clear();
561  m_nt_channel_noisy.clear();
562  m_nt_larcellsize = -1;
563  m_nt_cellsize = -1;
564  m_nt_cellpartlayerindex.clear();
565  m_nt_cellIdentifier.clear();
566  m_nt_onlIdentifier.clear();
567  m_nt_noisycellpart.clear();
568  m_nt_samples.clear();
569  m_nt_gain.clear();
570 
572  m_nt_noisycellHVphi.clear();
573  m_nt_noisycellHVeta.clear();
574 
575  ATH_MSG_DEBUG ( "clearing saturated cell variables " );
576 
577  //clearing quantities for sat cells
578  m_nt_barrelec_sat.clear();
579  m_nt_posneg_sat.clear();
580  m_nt_ft_sat.clear();
581  m_nt_slot_sat.clear();
582  m_nt_channel_sat.clear();
583  m_nt_partition_sat.clear();
584  m_nt_energy_sat.clear();
585  m_nt_phicell_sat.clear();
586  m_nt_etacell_sat.clear();
587  m_nt_layer_sat.clear();
588  m_nt_cellIdentifier_sat.clear();
589  m_nt_isbadcell_sat.clear();
590 
591  ATH_MSG_DEBUG ( "clearing LArTimeDiff variables " );
592 
593  //DiffTime computed with LAR
594  m_nt_ECTimeDiff = 9999;
595  m_nt_ECTimeAvg = 9999;
596  m_nt_nCellA = -1;
597  m_nt_nCellC = -1;
598 
599  return StatusCode::SUCCESS;
600 }

◆ declareGaudiProperty() [1/4]

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

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

Definition at line 170 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [2/4]

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

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

Definition at line 156 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [3/4]

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

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

Definition at line 184 of file AthCommonDataStore.h.

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

◆ declareGaudiProperty() [4/4]

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

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

Definition at line 199 of file AthCommonDataStore.h.

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

◆ declareProperty() [1/6]

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

Declare a new Gaudi property.

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

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

Definition at line 245 of file AthCommonDataStore.h.

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

◆ declareProperty() [2/6]

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

Declare a new Gaudi property.

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

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

Definition at line 221 of file AthCommonDataStore.h.

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

◆ declareProperty() [3/6]

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

Definition at line 259 of file AthCommonDataStore.h.

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

◆ declareProperty() [4/6]

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

Declare a new Gaudi property.

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

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

Definition at line 333 of file AthCommonDataStore.h.

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

◆ declareProperty() [5/6]

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

Declare a new Gaudi property.

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

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

Definition at line 352 of file AthCommonDataStore.h.

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

◆ declareProperty() [6/6]

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

Definition at line 145 of file AthCommonDataStore.h.

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

◆ detStore()

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

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

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ doEventProperties()

StatusCode LArNoiseBursts::doEventProperties ( )
private

Definition at line 749 of file LArNoiseBursts.cxx.

749  {
750  ATH_MSG_DEBUG ("in doEventProperties ");
751 
752 
754  // Retrieve event info
755  const xAOD::EventInfo* eventInfo = nullptr;
756  ATH_CHECK( evtStore()->retrieve(eventInfo) );
757 
758  int run = eventInfo->runNumber();
759  m_nt_run = eventInfo->runNumber();
760  m_nt_evtId = eventInfo->eventNumber();
761  m_nt_evtTime = eventInfo->timeStamp();
762  m_nt_evtTime_ns = eventInfo->timeStampNSOffset();
763  m_nt_lb = eventInfo->lumiBlock();
764  m_nt_bcid = eventInfo->bcid();
765 
766  ATH_MSG_DEBUG("Run Number: "<<run<<", event Id "<<m_nt_evtId<<", bcid = "<<m_nt_bcid);
767 
768  SG::ReadCondHandle<BunchCrossingCondData> bccd (m_bcDataKey);
769  const BunchCrossingCondData* bunchCrossing=*bccd;
770  if (!bunchCrossing) {
771  ATH_MSG_ERROR("Failed to retrieve Bunch Crossing obj");
772  return StatusCode::FAILURE;
773  }
774 
775  m_nt_isbcidFilled = bunchCrossing->isFilled(m_nt_bcid);
776  m_nt_isbcidInTrain = bunchCrossing->isInTrain(m_nt_bcid);
777  m_nt_bunchtype = bunchCrossing->bcType(m_nt_bcid);
778  ATH_MSG_DEBUG("BCID is Filled: "<<m_nt_isbcidFilled);
779  ATH_MSG_DEBUG("BCID is in Train: "<<m_nt_isbcidInTrain);
780  ATH_MSG_DEBUG("bunch type "<<m_nt_bunchtype);
781 
782  unsigned int distFromFront = bunchCrossing->distanceFromFront(m_nt_bcid,BunchCrossingCondData::BunchCrossings);
783  if(m_frontbunches < distFromFront) distFromFront=m_frontbunches;
784 
785  bool checkfirstbunch = true;
786  for(unsigned int i=1;i<=distFromFront;i++){
787  bool isFilled=bunchCrossing->isFilled(m_nt_bcid-i);
788  ATH_MSG_DEBUG("bunch "<<i<<" is Filled "<<isFilled);
789  m_nt_isBunchesInFront.push_back(isFilled);
790  if(isFilled){
791  if(i!=1){
792  if(checkfirstbunch){
793  float time = 25.0*i;
794  m_nt_bunchtime = time;
795  ATH_MSG_DEBUG("next bunch time: "<<time<<" ns ");
796  checkfirstbunch = false;
797  }
798  }
799  }
800  }
801 
802  m_CosmicCaloStream = false;
803  //std::vector<TriggerInfo::StreamTag>::const_iterator streamInfoIt=myTriggerInfo->streamTags().begin();
804  //std::vector<TriggerInfo::StreamTag>::const_iterator streamInfoIt_e=myTriggerInfo->streamTags().end();
805  //for (;streamInfoIt!=streamInfoIt_e;streamInfoIt++) {
806  for (const auto& streamInfo : eventInfo->streamTags()) {
807  const std::string& stream_name = streamInfo.name();
808  const std::string& stream_type = streamInfo.type();
809  m_nt_streamTagName.push_back(stream_name);
810  m_nt_streamTagType.push_back(stream_type);
811  ATH_MSG_DEBUG("event stream tag name "<<streamInfo.name());
812  ATH_MSG_DEBUG("event stream tag type "<<streamInfo.type());
813  if(streamInfo.name()=="CosmicCalo" && streamInfo.type()=="physics"){
814  m_CosmicCaloStream = true;
815  }
816  }
817 
818 
819  ATH_MSG_DEBUG("CosmicCalo stream value: "<<m_CosmicCaloStream);
820 
821  // Retrieve output of LArNoisyRO
822  bool larnoisyro = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS);
823  bool larnoisyro_opt =eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS_W);
824  bool larnoisyro_satTwo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ);
825  bool larmnbnoisy = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTLOOSE);
826  bool larmnbnoisy_sat = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTTIGHT);
827  m_nt_larnoisyro = larnoisyro ? 1 : 0;
828  m_nt_larnoisyro_opt = larnoisyro_opt ? 1 : 0;
829  m_nt_larnoisyro_satTwo = larnoisyro_satTwo ? 1 : 0;
830  m_nt_larmnbnoisy = larmnbnoisy ? 1 : 0;
831  m_nt_larmnbnoisy_sat = larmnbnoisy_sat ? 1 : 0;
832 
833  // Retrieve output of EventInfo veto - COMMENTED NOW TO MAKE IT COMPLIANT WITH xAOD::EventInfo
834 // mLog << MSG::DEBUG <<"Background: MBTSBeamVeto "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSBeamVeto)<<endmsg;
835 // mLog << MSG::DEBUG <<"Background: PixSPNonEmpty "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::PixSPNonEmpty)<<endmsg;
836 // mLog << MSG::DEBUG <<"Background: SCTSPNonEmpty "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::SCTSPNonEmpty)<<endmsg;
837 // mLog << MSG::DEBUG <<"Background: BCMBeamVeto "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMBeamVeto)<<endmsg;
838 // mLog << MSG::DEBUG <<"Background: LUCIDBeamVeto "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LUCIDBeamVeto)<<endmsg;
839 // mLog << MSG::DEBUG <<"Background: MBTSTimeDiffHalo "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSTimeDiffHalo)<<endmsg;
840 // mLog << MSG::DEBUG <<"Background: MBTSTimeDiffCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSTimeDiffCol)<<endmsg;
841 // mLog << MSG::DEBUG <<"Background: LArECTimeDiffHalo "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LArECTimeDiffHalo)<<endmsg;
842 // mLog << MSG::DEBUG <<"Background: LArECTimeDiffCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LArECTimeDiffCol)<<endmsg;
843 // mLog << MSG::DEBUG <<"Background: CSCTimeDiffHalo "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::CSCTimeDiffHalo)<<endmsg;
844 // mLog << MSG::DEBUG <<"Background: CSCTimeDiffCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::CSCTimeDiffCol)<<endmsg;
845 // mLog << MSG::DEBUG <<"Background: BCMTimeDiffHalo "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMTimeDiffHalo)<<endmsg;
846 // mLog << MSG::DEBUG <<"Background: BCMTimeDiffCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMTimeDiffCol)<<endmsg;
847 // mLog << MSG::DEBUG <<"Background: MuonTimmingCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MuonTimingCol)<<endmsg;
848 // mLog << MSG::DEBUG <<"Background: MuonTimmingCosmic "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MuonTimingCosmic)<<endmsg;
849 //
850 // m_nt_veto_mbts = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSBeamVeto);
851 // m_nt_veto_pixel = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::PixSPNonEmpty);
852 // m_nt_veto_sct = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::SCTSPNonEmpty);
853 // m_nt_veto_bcm = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMBeamVeto);
854 // m_nt_veto_lucid = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LUCIDBeamVeto);
855 //
856 // //more variables
857 // m_nt_veto_mbtstdHalo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSTimeDiffHalo);
858 // m_nt_veto_mbtstdCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSTimeDiffCol);
859 // m_nt_veto_lartdHalo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LArECTimeDiffHalo);
860 // m_nt_veto_lartdCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LArECTimeDiffCol);
861 // m_nt_veto_csctdHalo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::CSCTimeDiffHalo);
862 // m_nt_veto_csctdCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::CSCTimeDiffCol);
863 // m_nt_veto_bcmtHalo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMTimeDiffHalo);
864 // m_nt_veto_bcmtCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMTimeDiffCol);
865 // m_nt_veto_muontCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MuonTimingCol);
866 // m_nt_veto_muontCosmic= eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MuonTimingCosmic);
867 
868  // LArEventInfo
869 
870  ATH_MSG_DEBUG ("NOISEBURSTVETO bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO) );
871  ATH_MSG_DEBUG ("BADFEBS bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS));
872  ATH_MSG_DEBUG ("TIGHTSATURATEDQ bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ));
873 
874  m_nt_larflag_badFEBs = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS);
875  m_nt_larflag_mediumSaturatedDQ = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MEDIUMSATURATEDQ);
876  m_nt_larflag_tightSaturatedDQ = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ);
877  m_nt_larflag_noiseBurstVeto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO);
878  m_nt_larflag_dataCorrupted = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::DATACORRUPTED);
879  m_nt_larflag_dataCorruptedVeto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::DATACORRUPTEDVETO);
880 
882 
883  //const AthenaAttributeList* attrList(0);
884  //ATH_CHECK( evtStore()->retrieve(attrList, "/TDAQ/RunCtrl/DataTakingMode") );
885  //if (attrList != 0) {
886  // ATH_MSG_DEBUG ("ReadyForPhysics is: " << (*attrList)["ReadyForPhysics"].data<uint32_t>());
887  // //m_valueCache = ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
888  // m_nt_atlasready = (*attrList)["ReadyForPhysics"].data<uint32_t>();
889  // }
890 
891  /*const AthenaAttributeList* fillstate(0);
892  sc = evtStore()->retrieve(fillstate, "/LHC/DCS/FILLSTATE");
893  if (sc.isFailure()) {
894  ATH_MSG_WARNING ("Unable to retrieve fillstate information; falling back to" );
895  return StatusCode::SUCCESS;
896  }
897  if (fillstate != 0) {
898  ATH_MSG_DEBUG ("Stable beams is: " << (*fillstate)["StableBeams"].data<uint32_t>());
899  //m_valueCache = ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
900  m_nt_stablebeams.push_back((*fillstate)["StableBeams"].data<uint32_t>());
901  }*/
902 
903 
904  // 29/11/10 : Debug messages removed by BT
905  // mLog << MSG::INFO << "Event LAr flags " << std::hex
906  // << eventInfo->errorState(xAOD::EventInfo::LAr) << " "
907  // << std::hex << eventInfo->eventFlags(xAOD::EventInfo::LAr)
908  // << ", bit 0: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,0)
909  // << ", bit 1: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,1)
910  // << ", bit 2: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,2)
911  // << endmsg;
912 
913  // Retrieve LArCollision Timing information
914  const LArCollisionTime * larTime=nullptr;
915  if (evtStore()->contains<LArCollisionTime>("LArCollisionTime")) {
916  StatusCode sc = evtStore()->retrieve(larTime,"LArCollisionTime");
917  if( sc.isFailure()){
918  ATH_MSG_WARNING ( "Unable to retrieve LArCollisionTime event store" );
919  //return StatusCode::SUCCESS; // Check if failure shd be returned. VB
920  }else {
921  ATH_MSG_DEBUG ( "LArCollisionTime successfully retrieved from event store" );
922  }
923  }
924 
925  if (larTime) {
926  m_nt_nCellA = larTime->ncellA();
927  m_nt_nCellC = larTime->ncellC();
928  if(m_nt_nCellA>0 && m_nt_nCellC>0){
929  // Calculate the time diff between ECC and ECA
930  m_nt_ECTimeDiff = larTime->timeC() - larTime->timeA();
931  m_nt_ECTimeAvg = (larTime->timeC() + larTime->timeA()) * 0.5;
932  ATH_MSG_DEBUG ( "LAr: Calculated time difference of " << m_nt_ECTimeDiff << " ns" );
933  }
934  }
935 
936  return StatusCode::SUCCESS;
937 }

◆ doLArNoiseBursts()

StatusCode LArNoiseBursts::doLArNoiseBursts ( )
private

Definition at line 942 of file LArNoiseBursts.cxx.

942  {
943  ATH_MSG_DEBUG ( "in doLarCellInfo " );
944  const EventContext& ctx = Gaudi::Hive::currentContext();
945 
946  SG::ReadCondHandle<LArOnOffIdMapping> larCablingHdl (m_cablingKey, ctx);
947  const LArOnOffIdMapping* cabling=*larCablingHdl;
948  if(!cabling) {
949  ATH_MSG_WARNING("Do not have cabling info, not storing LarCellInfo ");
950  return StatusCode::SUCCESS;
951  }
952 
953  SG::ReadCondHandle<LArBadChannelCont> bcHdl (m_BCKey, ctx);
954  const LArBadChannelCont* bcCont=*bcHdl;
955  if(!bcCont) {
956  ATH_MSG_WARNING("Do not have bad chan info, not storing LarCellInfo ");
957  return StatusCode::SUCCESS;
958  }
959 
960  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
961  ATH_CHECK(caloMgrHandle.isValid());
962  const CaloDetDescrManager* caloMgr = *caloMgrHandle;
963 
964  // Retrieve LAr calocells container
965  // or LArRawChannel container, whatsever available...
966  const CaloCellContainer* caloTES=nullptr;
967  const LArRawChannelContainer* LArTES=nullptr;
968  const LArRawChannelContainer* LArTES_dig=nullptr;
969  if(evtStore()->contains<CaloCellContainer>("AllCalo")) {
970  ATH_CHECK(evtStore()->retrieve( caloTES, "AllCalo"));
971  } else if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels") || evtStore()->contains<LArRawChannelContainer>("LArRawChannels_fB")) {
972  if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels")) {
973  ATH_CHECK(evtStore()->retrieve( LArTES_dig, "LArRawChannels"));
974  }
975  if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels_fB")) {
976  ATH_CHECK(evtStore()->retrieve( LArTES, "LArRawChannels_fB"));
977  }
978  }
979 
980  if (caloTES==nullptr && LArTES==nullptr) {
981  ATH_MSG_WARNING ( "Neither CaloCell nor LArRawChannel Containers found!" );
982  return StatusCode::SUCCESS;
983  }
984 
985  m_nb_sat = 0;
986  m_noisycell =0;
987  nlarcell = 0;
988  v_barrelec_noisy.clear(); v_posneg_noisy.clear();
989  v_ft_noisy.clear();v_slot_noisy.clear();v_channel_noisy.clear();
990  v_isbarrel.clear();v_isendcap.clear();v_isfcal.clear();v_ishec.clear();
991  v_layer.clear();v_partition.clear();v_energycell.clear();v_qfactorcell.clear();
992  v_phicell.clear();v_etacell.clear();v_signifcell.clear();v_isbadcell.clear();
993  v_IdHash.clear();v_noisycellHVeta.clear();v_noisycellHVphi.clear();
994  v_cellpartlayerindex.clear();v_cellIdentifier.clear();v_onlIdentifier.clear();
995 
996  float eCalo;
997  float qfactor;
998  CaloGain::CaloGain gain;
999 
1000  SG::ReadCondHandle<CaloNoise> totalNoise (m_totalNoiseKey, ctx);
1001 
1002  if(caloTES) {
1003  for (const CaloCell* cell : *caloTES) {
1004  const CaloDetDescrElement* caloDDE = cell->caloDDE();
1005  if (caloDDE->is_tile())continue;
1006  HWIdentifier onlID;
1007  try {onlID = cabling->createSignalChannelID(cell->ID());}
1008  catch(LArID_Exception& except) {
1009  ATH_MSG_ERROR ( "LArID_Exception " << m_LArEM_IDHelper->show_to_string(cell->ID()) << " " << (std::string) except );
1010  ATH_MSG_ERROR ( "LArID_Exception " << m_LArHEC_IDHelper->show_to_string(cell->ID()) );
1011  ATH_MSG_ERROR ( "LArID_Exception " << m_LArFCAL_IDHelper->show_to_string(cell->ID()) );
1012  continue;
1013  }
1014  bool connected = cabling->isOnlineConnected(onlID);
1015  if(!connected) continue;
1016  eCalo = cell->energy();
1017  qfactor = cell->quality();
1018  gain = cell->gain();
1019  //if(qfactor > 0. || cell->ID() == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cell->ID()<<" : "<<eCalo<<" "<<qfactor<<" "<<gain<<" prov.: "<<cell->provenance());
1020  ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
1021  }//loop over cells
1022  ATH_MSG_DEBUG("Done cells "<<nlarcell);
1023  } else {
1024  std::vector<HWIdentifier> chdone;
1025  if (LArTES_dig) {
1026  LArRawChannelContainer::const_iterator caloItr;
1027  for(caloItr=LArTES_dig->begin();caloItr!=LArTES_dig->end();++caloItr){
1028  HWIdentifier onlID=caloItr->identify();
1029  bool connected = cabling->isOnlineConnected(onlID);
1030  if(!connected) continue;
1031  eCalo = caloItr->energy();
1032  qfactor = caloItr->quality();
1033  gain = caloItr->gain();
1034  //if(qfactor>0 || cabling->cnvToIdentifier((*caloItr).identify()) == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cabling->cnvToIdentifier((*caloItr).identify())<<" : "<<eCalo<<" "<<qfactor<<" "<<gain);
1035  ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
1036  chdone.push_back(onlID);
1037  }//loop over raw channels
1038  }
1039  ATH_MSG_DEBUG("Done raw chan. from digi "<<nlarcell);
1040  // dirty hack, if we are already complete:
1041  if (nlarcell < 182468 && LArTES) { // add those raw channels, which were not from dig.
1042  LArRawChannelContainer::const_iterator caloItr;
1043  for(caloItr=LArTES->begin();caloItr!=LArTES->end();++caloItr){
1044  HWIdentifier onlID=caloItr->identify();
1045  if(std::find(chdone.begin(), chdone.end(), onlID) != chdone.end()) continue;
1046  bool connected = cabling->isOnlineConnected(onlID);
1047  if(!connected) continue;
1048  eCalo = caloItr->energy();
1049  qfactor = caloItr->quality();
1050  gain = caloItr->gain();
1051  //if(qfactor>0 || cabling->cnvToIdentifier((*caloItr).identify()) == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cabling->cnvToIdentifier((*caloItr).identify())<<" : "<<eCalo<<" "<<qfactor<<" "<<gain);
1052  ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
1053  }//loop over raw channels
1054  }
1055  ATH_MSG_DEBUG("Done raw chan. "<<nlarcell);
1056  } // if raw chanels
1057 
1058  m_nt_larcellsize = nlarcell;
1059  if(caloTES) {
1060  m_nt_cellsize = caloTES->size();
1061  }
1062  else if (LArTES) {
1063  m_nt_cellsize = LArTES->size();
1064  }
1065  ATH_MSG_DEBUG ("lar cell size = "<<int(nlarcell));
1066  if(caloTES) ATH_MSG_DEBUG ("all cell size = "<<int(caloTES->size()));
1067  else {
1068  if(LArTES_dig) ATH_MSG_DEBUG ("all LArRawCh. from digi size = "<<int(LArTES_dig->size()));
1069  if(LArTES) ATH_MSG_DEBUG ("all LArRawCh. size = "<<int(LArTES->size()));
1070  }
1071 
1072  //if (nlarcell > 0)
1073  // m_nt_noisycellpercent = 100.0*double(n_noisycell)/double(nlarcell);
1074  //else
1075  // m_nt_noisycellpercent = 0;
1076 
1077  bool checknoise = false;
1078  //ratio of noisy cells per partition
1079  for(unsigned int i=0;i<8;i++){
1080  float noise = 100.0*(double(n_noisy_cell_part[i])/double(n_cell_part[i]));
1081  m_nt_noisycellpart.push_back(noise);
1082  if(noise> 1.0){
1083  checknoise = true;
1084  ATH_MSG_DEBUG ("noise burst in this event ");
1085  }
1086  }
1087 
1088  const LArDigitContainer* LArDigitCont=nullptr;
1089  if (evtStore()->contains<LArDigitContainer>("FREE")) ATH_CHECK(evtStore()->retrieve( LArDigitCont, "FREE"));
1090  if(!LArDigitCont) {
1091  if (evtStore()->contains<LArDigitContainer>("LArDigitContainer_Thinned")) ATH_CHECK(evtStore()->retrieve( LArDigitCont, "LArDigitContainer_Thinned"));
1092  }
1093  if (!LArDigitCont) {
1094  ATH_MSG_WARNING ( "LArDigitContainer Container not found!" );
1095  return StatusCode::SUCCESS;
1096  }
1097 
1098  bool store_condition = false;
1099  // CosmicCalo stream : Store detailed infos of cells only if Y3Sigma>1% or burst found by LArNoisyRO
1100  if(m_CosmicCaloStream){
1101  if(checknoise==true || m_nt_larnoisyro==1 || m_nt_larnoisyro_satTwo==1){
1102  store_condition = true;
1103  }
1104  }
1105  // Not cosmicCalo stream : Store detailed infos of cells only if burst found by LArNoisyRO
1106  if(!m_CosmicCaloStream){
1107  if(m_nt_larnoisyro==1 || m_nt_larnoisyro_satTwo==1){
1108  store_condition = true;
1109  }
1110  }
1111 
1112  //store the information of the noisy cell only when %noisycells > 1%.
1113  if(store_condition){
1114  std::vector<short> samples;
1115  samples.clear();
1116  for(unsigned int k=0;k<v_etacell.size();k++){
1117  m_nt_samples.push_back(samples);
1118  m_nt_gain.push_back(0);
1119  }
1120  for (const LArDigit* pLArDigit : *LArDigitCont) {
1121  HWIdentifier id2 = pLArDigit->hardwareID();
1122  IdentifierHash hashid2 = m_LArOnlineIDHelper->channel_Hash(id2);
1123  for(unsigned int j=0;j<v_IdHash.size();j++){
1124  if (hashid2 == v_IdHash[j] ){
1125  ATH_MSG_DEBUG ( "find a IdentifierHash of the noisy cell in LArDigit container " );
1126  samples = pLArDigit->samples();
1127  int gain=-1;
1128  if (pLArDigit->gain() == CaloGain::LARHIGHGAIN) gain = 0;
1129  if (pLArDigit->gain() == CaloGain::LARMEDIUMGAIN) gain = 1;
1130  if (pLArDigit->gain() == CaloGain::LARLOWGAIN) gain = 2;
1131  m_nt_gain.at(j)= gain;
1132  m_nt_samples.at(j) = samples;
1133  ATH_MSG_DEBUG ( "I got the samples!" );
1134  break;
1135  }
1136  }
1137  }
1138  for(unsigned int i=0;i<v_etacell.size();i++){
1139  m_nt_energycell.push_back( v_energycell[i]);
1140  m_nt_qfactorcell.push_back( v_qfactorcell[i]);
1141  m_nt_signifcell.push_back( v_signifcell[i]);
1142  m_nt_partition.push_back( v_partition[i]);
1143  m_nt_cellIdentifier.push_back(v_cellIdentifier[i].get_identifier32().get_compact());
1144  m_nt_onlIdentifier.push_back(v_onlIdentifier[i].get_identifier32().get_compact());
1145  if(!m_keepOnlyCellID){
1146  m_nt_barrelec_noisy.push_back( v_barrelec_noisy[i]);
1147  m_nt_posneg_noisy.push_back( v_posneg_noisy[i]);
1148  m_nt_ft_noisy.push_back( v_ft_noisy[i]);
1149  m_nt_slot_noisy.push_back( v_slot_noisy[i]);
1150  m_nt_channel_noisy.push_back( v_channel_noisy[i]);
1151 
1152  /*
1153  m_nt_isbarrel.push_back( v_isbarrel[i]);
1154  m_nt_isendcap.push_back( v_isendcap[i]);
1155  m_nt_isfcal.push_back( v_isfcal[i]);
1156  m_nt_ishec.push_back( v_ishec[i]);
1157  */
1158 
1159  m_nt_layer.push_back( v_layer[i]);
1160  m_nt_phicell.push_back( v_phicell[i]);
1161  m_nt_etacell.push_back( v_etacell[i]);
1162  m_nt_isbadcell.push_back( v_isbadcell[i]);
1163  m_nt_noisycellHVphi.push_back(v_noisycellHVphi[i]);
1164  m_nt_noisycellHVeta.push_back(v_noisycellHVeta[i]);
1165  m_nt_cellpartlayerindex.push_back(v_cellpartlayerindex[i]);
1166  }
1167  }
1168  ATH_MSG_DEBUG ("leaving if checknoise and larnoisyro");
1169 
1170  }//if(checknoisy==true ..)
1171 
1172  return StatusCode::SUCCESS;
1173 
1174 }

◆ doPhysicsObjects()

StatusCode LArNoiseBursts::doPhysicsObjects ( )
private

Definition at line 1303 of file LArNoiseBursts.cxx.

1303  {
1304  ATH_MSG_DEBUG ("in doPhysicsObjects ");
1305 
1306 // const ElectronContainer* elecTES = 0;
1307 // StatusCode sc=evtStore()->retrieve( elecTES, m_elecContainerName);
1308 // if( sc.isFailure() || !elecTES ) {
1309 // ATH_MSG_WARNING ( "No ESD electron container found in StoreGate" );
1310 // return StatusCode::SUCCESS;
1311 // }
1312 // ATH_MSG_DEBUG ( "ElectronContainer successfully retrieved. Size = " << elecTES->size() );
1313 
1314  return StatusCode::SUCCESS;
1315 }

◆ doTrigger()

StatusCode LArNoiseBursts::doTrigger ( )
private

methods called by execute()

Definition at line 649 of file LArNoiseBursts.cxx.

649  {
650  ATH_MSG_DEBUG ("in doTrigger ");
651 
652  std::string mychain( "L1_J75" );
653  if( ! m_trigDec->getListOfTriggers(mychain).empty() ){
654  m_nt_L1_J75 = m_trigDec->isPassed( mychain );
655  }
656  mychain = "L1_J10_EMPTY";
657  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
658  m_nt_L1_J10_EMPTY = m_trigDec->isPassed( mychain );
659  }
660  mychain = "L1_J30_FIRSTEMPTY";
661  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
662  m_nt_L1_J30_FIRSTEMPTY = m_trigDec->isPassed( mychain );
663  }
664  mychain = "L1_J30_EMPTY";
665  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
666  m_nt_L1_J30_EMPTY = m_trigDec->isPassed( mychain );
667  }
668  mychain = "L1_XE40";
669  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
670  m_nt_L1_XE40 = m_trigDec->isPassed( mychain );
671  }
672  mychain = "L1_XE50";
673  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
674  m_nt_L1_XE50 = m_trigDec->isPassed( mychain );
675  }
676  mychain = "L1_XE50_BGRP7";
677  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
678  m_nt_L1_XE50_BGRP7 = m_trigDec->isPassed( mychain );
679  }
680  mychain = "L1_XE70";
681  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
682  m_nt_L1_XE70 = m_trigDec->isPassed( mychain );
683  }
684 
685  // EF
686  mychain = "EF_j165_u0uchad_LArNoiseBurst";
687  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
688  m_nt_EF_j165_u0uchad_LArNoiseBurst = m_trigDec->isPassed( mychain );
689  }
690  mychain = "EF_j30_u0uchad_empty_LArNoiseBurst";
691  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
692  m_nt_EF_j30_u0uchad_empty_LArNoiseBurst = m_trigDec->isPassed( mychain );
693  }
694  mychain = "EF_j55_u0uchad_firstempty_LArNoiseBurst";
695  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
696  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst = m_trigDec->isPassed( mychain );
697  }
698  mychain = "EF_j55_u0uchad_empty_LArNoiseBurst";
699  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
700  m_nt_EF_j55_u0uchad_empty_LArNoiseBurst = m_trigDec->isPassed( mychain );
701  }
702  mychain = "EF_xe45_LArNoiseBurst";
703  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
704  m_nt_EF_xe45_LArNoiseBurst = m_trigDec->isPassed( mychain );
705  }
706  mychain = "EF_xe55_LArNoiseBurst";
707  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
708  m_nt_EF_xe55_LArNoiseBurst = m_trigDec->isPassed( mychain );
709  }
710  mychain = "EF_xe60_LArNoiseBurst";
711  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
712  m_nt_EF_xe60_LArNoiseBurst = m_trigDec->isPassed( mychain );
713  }
714  mychain = "EF_j55_u0uchad_firstempty_LArNoiseBurstT";
715  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
716  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT = m_trigDec->isPassed( mychain );
717  }
718  mychain = "EF_j100_u0uchad_LArNoiseBurstT";
719  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
720  m_nt_EF_j100_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
721  }
722  mychain = "EF_j165_u0uchad_LArNoiseBurstT";
723  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
724  m_nt_EF_j165_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
725  }
726  mychain = "EF_j130_u0uchad_LArNoiseBurstT";
727  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
728  m_nt_EF_j130_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
729  }
730  mychain = "EF_j35_u0uchad_empty_LArNoiseBurst";
731  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
732  m_nt_EF_j35_u0uchad_empty_LArNoiseBurst = m_trigDec->isPassed( mychain );
733  }
734  mychain = "EF_j35_u0uchad_firstempty_LArNoiseBurst";
735  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
736  m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst = m_trigDec->isPassed( mychain );
737  }
738  mychain = "EF_j80_u0uchad_LArNoiseBurstT";
739  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
740  m_nt_EF_j80_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
741  }
742 
743  return StatusCode::SUCCESS;
744 }

◆ evtStore() [1/2]

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

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

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

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

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

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ execute()

StatusCode LArNoiseBursts::execute ( )
overridevirtual

Execute - on event by event.

Definition at line 605 of file LArNoiseBursts.cxx.

605  {
606  ATH_MSG_DEBUG ( "in execute()" );
607 
608  StatusCode sc = clear();
609  if(sc.isFailure()) {
610  ATH_MSG_WARNING ( "The method clear() failed" );
611  return StatusCode::SUCCESS;
612  }
613 
614  if(!m_trigDec.empty()){
615 
616  sc = doTrigger();
617  if(sc.isFailure()) {
618  ATH_MSG_WARNING ( "The method doTrigger() failed" );
619  return StatusCode::SUCCESS;
620  }
621  }
622 
623  sc = doEventProperties();
624  if(sc.isFailure()) {
625  ATH_MSG_WARNING ( "The method doEventProperties() failed" );
626  return StatusCode::SUCCESS;
627  }
628 
629  sc = doLArNoiseBursts();
630  if (sc.isFailure()) {
631  ATH_MSG_WARNING ( "The method doLArNoiseBursts() failed" );
632  return StatusCode::SUCCESS;
633  }
634 
635 // sc = doPhysicsObjects();
636 // if (sc.isFailure()) {
637 // ATH_MSG_WARNING ( "The method doPhysicsObjects() failed" );
638 // return StatusCode::SUCCESS;
639 // }
640 
641  m_tree->Fill();
642 
643  return StatusCode::SUCCESS;
644 }

◆ extraDeps_update_handler()

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

Add StoreName to extra input/output deps as needed.

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

◆ extraOutputDeps()

const DataObjIDColl & AthAlgorithm::extraOutputDeps ( ) const
overridevirtualinherited

Return the list of extra output dependencies.

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

Definition at line 50 of file AthAlgorithm.cxx.

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

◆ 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 1176 of file LArNoiseBursts.cxx.

1184 {
1185  const Identifier idd = cabling->cnvToIdentifier(onlID);
1186  nlarcell++;
1187  IdentifierHash channelHash = m_LArOnlineIDHelper->channel_Hash(onlID);
1188  const CaloDetDescrElement *caloDDE = caloMgr->get_element(idd);
1189  int layer = caloDDE->getLayer();
1190  // CaloCell_ID::CaloSample sampling = (*caloItr)->caloDDE()->getSampling();
1191  float phi = caloDDE->phi();
1192  float noise = totalNoise.getNoise (idd, gain);
1193  float significance = eCalo / noise ;
1194  float eta = caloDDE->eta();
1195  bool badcell = ! (bcCont->status(onlID)).good();
1196  unsigned int partition = 0;
1197  bool is_lar_em_barrel = caloDDE->is_lar_em_barrel();
1198  if(is_lar_em_barrel){
1199  if(eta<0){
1200  partition = 0;
1201  }else{
1202  partition = 1;
1203  }
1204  }//barrel
1205  bool is_lar_em_endcap = caloDDE->is_lar_em_endcap();
1206  if(is_lar_em_endcap){
1207  if(eta<0){
1208  partition = 2;
1209  }else{
1210  partition = 3;
1211  }
1212  }//endcap
1213  bool is_lar_fcal = caloDDE->is_lar_fcal();
1214  if(is_lar_fcal){
1215  if(eta<0){
1216  partition = 4;
1217  }else{
1218  partition = 5;
1219  }
1220  }//fcal
1221  bool is_lar_hec = caloDDE->is_lar_hec();
1222  if(is_lar_hec){
1223  if(eta<0){
1224  partition = 6;
1225  }else{
1226  partition = 7;
1227  }
1228  }//hec
1229  for(unsigned int k=0;k<8;k++){
1230  if(partition==k){
1231  n_cell_part[k]++;
1232  }
1233  }
1234  if(qfactor <1000) {m_lowqfactor++;}
1235  if(qfactor>=1000 && qfactor<10000) {m_medqfactor++;}
1236  if(qfactor>=10000 && qfactor<65535){m_hiqfactor++;}
1237  if(qfactor==65535){
1238  ATH_MSG_DEBUG ("Satured cell at eta: "<<eta<<", phi: "<<phi<<", energy: "<<eCalo<<", partition: "<<partition);
1239  m_nb_sat = m_nb_sat +1;
1240  m_nt_partition_sat.push_back(partition);
1241  m_nt_energy_sat.push_back(eCalo);
1242  m_nt_cellIdentifier_sat.push_back((cabling->cnvToIdentifier(onlID)).get_identifier32().get_compact());
1243  if(!m_keepOnlyCellID){
1244  m_nt_barrelec_sat.push_back(m_LArOnlineIDHelper->barrel_ec(onlID));
1245  m_nt_posneg_sat.push_back(m_LArOnlineIDHelper->pos_neg(onlID));
1246  m_nt_ft_sat.push_back(m_LArOnlineIDHelper->feedthrough(onlID));
1247  m_nt_slot_sat.push_back(m_LArOnlineIDHelper->slot(onlID));
1248  m_nt_channel_sat.push_back(m_LArOnlineIDHelper->channel(onlID));
1249  m_nt_phicell_sat.push_back(phi);
1250  m_nt_etacell_sat.push_back(eta);
1251  m_nt_layer_sat.push_back(layer);
1252  m_nt_isbadcell_sat.push_back(badcell);
1253  }
1254  }
1255  // Store all cells in positive and negative 3 sigma tails...
1256  if(significance > m_sigmacut || qfactor > 4000){
1257  v_barrelec_noisy.push_back(m_LArOnlineIDHelper->barrel_ec(onlID));
1258  v_posneg_noisy.push_back(m_LArOnlineIDHelper->pos_neg(onlID));
1259  v_ft_noisy.push_back(m_LArOnlineIDHelper->feedthrough(onlID));
1260  v_slot_noisy.push_back(m_LArOnlineIDHelper->slot(onlID));
1261  v_channel_noisy.push_back(m_LArOnlineIDHelper->channel(onlID));
1262 
1263  /*
1264  v_isbarrel.push_back(is_lar_em_barrel);
1265  v_isendcap.push_back(is_lar_em_endcap);
1266  v_isfcal.push_back(is_lar_fcal);
1267  v_ishec.push_back(is_lar_hec);
1268  */
1269 
1270  v_layer.push_back(layer);
1271  v_energycell.push_back(eCalo);
1272  v_qfactorcell.push_back(qfactor);
1273  v_phicell.push_back(phi);
1274  v_etacell.push_back(eta);
1275  v_signifcell.push_back(significance);
1276  v_isbadcell.push_back(badcell);
1277  v_partition.push_back(partition);
1278  v_IdHash.push_back(channelHash);
1279  v_cellIdentifier.push_back(cabling->cnvToIdentifier(onlID));
1280  v_onlIdentifier.push_back(onlID);
1281  // ...but count only cells in positive 3 sigma tails!
1282  if (significance > m_sigmacut){
1283  m_noisycell++;
1284  ATH_MSG_DEBUG ("Noisy cell: "<<m_noisycell<<" "<<cabling->cnvToIdentifier(onlID)<<" q: "<<qfactor<<" sign.: "<<significance<<" noise: "<<noise);
1285  for(unsigned int k=0;k<8;k++){
1286  if(partition==k){
1287  n_noisy_cell_part[k]++;
1288  }
1289  }
1290  }
1291  int caloindex = GetPartitionLayerIndex(idd);
1292  v_cellpartlayerindex.push_back(caloindex);
1293  v_noisycellHVphi.push_back(m_LArElectrodeIDHelper->hv_phi(onlID));
1294  v_noisycellHVeta.push_back(m_LArElectrodeIDHelper->hv_eta(onlID));
1295 
1296 
1297  }
1298  return StatusCode::SUCCESS;
1299 }

◆ finalize()

StatusCode LArNoiseBursts::finalize ( )
overridevirtual

Finalize - delete any memory allocation from the heap.

Definition at line 445 of file LArNoiseBursts.cxx.

445  {
446  ATH_MSG_DEBUG ( "in finalize()" );
447  return StatusCode::SUCCESS;
448 }

◆ GetPartitionLayerIndex()

int LArNoiseBursts::GetPartitionLayerIndex ( const Identifier &  id)
private

Definition at line 1320 of file LArNoiseBursts.cxx.

1321 {
1322  // O.Simard -- GetPartitionLayer index [0,32]:
1323  // Returns a single integer code that corresponds to the
1324  // mapping of CaloCells in CaloMonitoring histogram frames.
1325 
1326  int caloindex = -1;
1327  int bc = 0;
1328  int sampling = 0;
1329 
1330  if(m_LArEM_IDHelper->is_lar_em(id)){ // EMB
1331  bc = m_LArEM_IDHelper->barrel_ec(id);
1332  sampling = m_LArEM_IDHelper->sampling(id);
1333  if(abs(bc)==1){
1334  if(bc<0) caloindex = sampling+4;
1335  else caloindex = sampling;
1336  } else { // EMEC
1337  if(bc<0) caloindex = sampling+12;
1338  else caloindex = sampling+8;
1339  }
1340  } else if(m_LArHEC_IDHelper->is_lar_hec(id)) { // LAr HEC
1341  bc = m_LArHEC_IDHelper->pos_neg(id);
1342  sampling = m_LArHEC_IDHelper->sampling(id);
1343  if(bc<0) caloindex = sampling+20;
1344  else caloindex = sampling+16;
1345  } else if(m_LArFCAL_IDHelper->is_lar_fcal(id)) { // LAr FCAL
1346  bc = m_LArFCAL_IDHelper->pos_neg(id);
1347  sampling = (int)m_LArFCAL_IDHelper->module(id); // module instead of sampling
1348  if(bc<0) caloindex = sampling+26;
1349  else caloindex = sampling+23;
1350  }
1351 
1352  return caloindex;
1353 }

◆ initialize()

StatusCode LArNoiseBursts::initialize ( )
overridevirtual

Initialize initialize StoreGate get a handle on the analysis tools book histograms.

get a handle on the NTuple and histogramming service

Prepare TTree

NEW Identifier of the cell

Definition at line 249 of file LArNoiseBursts.cxx.

249  {
250 
251  ATH_MSG_DEBUG ( "Initializing LArNoiseBursts" );
252 
253  // Trigger Decision Tool
254  ATH_CHECK( m_trigDec.retrieve() );
255 
256  ATH_CHECK( m_cablingKey.initialize() );
257  ATH_CHECK( m_BCKey.initialize() );
258  ATH_CHECK( m_totalNoiseKey.initialize() );
259  ATH_CHECK( m_bcDataKey.initialize() );
260 
261  // Retrieve online ID helper
262  const LArOnlineID* LArOnlineIDHelper = nullptr;
263  ATH_CHECK( detStore()->retrieve(LArOnlineIDHelper, "LArOnlineID") );
264  m_LArOnlineIDHelper = LArOnlineIDHelper;
265  ATH_MSG_DEBUG( " Found LArOnline Helper");
266 
267  // Retrieve HV line ID helper
268  const LArHVLineID* LArHVLineIDHelper = nullptr;
269  ATH_CHECK( detStore()->retrieve(LArHVLineIDHelper, "LArHVLineID") );
270  m_LArHVLineIDHelper = LArHVLineIDHelper;
271  ATH_MSG_DEBUG( " Found LArOnlineIDHelper Helper");
272 
273  // Retrieve HV electrode ID helper
274  const LArElectrodeID* LArElectrodeIDHelper = nullptr;
275  ATH_CHECK( detStore()->retrieve(LArElectrodeIDHelper, "LArElectrodeID") );
276  m_LArElectrodeIDHelper = LArElectrodeIDHelper;
277  ATH_MSG_DEBUG( " Found LArElectrodeIDHelper Helper");
278 
279  ATH_CHECK(m_caloMgrKey.initialize());
280 
281  // Retrieve ID helpers
282  const CaloCell_ID* idHelper = nullptr;
283  ATH_CHECK( detStore()->retrieve (idHelper, "CaloCell_ID") );
284  m_LArEM_IDHelper = idHelper->em_idHelper();
285  m_LArHEC_IDHelper = idHelper->hec_idHelper();
286  m_LArFCAL_IDHelper = idHelper->fcal_idHelper();
287 
289  ATH_CHECK( service("THistSvc", m_thistSvc) );
290 
291  /*const AthenaAttributeList* fillparams(0);
292  sc = evtStore()->retrieve(fillparams, "/TDAQ/OLC/LHC/FILLPARAMS");
293  if (sc.isFailure()) {
294  ATH_MSG_WARNING ("Unable to retrieve fillparams information; falling back to" );
295  return StatusCode::SUCCESS;
296  }
297 
298  if (fillparams != 0) {
299  ATH_MSG_DEBUG ("beam 1 #bunches are: " << (*fillparams)["Beam1Bunches"].data<uint32_t>() );
300  ATH_MSG_DEBUG ("beam 2 #bunches are: " << (*fillparams)["Beam2Bunches"].data<uint32_t>() );
301  }
302 */
303 
305  m_tree = new TTree( "CollectionTree", "CollectionTree" );
306  std::string treeName = "/TTREE/CollectionTree" ;
307  ATH_CHECK( m_thistSvc->regTree(treeName, m_tree) );
308 
309  // General properties of events
310  m_tree->Branch("Run",&m_nt_run,"Run/I");// Event ID
311  m_tree->Branch("EventId",&m_nt_evtId,"EventId/l");// Event ID
312  m_tree->Branch("EventTime",&m_nt_evtTime,"EventTime/I");// Event time
313  m_tree->Branch("EventTime_ns",&m_nt_evtTime_ns,"EventTime_ns/I");// Event time in nanosecond
314  m_tree->Branch("LumiBlock",&m_nt_lb,"LumiBlock/I"); // LB
315  m_tree->Branch("BCID",&m_nt_bcid,"BCID/I"); // BCID
316  m_tree->Branch("StreamTagName",&m_nt_streamTagName);// stream tag name
317  m_tree->Branch("StreamTagType",&m_nt_streamTagType); // stream tag type
318  m_tree->Branch("IsBCIDFilled", &m_nt_isbcidFilled,"IsBCIDFilled/I"); // check if bunch is filled
319  m_tree->Branch("IsBCIDInTrain",&m_nt_isbcidInTrain,"ISBCIDInTrain/I"); // check if bunch belong to a train
320  m_tree->Branch("BunchesInFront",&m_nt_isBunchesInFront); // check front bunches
321  m_tree->Branch("BunchType",&m_nt_bunchtype,"BunchType/I");// Empty = 0, FirstEmpty=1,&middleEmpty=2, Single=100,Front=200,&middle=201,Tail=202
322  m_tree->Branch("TimeAfterBunch",&m_nt_bunchtime,"TimeAfterBunch/F"); //time "distance" between the colliding bunch and the nearest one.
323  m_tree->Branch("ATLASIsReady",&m_nt_atlasready,"AtlasIsReady/I"); //check if atlas is ready for physics
324  m_tree->Branch("StableBeams",&m_nt_stablebeams,"StableBeams/I");//check stablebeams
325 
326  // Background bits in EventInfo
327 // m_tree->Branch("vetoMBTS",&m_nt_veto_mbts,"vetoMBST/S"); //Beam/collision veto based on mbts
328 // m_tree->Branch("vetoPixel",&m_nt_veto_pixel,"vetoPixel/S"); //Beam/collision veto based on indet
329 // m_tree->Branch("vetoSCT",&m_nt_veto_sct,"vetoSCT/S"); //Beam/collision veto based on indet
330 // m_tree->Branch("vetoBcm",&m_nt_veto_bcm,"vetoBcm/S"); //Beam/collision veto based on bcm
331 // m_tree->Branch("vetoLucid",&m_nt_veto_lucid,"vetoLucid/S"); //Beam/collision veto based on lucid
332 // m_tree->Branch("vetoMBTSDtHalo",&m_nt_veto_mbtstdHalo,"vetoMBTSDtHalo/S");
333 // m_tree->Branch("vetoMBTSDtCol",&m_nt_veto_mbtstdCol,"vetoMBTSDtCol/S");
334 // m_tree->Branch("vetoLArDtHalo",&m_nt_veto_lartdHalo,"vetoLArDtHalo/S");
335 // m_tree->Branch("vetoLArDtCol",&m_nt_veto_lartdCol,"vetoLArDtCol/S");
336 // m_tree->Branch("vetoCSCDtHalo",&m_nt_veto_csctdHalo,"vetoCSCDtHalo/S");
337 // m_tree->Branch("vetoCSCDtCol",&m_nt_veto_csctdCol,"vetoCSCDtCol/S");
338 // m_tree->Branch("vetoBCMDtHalo",&m_nt_veto_bcmtHalo,"vetoBCMDtHalo/S");
339 // m_tree->Branch("vetoBCMDtCol",&m_nt_veto_bcmtCol,"vetoBCMDtCol/S");
340 // m_tree->Branch("vetoMuonTimmingCol", &m_nt_veto_muontCol,"vetoMuonTimmingCol/S");
341 // m_tree->Branch("vetoMuonTimmingCosmic",&m_nt_veto_muontCosmic,"vetoMuonTimmingCosmic/S");
342 
343  // LAr event bit info
344  m_tree->Branch("larflag_badFEBs",&m_nt_larflag_badFEBs,"larflag_badFEBs/O");
345  m_tree->Branch("larflag_mediumSaturatedDQ",&m_nt_larflag_mediumSaturatedDQ,"larflag_mediumSaturatedDQ/O");
346  m_tree->Branch("larflag_tightSaturatedDQ",&m_nt_larflag_tightSaturatedDQ,"larflag_tightSaturatedDQ/O");
347  m_tree->Branch("larflag_noiseBurstVeto",&m_nt_larflag_noiseBurstVeto,"larflag_noiseBurstVeto/O");
348  m_tree->Branch("larflag_dataCorrupted",&m_nt_larflag_dataCorrupted,"larflag_dataCorrupted/O");
349  m_tree->Branch("larflag_dataCorruptedVeto",&m_nt_larflag_dataCorruptedVeto,"larflag_dataCorruptedVeto/O");
350 
351  // trigger flags
352  m_tree->Branch("L1_J75",&m_nt_L1_J75,"L1_J75/O");
353  m_tree->Branch("L1_J10_EMPTY",&m_nt_L1_J10_EMPTY,"L1_J10_EMPTY/O");
354  m_tree->Branch("L1_J30_FIRSTEMPTY",&m_nt_L1_J30_FIRSTEMPTY,"L1_J30_FIRSTEMPTY/O");
355  m_tree->Branch("L1_J30_EMPTY",&m_nt_L1_J30_EMPTY,"L1_J30_EMPTY/O");
356  m_tree->Branch("L1_XE40",&m_nt_L1_XE40,"L1_XE40/O");
357  m_tree->Branch("L1_XE50",&m_nt_L1_XE50,"L1_XE50/O");
358  m_tree->Branch("L1_XE50_BGRP7",&m_nt_L1_XE50_BGRP7,"L1_XE50_BGRP7/O");
359  m_tree->Branch("L1_XE70",&m_nt_L1_XE70,"L1_XE70/O");
360 
361  m_tree->Branch("EF_j165_u0uchad_LArNoiseBurst",&m_nt_EF_j165_u0uchad_LArNoiseBurst,"EF_j165_u0uchad_LArNoiseBurst/O");
362  m_tree->Branch("EF_j30_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j30_u0uchad_empty_LArNoiseBurst,"EF_j30_u0uchad_empty_LArNoiseBurst/O");
363  m_tree->Branch("EF_j55_u0uchad_firstempty_LArNoiseBurst",&m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst,"EF_j55_u0uchad_firstempty_LArNoiseBurst/O");
364  m_tree->Branch("EF_j55_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j55_u0uchad_empty_LArNoiseBurst,"EF_j55_u0uchad_empty_LArNoiseBurst/O");
365  m_tree->Branch("EF_xe45_LArNoiseBurst",&m_nt_EF_xe45_LArNoiseBurst,"EF_xe45_LArNoiseBurst/O");
366  m_tree->Branch("EF_xe55_LArNoiseBurst",&m_nt_EF_xe55_LArNoiseBurst,"EF_xe55_LArNoiseBurst/O");
367  m_tree->Branch("EF_xe60_LArNoiseBurst",&m_nt_EF_xe60_LArNoiseBurst,"EF_xe60_LArNoiseBurst/O");
368  m_tree->Branch("EF_j55_u0uchad_firstempty_LArNoiseBurstT",&m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT,"EF_j55_u0uchad_firstempty_LArNoiseBurstT/O");
369  m_tree->Branch("EF_j100_u0uchad_LArNoiseBurstT",&m_nt_EF_j100_u0uchad_LArNoiseBurstT,"EF_j100_u0uchad_LArNoiseBurstT/O");
370  m_tree->Branch("EF_j165_u0uchad_LArNoiseBurstT",&m_nt_EF_j165_u0uchad_LArNoiseBurstT,"EF_j165_u0uchad_LArNoiseBurstT/O");
371  m_tree->Branch("EF_j130_u0uchad_LArNoiseBurstT",&m_nt_EF_j130_u0uchad_LArNoiseBurstT,"EF_j130_u0uchad_LArNoiseBurstT/O");
372  m_tree->Branch("EF_j35_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j35_u0uchad_empty_LArNoiseBurst,"EF_j35_u0uchad_empty_LArNoiseBurst/O");
373  m_tree->Branch("EF_j35_u0uchad_firstempty_LArNoiseBurst",&m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst,"EF_j35_u0uchad_firstempty_LArNoiseBurst/O");
374  m_tree->Branch("EF_j80_u0uchad_LArNoiseBurstT",&m_nt_EF_j80_u0uchad_LArNoiseBurstT,"EF_j80_u0uchad_LArNoiseBurstT/O");
375 
376  //
377  m_tree->Branch("LArCellSize", &m_nt_larcellsize,"LArCellSize/I"); // NEW number of online conected LAr cells
378  m_tree->Branch("CaloCellSize",&m_nt_cellsize,"CaloCellSize/I");// NEW number of total cells.
379  // LAr time difference as computed by LArCollisionTime info
380  m_tree->Branch("LArTime_Diff",&m_nt_ECTimeDiff,"LArTime_Diff/F"); // time diff between 2 endcaps
381  m_tree->Branch("LArTime_Avg",&m_nt_ECTimeAvg,"LArTime_Avg/F"); // time average of 2 endcaps
382  m_tree->Branch("LArTime_nCellA",&m_nt_nCellA,"LArTime_nCellA/I"); // nb of cells used to compute endcap A time
383  m_tree->Branch("LArTime_nCellC",&m_nt_nCellC,"LArTime_nCellC/I"); // nb of cells used to compute endcap C time
384 
385  // Event properties related to yield of channels in 3 sigma tails
386  //m_tree->Branch("PerCentNoisyCell",&m_nt_noisycellpercent,"PerCentNoisyCell/F"); // Yield of channels in 3sigma tails in whole LAr
387  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
388 
389  // LArNoisyRO output
390  m_tree->Branch("LArNoisyRO_Std", &m_nt_larnoisyro,"LArNoisyRO_Std/S"); // standard flag (>5 FEB with more than 30 cells with q factor > 4000)
391  m_tree->Branch("LArNoisyRO_Std_optimized", &m_nt_larnoisyro_opt,"LArNoisyRO_Std_optimized/S"); // standard flag with a double weight for critical FEB (>5 FEB with more than 30 cells with q factor > 4000)
392  m_tree->Branch("LArNoisyRO_SatTight",&m_nt_larnoisyro_satTwo,"LArNoisyRO_SatTight/S"); // tight flag (> 20 cells with E>1000MeV and saturated q factor)
393  m_tree->Branch("LArNoisyRO_MNB",&m_nt_larmnbnoisy,"LArNoisyRO_MNB/S");
394  m_tree->Branch("LArNoisyRO_MNB_Sat",&m_nt_larmnbnoisy_sat,"LArNoisyRO_MNB_Sat/S");
395 
396  // Properties of cells with fabs(energy/noise)>3
397  m_tree->Branch("NoisyCellPartitionLayerIndex",&m_nt_cellpartlayerindex);
398  m_tree->Branch("NoisyCellIdentifier",&m_nt_cellIdentifier); // Identifier of the noisy cell
399  m_tree->Branch("NoisyCellOnlineIdentifier",&m_nt_onlIdentifier); // Identifier of the noisy cell
400  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
401  m_tree->Branch("NoisyCellBarrelEc",&m_nt_barrelec_noisy); // BC
402  m_tree->Branch("NoisyCellPosNeg",&m_nt_posneg_noisy); // side
403  m_tree->Branch("NoisyCellFT",&m_nt_ft_noisy); // FT
404  m_tree->Branch("NoisyCellSlot",&m_nt_slot_noisy); // Slot
405  m_tree->Branch("NoisyCellChannel",&m_nt_channel_noisy); // Channel
406  m_tree->Branch("NoisyCellADCvalues", &m_nt_samples); // ADC values
407  m_tree->Branch("NoisyCellGain",&m_nt_gain); // Gain
408  m_tree->Branch("NoisyCellPhi",&m_nt_phicell); // Phi
409  m_tree->Branch("NoisyCellEta",&m_nt_etacell); // Eta
410  m_tree->Branch("NoisyCellLayer", &m_nt_layer); // layer
411  m_tree->Branch("NoisyCellHVphi", &m_nt_noisycellHVphi); // Phi of HV
412  m_tree->Branch("NoisyCellHVeta", &m_nt_noisycellHVeta); // Eta of HV
413  m_tree->Branch("NoisyCellEnergy",&m_nt_energycell); // Energy
414  m_tree->Branch("NoisyCellSignificance",&m_nt_signifcell); // Significance (energy/noise)
415  m_tree->Branch("NoisyCellQFactor",&m_nt_qfactorcell); // Q factor
416  m_tree->Branch("NoisyCellIsBad",&m_nt_isbadcell); // Bad channel status
417  // Event properties related to q factor
418  m_tree->Branch("nbLowQFactor", &m_lowqfactor,"m_lowqfactor/i"); // Nb of cells per event with q factor<1000
419  m_tree->Branch("nbMedQFactor", &m_medqfactor,"m_medqfactor/i"); // Nb of cells per event with 1000<q factor<10000
420  m_tree->Branch("nbHighQFactor", &m_hiqfactor,"m_hiqfactor/i"); // Nb of cells per event with q 10000<factor<65535
421  m_tree->Branch("nbSatQFactor",&m_nb_sat,"nbSat/i"); // Nb of cells per event with saturated q factor (65535)
422  // Properties of cells with q factor saturated
423  m_tree->Branch("SatCellPartition",&m_nt_partition_sat);
424  m_tree->Branch("SatCellBarrelEc",&m_nt_barrelec_sat);
425  m_tree->Branch("SatCellPosNeg",&m_nt_posneg_sat);
426  m_tree->Branch("SatCellFT",&m_nt_ft_sat);
427  m_tree->Branch("SatCellSlot",&m_nt_slot_sat);
428  m_tree->Branch("SatCellChannel",&m_nt_channel_sat);
429  m_tree->Branch("SatCellEnergy",&m_nt_energy_sat);
430  m_tree->Branch("SatCellPhi", &m_nt_phicell_sat);
431  m_tree->Branch("SatCellEta",&m_nt_etacell_sat);
432  m_tree->Branch("SatCellLayer",&m_nt_layer_sat);
433  m_tree->Branch("SatCellIsBad", &m_nt_isbadcell_sat);
434  m_tree->Branch("SatCellOnlineIdentifier",&m_nt_cellIdentifier_sat);
435 
436 
437  ATH_MSG_DEBUG ( "End of Initializing LArNoiseBursts" );
438 
439  return StatusCode::SUCCESS;
440 }

◆ 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() [1/2]

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

Definition at line 24 of file AthCommonMsg.h.

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

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

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

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

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

◆ outputHandles()

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

Return this algorithm's output handles.

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

◆ renounce()

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

Definition at line 380 of file AthCommonDataStore.h.

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

◆ renounceArray()

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

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ sysInitialize()

StatusCode AthAlgorithm::sysInitialize ( )
overridevirtualinherited

Override sysInitialize.

Override sysInitialize from the base class.

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

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

Reimplemented from AthCommonDataStore< AthCommonMsg< Algorithm > >.

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

Definition at line 66 of file AthAlgorithm.cxx.

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

◆ sysStart()

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

Handle START transition.

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

◆ updateVHKA()

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

Definition at line 308 of file AthCommonDataStore.h.

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

Member Data Documentation

◆ m_bcDataKey

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

Definition at line 99 of file LArNoiseBursts.h.

◆ m_BCKey

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

Definition at line 96 of file LArNoiseBursts.h.

◆ m_cablingKey

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

Definition at line 95 of file LArNoiseBursts.h.

◆ 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 111 of file LArNoiseBursts.h.

◆ m_CosmicCaloStream

bool LArNoiseBursts::m_CosmicCaloStream
private

Definition at line 122 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 118 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 123 of file LArNoiseBursts.h.

◆ m_hiqfactor

int LArNoiseBursts::m_hiqfactor
private

Definition at line 130 of file LArNoiseBursts.h.

◆ m_keepOnlyCellID

bool LArNoiseBursts::m_keepOnlyCellID
private

Definition at line 124 of file LArNoiseBursts.h.

◆ m_LArElectrodeIDHelper

const LArElectrodeID* LArNoiseBursts::m_LArElectrodeIDHelper
private

Definition at line 107 of file LArNoiseBursts.h.

◆ m_LArEM_IDHelper

const LArEM_ID* LArNoiseBursts::m_LArEM_IDHelper
private

Definition at line 108 of file LArNoiseBursts.h.

◆ m_LArFCAL_IDHelper

const LArFCAL_ID* LArNoiseBursts::m_LArFCAL_IDHelper
private

Definition at line 109 of file LArNoiseBursts.h.

◆ m_LArHEC_IDHelper

const LArHEC_ID* LArNoiseBursts::m_LArHEC_IDHelper
private

Definition at line 110 of file LArNoiseBursts.h.

◆ m_LArHVLineIDHelper

const LArHVLineID* LArNoiseBursts::m_LArHVLineIDHelper
private

Definition at line 106 of file LArNoiseBursts.h.

◆ m_LArOnlineIDHelper

const LArOnlineID* LArNoiseBursts::m_LArOnlineIDHelper
private

Definition at line 105 of file LArNoiseBursts.h.

◆ m_lowqfactor

int LArNoiseBursts::m_lowqfactor
private

Definition at line 128 of file LArNoiseBursts.h.

◆ m_medqfactor

int LArNoiseBursts::m_medqfactor
private

Definition at line 129 of file LArNoiseBursts.h.

◆ m_nb_sat

int LArNoiseBursts::m_nb_sat
private

Definition at line 127 of file LArNoiseBursts.h.

◆ m_noisycell

long LArNoiseBursts::m_noisycell
private

Definition at line 131 of file LArNoiseBursts.h.

◆ m_nt_atlasready

unsigned int LArNoiseBursts::m_nt_atlasready
private

Definition at line 146 of file LArNoiseBursts.h.

◆ m_nt_barrelec_noisy

std::vector<short> LArNoiseBursts::m_nt_barrelec_noisy
private

Definition at line 221 of file LArNoiseBursts.h.

◆ m_nt_barrelec_sat

std::vector<int> LArNoiseBursts::m_nt_barrelec_sat
private

Definition at line 248 of file LArNoiseBursts.h.

◆ m_nt_bcid

int LArNoiseBursts::m_nt_bcid
private

Definition at line 139 of file LArNoiseBursts.h.

◆ m_nt_bunchtime

float LArNoiseBursts::m_nt_bunchtime
private

Definition at line 145 of file LArNoiseBursts.h.

◆ m_nt_bunchtype

int LArNoiseBursts::m_nt_bunchtype
private

Definition at line 144 of file LArNoiseBursts.h.

◆ m_nt_cellIdentifier

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

Definition at line 227 of file LArNoiseBursts.h.

◆ m_nt_cellIdentifier_sat

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

Definition at line 258 of file LArNoiseBursts.h.

◆ m_nt_cellpartlayerindex

std::vector<short> LArNoiseBursts::m_nt_cellpartlayerindex
private

Definition at line 226 of file LArNoiseBursts.h.

◆ m_nt_cellsize

int LArNoiseBursts::m_nt_cellsize
private

Definition at line 133 of file LArNoiseBursts.h.

◆ m_nt_channel_noisy

std::vector<short> LArNoiseBursts::m_nt_channel_noisy
private

Definition at line 225 of file LArNoiseBursts.h.

◆ m_nt_channel_sat

std::vector<short> LArNoiseBursts::m_nt_channel_sat
private

Definition at line 252 of file LArNoiseBursts.h.

◆ m_nt_ECTimeAvg

float LArNoiseBursts::m_nt_ECTimeAvg
private

Definition at line 209 of file LArNoiseBursts.h.

◆ m_nt_ECTimeDiff

float LArNoiseBursts::m_nt_ECTimeDiff
private

Definition at line 208 of file LArNoiseBursts.h.

◆ m_nt_EF_j100_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j100_u0uchad_LArNoiseBurstT
private

Definition at line 200 of file LArNoiseBursts.h.

◆ m_nt_EF_j130_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j130_u0uchad_LArNoiseBurstT
private

Definition at line 202 of file LArNoiseBursts.h.

◆ m_nt_EF_j165_u0uchad_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurst
private

Definition at line 192 of file LArNoiseBursts.h.

◆ m_nt_EF_j165_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurstT
private

Definition at line 201 of file LArNoiseBursts.h.

◆ m_nt_EF_j30_u0uchad_empty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j30_u0uchad_empty_LArNoiseBurst
private

Definition at line 193 of file LArNoiseBursts.h.

◆ m_nt_EF_j35_u0uchad_empty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j35_u0uchad_empty_LArNoiseBurst
private

Definition at line 203 of file LArNoiseBursts.h.

◆ m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst
private

Definition at line 204 of file LArNoiseBursts.h.

◆ m_nt_EF_j55_u0uchad_empty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j55_u0uchad_empty_LArNoiseBurst
private

Definition at line 195 of file LArNoiseBursts.h.

◆ m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst
private

Definition at line 194 of file LArNoiseBursts.h.

◆ m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT
private

Definition at line 199 of file LArNoiseBursts.h.

◆ m_nt_EF_j80_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j80_u0uchad_LArNoiseBurstT
private

Definition at line 205 of file LArNoiseBursts.h.

◆ m_nt_EF_xe45_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_xe45_LArNoiseBurst
private

Definition at line 196 of file LArNoiseBursts.h.

◆ m_nt_EF_xe55_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_xe55_LArNoiseBurst
private

Definition at line 197 of file LArNoiseBursts.h.

◆ m_nt_EF_xe60_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_xe60_LArNoiseBurst
private

Definition at line 198 of file LArNoiseBursts.h.

◆ m_nt_energy_sat

std::vector<float> LArNoiseBursts::m_nt_energy_sat
private

Definition at line 254 of file LArNoiseBursts.h.

◆ m_nt_energycell

std::vector<float> LArNoiseBursts::m_nt_energycell
private

Definition at line 215 of file LArNoiseBursts.h.

◆ m_nt_etacell

std::vector<float> LArNoiseBursts::m_nt_etacell
private

Definition at line 218 of file LArNoiseBursts.h.

◆ m_nt_etacell_sat

std::vector<float> LArNoiseBursts::m_nt_etacell_sat
private

Definition at line 256 of file LArNoiseBursts.h.

◆ m_nt_evtId

unsigned long LArNoiseBursts::m_nt_evtId
private

Definition at line 135 of file LArNoiseBursts.h.

◆ m_nt_evtTime

int LArNoiseBursts::m_nt_evtTime
private

Definition at line 136 of file LArNoiseBursts.h.

◆ m_nt_evtTime_ns

int LArNoiseBursts::m_nt_evtTime_ns
private

Definition at line 137 of file LArNoiseBursts.h.

◆ m_nt_ft_noisy

std::vector<short> LArNoiseBursts::m_nt_ft_noisy
private

Definition at line 223 of file LArNoiseBursts.h.

◆ m_nt_ft_sat

std::vector<short> LArNoiseBursts::m_nt_ft_sat
private

Definition at line 250 of file LArNoiseBursts.h.

◆ m_nt_gain

std::vector<int> LArNoiseBursts::m_nt_gain
private

Definition at line 233 of file LArNoiseBursts.h.

◆ m_nt_isbadcell

std::vector<int> LArNoiseBursts::m_nt_isbadcell
private

Definition at line 234 of file LArNoiseBursts.h.

◆ m_nt_isbadcell_sat

std::vector<int> LArNoiseBursts::m_nt_isbadcell_sat
private

Definition at line 247 of file LArNoiseBursts.h.

◆ m_nt_isbcidFilled

int LArNoiseBursts::m_nt_isbcidFilled
private

Definition at line 141 of file LArNoiseBursts.h.

◆ m_nt_isbcidInTrain

int LArNoiseBursts::m_nt_isbcidInTrain
private

Definition at line 142 of file LArNoiseBursts.h.

◆ m_nt_isBunchesInFront

std::vector<int> LArNoiseBursts::m_nt_isBunchesInFront
private

Definition at line 143 of file LArNoiseBursts.h.

◆ m_nt_L1_J10_EMPTY

bool LArNoiseBursts::m_nt_L1_J10_EMPTY
private

Definition at line 184 of file LArNoiseBursts.h.

◆ m_nt_L1_J30_EMPTY

bool LArNoiseBursts::m_nt_L1_J30_EMPTY
private

Definition at line 186 of file LArNoiseBursts.h.

◆ m_nt_L1_J30_FIRSTEMPTY

bool LArNoiseBursts::m_nt_L1_J30_FIRSTEMPTY
private

Definition at line 185 of file LArNoiseBursts.h.

◆ m_nt_L1_J75

bool LArNoiseBursts::m_nt_L1_J75
private

Definition at line 183 of file LArNoiseBursts.h.

◆ m_nt_L1_XE40

bool LArNoiseBursts::m_nt_L1_XE40
private

Definition at line 187 of file LArNoiseBursts.h.

◆ m_nt_L1_XE50

bool LArNoiseBursts::m_nt_L1_XE50
private

Definition at line 188 of file LArNoiseBursts.h.

◆ m_nt_L1_XE50_BGRP7

bool LArNoiseBursts::m_nt_L1_XE50_BGRP7
private

Definition at line 189 of file LArNoiseBursts.h.

◆ m_nt_L1_XE70

bool LArNoiseBursts::m_nt_L1_XE70
private

Definition at line 190 of file LArNoiseBursts.h.

◆ m_nt_larcellsize

int LArNoiseBursts::m_nt_larcellsize
private

Definition at line 132 of file LArNoiseBursts.h.

◆ m_nt_larflag_badFEBs

bool LArNoiseBursts::m_nt_larflag_badFEBs
private

Definition at line 175 of file LArNoiseBursts.h.

◆ m_nt_larflag_dataCorrupted

bool LArNoiseBursts::m_nt_larflag_dataCorrupted
private

Definition at line 179 of file LArNoiseBursts.h.

◆ m_nt_larflag_dataCorruptedVeto

bool LArNoiseBursts::m_nt_larflag_dataCorruptedVeto
private

Definition at line 180 of file LArNoiseBursts.h.

◆ m_nt_larflag_mediumSaturatedDQ

bool LArNoiseBursts::m_nt_larflag_mediumSaturatedDQ
private

Definition at line 176 of file LArNoiseBursts.h.

◆ m_nt_larflag_noiseBurstVeto

bool LArNoiseBursts::m_nt_larflag_noiseBurstVeto
private

Definition at line 178 of file LArNoiseBursts.h.

◆ m_nt_larflag_tightSaturatedDQ

bool LArNoiseBursts::m_nt_larflag_tightSaturatedDQ
private

Definition at line 177 of file LArNoiseBursts.h.

◆ m_nt_larmnbnoisy

short LArNoiseBursts::m_nt_larmnbnoisy
private

Definition at line 153 of file LArNoiseBursts.h.

◆ m_nt_larmnbnoisy_sat

short LArNoiseBursts::m_nt_larmnbnoisy_sat
private

Definition at line 154 of file LArNoiseBursts.h.

◆ m_nt_larnoisyro

short LArNoiseBursts::m_nt_larnoisyro
private

Definition at line 150 of file LArNoiseBursts.h.

◆ m_nt_larnoisyro_opt

short LArNoiseBursts::m_nt_larnoisyro_opt
private

Definition at line 151 of file LArNoiseBursts.h.

◆ m_nt_larnoisyro_satTwo

short LArNoiseBursts::m_nt_larnoisyro_satTwo
private

Definition at line 152 of file LArNoiseBursts.h.

◆ m_nt_layer

std::vector<int> LArNoiseBursts::m_nt_layer
private

Definition at line 244 of file LArNoiseBursts.h.

◆ m_nt_layer_sat

std::vector<int> LArNoiseBursts::m_nt_layer_sat
private

Definition at line 257 of file LArNoiseBursts.h.

◆ m_nt_lb

int LArNoiseBursts::m_nt_lb
private

Definition at line 138 of file LArNoiseBursts.h.

◆ m_nt_nCellA

int LArNoiseBursts::m_nt_nCellA
private

Definition at line 210 of file LArNoiseBursts.h.

◆ m_nt_nCellC

int LArNoiseBursts::m_nt_nCellC
private

Definition at line 211 of file LArNoiseBursts.h.

◆ m_nt_noisycellHVeta

std::vector<int> LArNoiseBursts::m_nt_noisycellHVeta
private

Definition at line 231 of file LArNoiseBursts.h.

◆ m_nt_noisycellHVphi

std::vector<int> LArNoiseBursts::m_nt_noisycellHVphi
private

Definition at line 230 of file LArNoiseBursts.h.

◆ m_nt_noisycellpart

std::vector<float> LArNoiseBursts::m_nt_noisycellpart
private

Definition at line 229 of file LArNoiseBursts.h.

◆ m_nt_onlIdentifier

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

Definition at line 228 of file LArNoiseBursts.h.

◆ m_nt_partition

std::vector<int> LArNoiseBursts::m_nt_partition
private

Definition at line 243 of file LArNoiseBursts.h.

◆ m_nt_partition_sat

std::vector<int> LArNoiseBursts::m_nt_partition_sat
private

Definition at line 253 of file LArNoiseBursts.h.

◆ m_nt_phicell

std::vector<float> LArNoiseBursts::m_nt_phicell
private

Definition at line 217 of file LArNoiseBursts.h.

◆ m_nt_phicell_sat

std::vector<float> LArNoiseBursts::m_nt_phicell_sat
private

Definition at line 255 of file LArNoiseBursts.h.

◆ m_nt_posneg_noisy

std::vector<short> LArNoiseBursts::m_nt_posneg_noisy
private

Definition at line 222 of file LArNoiseBursts.h.

◆ m_nt_posneg_sat

std::vector<int> LArNoiseBursts::m_nt_posneg_sat
private

Definition at line 249 of file LArNoiseBursts.h.

◆ m_nt_qfactorcell

std::vector<float> LArNoiseBursts::m_nt_qfactorcell
private

Definition at line 216 of file LArNoiseBursts.h.

◆ m_nt_run

int LArNoiseBursts::m_nt_run
private

Definition at line 134 of file LArNoiseBursts.h.

◆ m_nt_samples

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

Definition at line 232 of file LArNoiseBursts.h.

◆ m_nt_signifcell

std::vector<float> LArNoiseBursts::m_nt_signifcell
private

Definition at line 219 of file LArNoiseBursts.h.

◆ m_nt_slot_noisy

std::vector<short> LArNoiseBursts::m_nt_slot_noisy
private

Definition at line 224 of file LArNoiseBursts.h.

◆ m_nt_slot_sat

std::vector<short> LArNoiseBursts::m_nt_slot_sat
private

Definition at line 251 of file LArNoiseBursts.h.

◆ m_nt_stablebeams

unsigned int LArNoiseBursts::m_nt_stablebeams
private

Definition at line 147 of file LArNoiseBursts.h.

◆ m_nt_streamTagName

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

Definition at line 148 of file LArNoiseBursts.h.

◆ m_nt_streamTagType

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

Definition at line 149 of file LArNoiseBursts.h.

◆ m_sigmacut

double LArNoiseBursts::m_sigmacut
private

Definition at line 121 of file LArNoiseBursts.h.

◆ m_thistSvc

ITHistSvc* LArNoiseBursts::m_thistSvc
private

Definition at line 91 of file LArNoiseBursts.h.

◆ m_totalNoiseKey

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

Definition at line 97 of file LArNoiseBursts.h.

◆ m_tree

TTree* LArNoiseBursts::m_tree
private

Definition at line 93 of file LArNoiseBursts.h.

◆ m_trigDec

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

Definition at line 102 of file LArNoiseBursts.h.

◆ m_varHandleArraysDeclared

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

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

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

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
LArNoiseBursts::m_sigmacut
double m_sigmacut
Definition: LArNoiseBursts.h:121
LArNoiseBursts::m_nt_phicell_sat
std::vector< float > m_nt_phicell_sat
Definition: LArNoiseBursts.h:255
LArNoiseBursts::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArNoiseBursts.h:95
v_phicell
std::vector< float > v_phicell
Definition: LArNoiseBursts.cxx:75
LArNoiseBursts::m_nt_channel_sat
std::vector< short > m_nt_channel_sat
Definition: LArNoiseBursts.h:252
LArNoiseBursts::m_nt_signifcell
std::vector< float > m_nt_signifcell
Definition: LArNoiseBursts.h:219
LArNoiseBursts::m_BCKey
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey
Definition: LArNoiseBursts.h:96
LArNoiseBursts::m_nb_sat
int m_nb_sat
Definition: LArNoiseBursts.h:127
LArNoiseBursts::m_nt_samples
std::vector< std::vector< short > > m_nt_samples
Definition: LArNoiseBursts.h:232
LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurstT
bool m_nt_EF_j165_u0uchad_LArNoiseBurstT
Definition: LArNoiseBursts.h:201
LArNoiseBursts::m_nt_qfactorcell
std::vector< float > m_nt_qfactorcell
Definition: LArNoiseBursts.h:216
LArNoiseBursts::m_nt_partition
std::vector< int > m_nt_partition
Definition: LArNoiseBursts.h:243
LArOnlineID_Base::channel_Hash
IdentifierHash channel_Hash(HWIdentifier channelId) const
Create channel_hash from channel_Id.
Definition: LArOnlineID_Base.cxx:1636
LArNoiseBursts::m_nt_ft_sat
std::vector< short > m_nt_ft_sat
Definition: LArNoiseBursts.h:250
v_isfcal
std::vector< bool > v_isfcal
Definition: LArNoiseBursts.cxx:71
BunchCrossingCondData
Definition: BunchCrossingCondData.h:23
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
LArNoiseBursts::m_nt_atlasready
unsigned int m_nt_atlasready
Definition: LArNoiseBursts.h:146
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:64
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LArNoiseBursts::m_nt_L1_J75
bool m_nt_L1_J75
Definition: LArNoiseBursts.h:183
find
std::string find(const std::string &s)
return a remapped string
Definition: hcg.cxx:135
LArNoiseBursts::m_nt_larflag_dataCorruptedVeto
bool m_nt_larflag_dataCorruptedVeto
Definition: LArNoiseBursts.h:180
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
v_barrelec_noisy
std::vector< short > v_barrelec_noisy
Definition: LArNoiseBursts.cxx:70
AtlasDetectorID::is_lar_fcal
bool is_lar_fcal(Identifier id) const
Definition: AtlasDetectorID.h:839
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
LArNoiseBursts::m_nt_barrelec_noisy
std::vector< short > m_nt_barrelec_noisy
Definition: LArNoiseBursts.h:221
LArCollisionTime
Holds information about collisions timing from end-cap LAr calorimeters.
Definition: LArCollisionTime.h:19
LArFCAL_Base_ID::pos_neg
int pos_neg(const Identifier id) const
pos_neg : +/- 2 (A/C side)
eta
Scalar eta() const
pseudorapidity method
Definition: AmgMatrixBasePlugin.h:79
LArElectrodeID
Helper for the Liquid Argon Calorimeter cell at the electrode level.
Definition: LArElectrodeID.h:101
AthCommonDataStore< AthCommonMsg< Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
LArNoiseBursts::m_medqfactor
int m_medqfactor
Definition: LArNoiseBursts.h:129
v_qfactorcell
std::vector< float > v_qfactorcell
Definition: LArNoiseBursts.cxx:74
LArNoiseBursts::m_nt_streamTagName
std::vector< std::string > m_nt_streamTagName
Definition: LArNoiseBursts.h:148
LArEventBitInfo::MININOISEBURSTTIGHT
@ MININOISEBURSTTIGHT
Definition: LArEventBitInfo.h:18
LArBadXCont
Conditions-Data class holding LAr Bad Channel or Bad Feb information.
Definition: LArBadChannelCont.h:28
LArNoiseBursts::m_nt_onlIdentifier
std::vector< unsigned int > m_nt_onlIdentifier
Definition: LArNoiseBursts.h:228
LArNoiseBursts::m_nt_posneg_noisy
std::vector< short > m_nt_posneg_noisy
Definition: LArNoiseBursts.h:222
CaloDetDescrElement
This class groups all DetDescr information related to a CaloCell. Provides a generic interface for al...
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:66
LArNoiseBursts::m_nt_channel_noisy
std::vector< short > m_nt_channel_noisy
Definition: LArNoiseBursts.h:225
v_cellpartlayerindex
std::vector< int > v_cellpartlayerindex
Definition: LArNoiseBursts.cxx:78
CaloCondBlobAlgs_fillNoiseFromASCII.gain
gain
Definition: CaloCondBlobAlgs_fillNoiseFromASCII.py:110
CaloDetDescrManager_Base::get_element
const CaloDetDescrElement * get_element(const Identifier &cellId) const
get element by its identifier
Definition: CaloDetDescrManager.cxx:159
LArNoiseBursts::m_nt_EF_j130_u0uchad_LArNoiseBurstT
bool m_nt_EF_j130_u0uchad_LArNoiseBurstT
Definition: LArNoiseBursts.h:202
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
LArNoiseBursts::m_nt_evtId
unsigned long m_nt_evtId
Definition: LArNoiseBursts.h:135
LArNoiseBursts::m_nt_energycell
std::vector< float > m_nt_energycell
Definition: LArNoiseBursts.h:215
n_noisy_cell_part
int n_noisy_cell_part[8]
Definition: LArNoiseBursts.cxx:68
LArNoiseBursts::m_nt_bcid
int m_nt_bcid
Definition: LArNoiseBursts.h:139
LArOnlineID_Base::slot
int slot(const HWIdentifier id) const
Return the slot number of a hardware cell identifier: slot = [1,15] Slot-ID in top part of the crat...
Definition: LArOnlineID_Base.cxx:1961
LArNoiseBursts::doLArNoiseBursts
StatusCode doLArNoiseBursts()
Definition: LArNoiseBursts.cxx:942
LArNoiseBursts::m_nt_L1_XE50_BGRP7
bool m_nt_L1_XE50_BGRP7
Definition: LArNoiseBursts.h:189
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
LArEventBitInfo::DATACORRUPTED
@ DATACORRUPTED
Definition: LArEventBitInfo.h:14
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
LArFCAL_Base_ID::module
int module(const Identifier id) const
module [1,3]
LArEventBitInfo::BADFEBS
@ BADFEBS
Definition: LArEventBitInfo.h:10
LArNoiseBursts::m_nt_larmnbnoisy
short m_nt_larmnbnoisy
Definition: LArNoiseBursts.h:153
v_cellIdentifier
std::vector< Identifier > v_cellIdentifier
Definition: LArNoiseBursts.cxx:79
LArNoiseBursts::doEventProperties
StatusCode doEventProperties()
Definition: LArNoiseBursts.cxx:749
LArNoiseBursts::m_nt_L1_XE50
bool m_nt_L1_XE50
Definition: LArNoiseBursts.h:188
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
v_isendcap
std::vector< bool > v_isendcap
Definition: LArNoiseBursts.cxx:71
LArNoiseBursts::m_nt_posneg_sat
std::vector< int > m_nt_posneg_sat
Definition: LArNoiseBursts.h:249
LArNoiseBursts::m_nt_larnoisyro
short m_nt_larnoisyro
Definition: LArNoiseBursts.h:150
v_isbarrel
std::vector< bool > v_isbarrel
Definition: LArNoiseBursts.cxx:71
LArNoiseBursts::m_nt_cellIdentifier
std::vector< unsigned int > m_nt_cellIdentifier
Definition: LArNoiseBursts.h:227
LArNoiseBursts::m_nt_isBunchesInFront
std::vector< int > m_nt_isBunchesInFront
Definition: LArNoiseBursts.h:143
CaloDetDescrElement::is_lar_em_endcap
bool is_lar_em_endcap() const
cell belongs to EM end cap
Definition: CaloDetDescrElement.cxx:106
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
LArNoiseBursts::m_nt_larflag_badFEBs
bool m_nt_larflag_badFEBs
Definition: LArNoiseBursts.h:175
LArNoiseBursts::m_nt_larflag_mediumSaturatedDQ
bool m_nt_larflag_mediumSaturatedDQ
Definition: LArNoiseBursts.h:176
xAOD::EventInfo_v1::timeStampNSOffset
uint32_t timeStampNSOffset() const
Nanosecond time offset wrt. the time stamp.
LArNoiseBursts::m_nt_larflag_tightSaturatedDQ
bool m_nt_larflag_tightSaturatedDQ
Definition: LArNoiseBursts.h:177
LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst
bool m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst
Definition: LArNoiseBursts.h:194
v_onlIdentifier
std::vector< HWIdentifier > v_onlIdentifier
Definition: LArNoiseBursts.cxx:80
CaloNoise::getNoise
float getNoise(const IdentifierHash h, const int gain) const
Accessor by IdentifierHash and gain.
Definition: CaloNoise.h:34
LArNoiseBursts::m_nt_cellIdentifier_sat
std::vector< unsigned int > m_nt_cellIdentifier_sat
Definition: LArNoiseBursts.h:258
LArOnlineID_Base::barrel_ec
int barrel_ec(const HWIdentifier id) const
Return the position barrel or endcap of a hardware cell identifier: barrel_ec = [0,...
Definition: LArOnlineID_Base.cxx:1942
v_noisycellHVeta
std::vector< int > v_noisycellHVeta
Definition: LArNoiseBursts.cxx:73
xAOD::EventInfo_v1::LAr
@ LAr
The LAr calorimeter.
Definition: EventInfo_v1.h:335
LArNoiseBursts::m_nt_L1_XE70
bool m_nt_L1_XE70
Definition: LArNoiseBursts.h:190
LArBadXCont::status
LArBC_t status(const HWIdentifier channel) const
Query the status of a particular channel or FEB This is the main client access method.
LArNoiseBursts::m_totalNoiseKey
SG::ReadCondHandleKey< CaloNoise > m_totalNoiseKey
Definition: LArNoiseBursts.h:98
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
LArNoiseBursts::m_nt_streamTagType
std::vector< std::string > m_nt_streamTagType
Definition: LArNoiseBursts.h:149
LArNoiseBursts::m_LArOnlineIDHelper
const LArOnlineID * m_LArOnlineIDHelper
Definition: LArNoiseBursts.h:105
LArNoiseBursts::m_LArEM_IDHelper
const LArEM_ID * m_LArEM_IDHelper
Definition: LArNoiseBursts.h:108
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
LArNoiseBursts::m_nt_cellsize
int m_nt_cellsize
Definition: LArNoiseBursts.h:133
AthCommonDataStore< AthCommonMsg< Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
LArNoiseBursts::m_nt_nCellA
int m_nt_nCellA
Definition: LArNoiseBursts.h:210
LArNoiseBursts::m_hiqfactor
int m_hiqfactor
Definition: LArNoiseBursts.h:130
LArNoiseBursts::m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst
bool m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst
Definition: LArNoiseBursts.h:204
v_partition
std::vector< int > v_partition
Definition: LArNoiseBursts.cxx:73
LArNoiseBursts::m_nt_ECTimeAvg
float m_nt_ECTimeAvg
Definition: LArNoiseBursts.h:209
LArNoiseBursts::m_nt_larflag_noiseBurstVeto
bool m_nt_larflag_noiseBurstVeto
Definition: LArNoiseBursts.h:178
LArNoiseBursts::m_nt_slot_noisy
std::vector< short > m_nt_slot_noisy
Definition: LArNoiseBursts.h:224
LArNoiseBursts::m_nt_partition_sat
std::vector< int > m_nt_partition_sat
Definition: LArNoiseBursts.h:253
LArCollisionTime::ncellC
int ncellC() const
get number of cells for time C side
Definition: LArCollisionTime.h:33
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
LArEventBitInfo::NOISEBURSTVETO
@ NOISEBURSTVETO
Definition: LArEventBitInfo.h:13
LArNoiseBursts::m_nt_noisycellHVphi
std::vector< int > m_nt_noisycellHVphi
Definition: LArNoiseBursts.h:230
LArOnlineID_Base::channel
int channel(const HWIdentifier id) const
Return the channel number of a hardware cell identifier channel = [0,127] in all FEB.
Definition: LArOnlineID_Base.cxx:1967
LArNoiseBursts::m_nt_etacell_sat
std::vector< float > m_nt_etacell_sat
Definition: LArNoiseBursts.h:256
LArEventBitInfo::TIGHTSATURATEDQ
@ TIGHTSATURATEDQ
Definition: LArEventBitInfo.h:12
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthAlgorithm::sysInitialize
virtual StatusCode sysInitialize() override
Override sysInitialize.
Definition: AthAlgorithm.cxx:66
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
id2
HWIdentifier id2
Definition: LArRodBlockPhysicsV0.cxx:564
LArNoiseBursts::m_nt_EF_xe55_LArNoiseBurst
bool m_nt_EF_xe55_LArNoiseBurst
Definition: LArNoiseBursts.h:197
AthCommonDataStore< AthCommonMsg< Algorithm > >::outputHandles
virtual std::vector< Gaudi::DataHandle * > outputHandles() const override
Return this algorithm's output handles.
LArNoiseBursts::m_nt_L1_XE40
bool m_nt_L1_XE40
Definition: LArNoiseBursts.h:187
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
LArNoiseBursts::m_tree
TTree * m_tree
Definition: LArNoiseBursts.h:93
lumiFormat.i
int i
Definition: lumiFormat.py:92
LArNoiseBursts::m_CosmicCaloStream
bool m_CosmicCaloStream
Definition: LArNoiseBursts.h:122
LArEventBitInfo::MEDIUMSATURATEDQ
@ MEDIUMSATURATEDQ
Definition: LArEventBitInfo.h:11
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LArNoiseBursts::fillCell
StatusCode fillCell(HWIdentifier onlID, float eCalo, float qfactor, CaloGain::CaloGain gain, const LArOnOffIdMapping *cabling, const LArBadChannelCont *bcCont, const CaloNoise &totalNoise, const CaloDetDescrManager *caloMgr)
Definition: LArNoiseBursts.cxx:1176
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
01SubmitToGrid.samples
samples
Definition: 01SubmitToGrid.py:58
LArNoiseBursts::m_nt_EF_xe45_LArNoiseBurst
bool m_nt_EF_xe45_LArNoiseBurst
Definition: LArNoiseBursts.h:196
LArNoiseBursts::m_nt_layer
std::vector< int > m_nt_layer
Definition: LArNoiseBursts.h:244
LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT
bool m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT
Definition: LArNoiseBursts.h:199
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LArNoiseBursts::m_nt_ECTimeDiff
float m_nt_ECTimeDiff
Definition: LArNoiseBursts.h:208
LArNoiseBursts::m_nt_cellpartlayerindex
std::vector< short > m_nt_cellpartlayerindex
Definition: LArNoiseBursts.h:226
LArNoiseBursts::m_nt_EF_j100_u0uchad_LArNoiseBurstT
bool m_nt_EF_j100_u0uchad_LArNoiseBurstT
Definition: LArNoiseBursts.h:200
v_IdHash
std::vector< IdentifierHash > v_IdHash
Definition: LArNoiseBursts.cxx:77
LArEventBitInfo::BADFEBS_W
@ BADFEBS_W
Definition: LArEventBitInfo.h:16
LArNoiseBursts::m_LArElectrodeIDHelper
const LArElectrodeID * m_LArElectrodeIDHelper
Definition: LArNoiseBursts.h:107
BunchCrossingCondData::BunchCrossings
@ BunchCrossings
Distance in units of 25 nanoseconds.
Definition: BunchCrossingCondData.h:132
LArNoiseBursts::m_keepOnlyCellID
bool m_keepOnlyCellID
Definition: LArNoiseBursts.h:124
LArOnlineID_Base::pos_neg
int pos_neg(const HWIdentifier id) const
Return the side of a hardware cell identifier pos_neg = [0,1] positive-side or negative-side Barrel...
Definition: LArOnlineID_Base.cxx:1954
LArNoiseBursts::m_nt_EF_j80_u0uchad_LArNoiseBurstT
bool m_nt_EF_j80_u0uchad_LArNoiseBurstT
Definition: LArNoiseBursts.h:205
LArCollisionTime::timeC
double timeC() const
time C side
Definition: LArCollisionTime.h:45
dumpFileToPlots.treeName
string treeName
Definition: dumpFileToPlots.py:20
v_ishec
std::vector< bool > v_ishec
Definition: LArNoiseBursts.cxx:71
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AtlasDetectorID::is_lar_hec
bool is_lar_hec(Identifier id) const
Definition: AtlasDetectorID.h:829
run
Definition: run.py:1
LArNoiseBursts::m_lowqfactor
int m_lowqfactor
Definition: LArNoiseBursts.h:128
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
CaloDetDescrElement::is_lar_fcal
bool is_lar_fcal() const
cell belongs to FCAL
Definition: CaloDetDescrElement.cxx:138
LArNoiseBursts::GetPartitionLayerIndex
int GetPartitionLayerIndex(const Identifier &id)
Definition: LArNoiseBursts.cxx:1320
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
LArNoiseBursts::m_nt_stablebeams
unsigned int m_nt_stablebeams
Definition: LArNoiseBursts.h:147
LArNoiseBursts::m_nt_noisycellpart
std::vector< float > m_nt_noisycellpart
Definition: LArNoiseBursts.h:229
LArEventBitInfo::MININOISEBURSTLOOSE
@ MININOISEBURSTLOOSE
Definition: LArEventBitInfo.h:17
LArNoiseBursts::m_nt_L1_J30_EMPTY
bool m_nt_L1_J30_EMPTY
Definition: LArNoiseBursts.h:186
BunchCrossingCondData::distanceFromFront
int distanceFromFront(const bcid_type bcid, const BunchDistanceType type=NanoSec) const
The distance of the specific bunch crossing from the front of the train.
Definition: BunchCrossingCondData.cxx:35
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
CaloDetDescrElement::is_tile
bool is_tile() const
cell belongs to Tile
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:442
LArNoiseBursts::m_nt_EF_j55_u0uchad_empty_LArNoiseBurst
bool m_nt_EF_j55_u0uchad_empty_LArNoiseBurst
Definition: LArNoiseBursts.h:195
LArNoiseBursts::m_nt_L1_J10_EMPTY
bool m_nt_L1_J10_EMPTY
Definition: LArNoiseBursts.h:184
v_posneg_noisy
std::vector< short > v_posneg_noisy
Definition: LArNoiseBursts.cxx:70
LArNoiseBursts::m_nt_larcellsize
int m_nt_larcellsize
Definition: LArNoiseBursts.h:132
LArNoiseBursts::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: LArNoiseBursts.h:111
v_noisycellHVphi
std::vector< int > v_noisycellHVphi
Definition: LArNoiseBursts.cxx:73
LArNoiseBursts::m_nt_energy_sat
std::vector< float > m_nt_energy_sat
Definition: LArNoiseBursts.h:254
LArNoiseBursts::m_frontbunches
unsigned int m_frontbunches
Definition: LArNoiseBursts.h:123
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
LArNoiseBursts::m_nt_layer_sat
std::vector< int > m_nt_layer_sat
Definition: LArNoiseBursts.h:257
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
LArNoiseBursts::m_trigDec
PublicToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: LArNoiseBursts.h:102
v_slot_noisy
std::vector< short > v_slot_noisy
Definition: LArNoiseBursts.cxx:70
LArNoiseBursts::m_nt_bunchtype
int m_nt_bunchtype
Definition: LArNoiseBursts.h:144
LArElectrodeID::hv_eta
int hv_eta(const HWIdentifier id) const
Return an integer corresponding to the high volatge eta sector of an hardware electrode identifier.
Definition: LArElectrodeID.h:386
LArEM_Base_ID::barrel_ec
int barrel_ec(const Identifier id) const
return barrel_ec according to :
LArNoiseBursts::doTrigger
StatusCode doTrigger()
methods called by execute()
Definition: LArNoiseBursts.cxx:649
nlarcell
int nlarcell
Definition: LArNoiseBursts.cxx:67
LArNoiseBursts::m_bcDataKey
SG::ReadCondHandleKey< BunchCrossingCondData > m_bcDataKey
Definition: LArNoiseBursts.h:100
v_signifcell
std::vector< float > v_signifcell
Definition: LArNoiseBursts.cxx:74
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArOnlineID
Definition: LArOnlineID.h:20
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
LArNoiseBursts::m_nt_barrelec_sat
std::vector< int > m_nt_barrelec_sat
Definition: LArNoiseBursts.h:248
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
LArNoiseBursts::m_nt_isbadcell
std::vector< int > m_nt_isbadcell
Definition: LArNoiseBursts.h:234
LArNoiseBursts::m_nt_L1_J30_FIRSTEMPTY
bool m_nt_L1_J30_FIRSTEMPTY
Definition: LArNoiseBursts.h:185
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
LArNoiseBursts::m_nt_phicell
std::vector< float > m_nt_phicell
Definition: LArNoiseBursts.h:217
BunchCrossingCondData::isInTrain
bool isInTrain(const bcid_type bcid) const
Function deciding if a given bunch crossing is in a filled train.
Definition: BunchCrossingCondData.h:376
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
xAOD::EventInfo_v1::streamTags
const std::vector< StreamTag > & streamTags() const
Get the streams that the event was put in.
Definition: EventInfo_v1.cxx:283
LArCollisionTime::ncellA
int ncellA() const
get number of cells for time A side
Definition: LArCollisionTime.h:30
CaloGain::LARMEDIUMGAIN
@ LARMEDIUMGAIN
Definition: CaloGain.h:18
AthAlgorithm::m_extendedExtraObjects
DataObjIDColl m_extendedExtraObjects
Definition: AthAlgorithm.h:79
CaloDetDescrElement::is_lar_em_barrel
bool is_lar_em_barrel() const
cell belongs to EM barrel
Definition: CaloDetDescrElement.cxx:98
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx:1948
ReadBchFromCool.good
good
Definition: ReadBchFromCool.py:433
a
TList * a
Definition: liststreamerinfos.cxx:10
LArNoiseBursts::m_nt_evtTime_ns
int m_nt_evtTime_ns
Definition: LArNoiseBursts.h:137
CaloDetDescrElement::getLayer
virtual int getLayer() const
cell layer
Definition: CaloDetDescrElement.cxx:85
h
CaloDetDescrManager
This class provides the client interface for accessing the detector description information common to...
Definition: CaloDetDescrManager.h:473
CaloCell
Data object for each calorimeter readout cell.
Definition: CaloCell.h:57
LArNoiseBursts::m_thistSvc
ITHistSvc * m_thistSvc
Definition: LArNoiseBursts.h:91
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:574
v_etacell
std::vector< float > v_etacell
Definition: LArNoiseBursts.cxx:75
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LArNoiseBursts::m_nt_larnoisyro_satTwo
short m_nt_larnoisyro_satTwo
Definition: LArNoiseBursts.h:152
LArNoiseBursts::m_nt_nCellC
int m_nt_nCellC
Definition: LArNoiseBursts.h:211
LArNoiseBursts::m_nt_etacell
std::vector< float > m_nt_etacell
Definition: LArNoiseBursts.h:218
LArNoiseBursts::m_nt_gain
std::vector< int > m_nt_gain
Definition: LArNoiseBursts.h:233
BunchCrossingCondData::bcType
BunchCrossingType bcType(const bcid_type bcid) const
Convenience function for the type of the specific bunch crossing.
Definition: BunchCrossingCondData.cxx:195
LArNoiseBursts::m_LArHVLineIDHelper
const LArHVLineID * m_LArHVLineIDHelper
Definition: LArNoiseBursts.h:106
LArNoiseBursts::m_nt_run
int m_nt_run
Definition: LArNoiseBursts.h:134
n_cell_part
int n_cell_part[8]
Definition: LArNoiseBursts.cxx:69
LArHEC_Base_ID::sampling
int sampling(const Identifier id) const
return sampling [0,3] (only 0 for supercells)
StateLessPT_NewConfig.partition
partition
Definition: StateLessPT_NewConfig.py:49
v_energycell
std::vector< float > v_energycell
Definition: LArNoiseBursts.cxx:74
LArNoiseBursts::m_nt_larflag_dataCorrupted
bool m_nt_larflag_dataCorrupted
Definition: LArNoiseBursts.h:179
LArNoiseBursts::m_noisycell
long m_noisycell
Definition: LArNoiseBursts.h:131
LArHEC_Base_ID::pos_neg
int pos_neg(const Identifier id) const
return pos_neg -2 (C side) or 2 (A side)
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:616
LArNoiseBursts::m_nt_isbcidFilled
int m_nt_isbcidFilled
Definition: LArNoiseBursts.h:141
LArDigitContainer
Container class for LArDigit.
Definition: LArDigitContainer.h:24
LArElectrodeID::hv_phi
int hv_phi(const HWIdentifier id) const
Return an integer corresponding to the high voltage phi sector of an hardware electrode identifier.
Definition: LArElectrodeID.h:380
xAOD::EventInfo_v1::timeStamp
uint32_t timeStamp() const
POSIX time in seconds from 1970. January 1st.
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
xAOD::EventInfo_v1::isEventFlagBitSet
bool isEventFlagBitSet(EventFlagSubDet subDet, size_t bit) const
Check one particular bit of one particular sub-detector.
Definition: EventInfo_v1.cxx:703
CaloDetDescrElement::eta
float eta() const
cell eta
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:344
AthAlgorithm::AthAlgorithm
AthAlgorithm()
Default constructor:
LArNoiseBursts::m_nt_lb
int m_nt_lb
Definition: LArNoiseBursts.h:138
LArNoiseBursts::m_nt_EF_xe60_LArNoiseBurst
bool m_nt_EF_xe60_LArNoiseBurst
Definition: LArNoiseBursts.h:198
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:790
LArCollisionTime::timeA
double timeA() const
time A side
Definition: LArCollisionTime.h:42
CaloDetDescrElement::phi
float phi() const
cell phi
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:346
LArNoiseBursts::m_LArHEC_IDHelper
const LArHEC_ID * m_LArHEC_IDHelper
Definition: LArNoiseBursts.h:110
LArNoiseBursts::m_nt_isbadcell_sat
std::vector< int > m_nt_isbadcell_sat
Definition: LArNoiseBursts.h:247
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
LArNoiseBursts::m_nt_ft_noisy
std::vector< short > m_nt_ft_noisy
Definition: LArNoiseBursts.h:223
CaloGain::LARLOWGAIN
@ LARLOWGAIN
Definition: CaloGain.h:18
LArEventBitInfo::DATACORRUPTEDVETO
@ DATACORRUPTEDVETO
Definition: LArEventBitInfo.h:15
CaloDetDescrElement::is_lar_hec
bool is_lar_hec() const
cell belongs to HEC
Definition: CaloDetDescrElement.cxx:130
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
LArNoiseBursts::m_nt_EF_j35_u0uchad_empty_LArNoiseBurst
bool m_nt_EF_j35_u0uchad_empty_LArNoiseBurst
Definition: LArNoiseBursts.h:203
LArNoiseBursts::m_nt_isbcidInTrain
int m_nt_isbcidInTrain
Definition: LArNoiseBursts.h:142
v_ft_noisy
std::vector< short > v_ft_noisy
Definition: LArNoiseBursts.cxx:70
v_channel_noisy
std::vector< short > v_channel_noisy
Definition: LArNoiseBursts.cxx:70
AtlasDetectorID::is_lar_em
bool is_lar_em(Identifier id) const
Definition: AtlasDetectorID.h:818
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
LArNoiseBursts::m_nt_larmnbnoisy_sat
short m_nt_larmnbnoisy_sat
Definition: LArNoiseBursts.h:154
LArNoiseBursts::m_nt_bunchtime
float m_nt_bunchtime
Definition: LArNoiseBursts.h:145
LArNoiseBursts::m_nt_evtTime
int m_nt_evtTime
Definition: LArNoiseBursts.h:136
v_isbadcell
std::vector< bool > v_isbadcell
Definition: LArNoiseBursts.cxx:76
LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurst
bool m_nt_EF_j165_u0uchad_LArNoiseBurst
Definition: LArNoiseBursts.h:192
LArNoiseBursts::m_LArFCAL_IDHelper
const LArFCAL_ID * m_LArFCAL_IDHelper
Definition: LArNoiseBursts.h:109
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
LArNoiseBursts::m_nt_larnoisyro_opt
short m_nt_larnoisyro_opt
Definition: LArNoiseBursts.h:151
LArNoiseBursts::m_nt_noisycellHVeta
std::vector< int > m_nt_noisycellHVeta
Definition: LArNoiseBursts.h:231
v_layer
std::vector< short > v_layer
Definition: LArNoiseBursts.cxx:72
BunchCrossingCondData::isFilled
bool isFilled(const bcid_type bcid) const
The simplest query: Is the bunch crossing filled or not?
Definition: BunchCrossingCondData.h:339
fitman.k
k
Definition: fitman.py:528
LArRawChannelContainer
Container for LArRawChannel (IDC using LArRawChannelCollection)
Definition: LArRawChannelContainer.h:26
ServiceHandle< ICondSvc >
LArNoiseBursts::m_nt_slot_sat
std::vector< short > m_nt_slot_sat
Definition: LArNoiseBursts.h:251
LArNoiseBursts::m_nt_EF_j30_u0uchad_empty_LArNoiseBurst
bool m_nt_EF_j30_u0uchad_empty_LArNoiseBurst
Definition: LArNoiseBursts.h:193
LArNoiseBursts::clear
virtual StatusCode clear()
Clear - clear CBNT members.
Definition: LArNoiseBursts.cxx:452
LArHVLineID
Helper for the Liquid Argon Calorimeter High-Voltage identifiers.
Definition: LArHVLineID.h:48
Generated on Fri Jul 5 2024 21:50:53 for ATLAS Offline Software by   doxygen 1.8.18