Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
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 ()=default
 
virtual StatusCode initialize () override
 
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 ()
 
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

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

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

◆ ~LArNoiseBursts()

virtual LArNoiseBursts::~LArNoiseBursts ( )
virtualdefault

Member Function Documentation

◆ clear()

StatusCode LArNoiseBursts::clear ( )
virtual

Clear - clear CBNT members.

For Athena-Aware NTuple

HV branches

Definition at line 377 of file LArNoiseBursts.cxx.

377  {
379 
380  ATH_MSG_DEBUG ( "start clearing variables " );
381 
382  m_nb_sat = 0;
383  m_noisycell = 0;
384  m_lowqfactor = 0;
385  m_medqfactor = 0;
386  m_hiqfactor = 0;
387 
388  m_nt_run = 0;
389  m_nt_evtId = 0;
390  m_nt_evtTime = 0;
391  m_nt_evtTime_ns = 0;
392  m_nt_lb = 0;
393  m_nt_bcid = -1;
394 
395  m_nt_streamTagName.clear();
396  m_nt_streamTagType.clear();
397  m_nt_isbcidFilled = -1;
398  m_nt_isbcidInTrain = -1;
399  m_nt_isBunchesInFront.clear();
400  m_nt_bunchtype = -1;
401  m_nt_bunchtime = -1.0;
402  m_nt_atlasready = -1;
403  m_nt_stablebeams = -1;
404 
405 
406  ATH_MSG_DEBUG ( "clearing LAr event flags " );
407 
408  // lar bit event info
409  m_nt_larflag_badFEBs = false;
410  m_nt_larflag_mediumSaturatedDQ = false;
411  m_nt_larflag_tightSaturatedDQ = false;
412  m_nt_larflag_noiseBurstVeto = false;
413  m_nt_larflag_dataCorrupted = false;
414  m_nt_larflag_dataCorruptedVeto = false;
415  m_nt_larflag_badFEBS_w = false;
416  m_nt_larflag_mnbLoose = false;
417  m_nt_larflag_mnbTight = false;
418  m_nt_larflag_mnbTight_psveto = false;
419  m_nt_larflag_badHVlines = false;
420 
421  m_nt_badHVPartitions = 0;
422  m_nt_badHVlines.clear();
423 
424  ATH_MSG_DEBUG ( "clearing Pixel variables " );
425 
426  // Trigger flags
427  m_nt_L1_J75 = true; // turned on for tests
428  m_nt_L1_J10_EMPTY = false;
429  m_nt_L1_J30_FIRSTEMPTY = false;
430  m_nt_L1_J30_EMPTY = false;
431  m_nt_L1_XE40 = false;
432  m_nt_L1_XE50 = false;
433  m_nt_L1_XE50_BGRP7 = false;
434  m_nt_L1_XE70 = false;
435 
436  m_nt_EF_j165_u0uchad_LArNoiseBurst = false;
437  m_nt_EF_j30_u0uchad_empty_LArNoiseBurst = false;
438  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst = false;
439  m_nt_EF_j55_u0uchad_empty_LArNoiseBurst = false;
440  m_nt_EF_xe45_LArNoiseBurst = false;
441  m_nt_EF_xe55_LArNoiseBurst = false;
442  m_nt_EF_xe60_LArNoiseBurst = false;
443  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT = false;
444  m_nt_EF_j100_u0uchad_LArNoiseBurstT = false;
445  m_nt_EF_j165_u0uchad_LArNoiseBurstT = false;
446  m_nt_EF_j130_u0uchad_LArNoiseBurstT = false;
447  m_nt_EF_j35_u0uchad_empty_LArNoiseBurst = false;
448  m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst = false;
449  m_nt_EF_j80_u0uchad_LArNoiseBurstT = false;
450 
451  ATH_MSG_DEBUG ( "clearing noisy cells variables " );
452 
453  //Quantities for noisy cells
454  m_nt_energycell.clear();
455  m_nt_qfactorcell.clear();
456  m_nt_phicell.clear();
457  m_nt_etacell.clear();
458  m_nt_signifcell.clear();
459  m_nt_isbadcell.clear();
460  m_nt_partition.clear();
461  m_nt_layer.clear();
462  //m_nt_noisycellpercent = -1;
463  m_nt_barrelec_noisy.clear();
464  m_nt_posneg_noisy.clear();
465  m_nt_ft_noisy.clear();
466  m_nt_slot_noisy.clear();
467  m_nt_channel_noisy.clear();
468  m_nt_larcellsize = -1;
469  m_nt_cellsize = -1;
470  m_nt_cellpartlayerindex.clear();
471  m_nt_cellIdentifier.clear();
472  m_nt_onlIdentifier.clear();
473  m_nt_noisycellpart.clear();
474  m_nt_samples.clear();
475  m_nt_gain.clear();
476 
478  m_nt_noisycellHVphi.clear();
479  m_nt_noisycellHVeta.clear();
480 
481  ATH_MSG_DEBUG ( "clearing saturated cell variables " );
482 
483  //clearing quantities for sat cells
484  m_nt_barrelec_sat.clear();
485  m_nt_posneg_sat.clear();
486  m_nt_ft_sat.clear();
487  m_nt_slot_sat.clear();
488  m_nt_channel_sat.clear();
489  m_nt_partition_sat.clear();
490  m_nt_energy_sat.clear();
491  m_nt_phicell_sat.clear();
492  m_nt_etacell_sat.clear();
493  m_nt_layer_sat.clear();
494  m_nt_cellIdentifier_sat.clear();
495  m_nt_isbadcell_sat.clear();
496 
497  ATH_MSG_DEBUG ( "clearing LArTimeDiff variables " );
498 
499  //DiffTime computed with LAR
500  m_nt_ECTimeDiff = 9999;
501  m_nt_ECTimeAvg = 9999;
502  m_nt_nCellA = -1;
503  m_nt_nCellC = -1;
504 
505  return StatusCode::SUCCESS;
506 }

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

655  {
656  ATH_MSG_DEBUG ("in doEventProperties ");
657 
658 
660  // Retrieve event info
661  const xAOD::EventInfo* eventInfo = nullptr;
662  ATH_CHECK( evtStore()->retrieve(eventInfo) );
663 
664  int run = eventInfo->runNumber();
665  m_nt_run = eventInfo->runNumber();
666  m_nt_evtId = eventInfo->eventNumber();
667  m_nt_evtTime = eventInfo->timeStamp();
668  m_nt_evtTime_ns = eventInfo->timeStampNSOffset();
669  m_nt_lb = eventInfo->lumiBlock();
670  m_nt_bcid = eventInfo->bcid();
671 
672  ATH_MSG_DEBUG("Run Number: "<<run<<", event Id "<<m_nt_evtId<<", bcid = "<<m_nt_bcid);
673 
674  SG::ReadCondHandle<BunchCrossingCondData> bccd (m_bcDataKey);
675  const BunchCrossingCondData* bunchCrossing=*bccd;
676  if (!bunchCrossing) {
677  ATH_MSG_ERROR("Failed to retrieve Bunch Crossing obj");
678  return StatusCode::FAILURE;
679  }
680 
681  m_nt_isbcidFilled = bunchCrossing->isFilled(m_nt_bcid);
682  m_nt_isbcidInTrain = bunchCrossing->isInTrain(m_nt_bcid);
683  m_nt_bunchtype = bunchCrossing->bcType(m_nt_bcid);
684  ATH_MSG_DEBUG("BCID is Filled: "<<m_nt_isbcidFilled);
685  ATH_MSG_DEBUG("BCID is in Train: "<<m_nt_isbcidInTrain);
686  ATH_MSG_DEBUG("bunch type "<<m_nt_bunchtype);
687 
688  unsigned int distFromFront = bunchCrossing->distanceFromFront(m_nt_bcid,BunchCrossingCondData::BunchCrossings);
689  if(m_frontbunches < distFromFront) distFromFront=m_frontbunches;
690 
691  bool checkfirstbunch = true;
692  for(unsigned int i=1;i<=distFromFront;i++){
693  bool isFilled=bunchCrossing->isFilled(m_nt_bcid-i);
694  ATH_MSG_DEBUG("bunch "<<i<<" is Filled "<<isFilled);
695  m_nt_isBunchesInFront.push_back(isFilled);
696  if(isFilled){
697  if(i!=1){
698  if(checkfirstbunch){
699  float time = 25.0*i;
700  m_nt_bunchtime = time;
701  ATH_MSG_DEBUG("next bunch time: "<<time<<" ns ");
702  checkfirstbunch = false;
703  }
704  }
705  }
706  }
707 
708  m_CosmicCaloStream = false;
709  //std::vector<TriggerInfo::StreamTag>::const_iterator streamInfoIt=myTriggerInfo->streamTags().begin();
710  //std::vector<TriggerInfo::StreamTag>::const_iterator streamInfoIt_e=myTriggerInfo->streamTags().end();
711  //for (;streamInfoIt!=streamInfoIt_e;streamInfoIt++) {
712  for (const auto& streamInfo : eventInfo->streamTags()) {
713  const std::string& stream_name = streamInfo.name();
714  const std::string& stream_type = streamInfo.type();
715  m_nt_streamTagName.push_back(stream_name);
716  m_nt_streamTagType.push_back(stream_type);
717  ATH_MSG_DEBUG("event stream tag name "<<streamInfo.name());
718  ATH_MSG_DEBUG("event stream tag type "<<streamInfo.type());
719  if(streamInfo.name()=="CosmicCalo" && streamInfo.type()=="physics"){
720  m_CosmicCaloStream = true;
721  }
722  }
723 
724 
725  // LArEventInfo
726 
727  ATH_MSG_DEBUG ("NOISEBURSTVETO bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO) );
728  ATH_MSG_DEBUG ("BADFEBS bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS));
729  ATH_MSG_DEBUG ("TIGHTSATURATEDQ bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ));
730 
731  m_nt_larflag_badFEBs = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS);
732  m_nt_larflag_mediumSaturatedDQ = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MEDIUMSATURATEDQ);
733  m_nt_larflag_tightSaturatedDQ = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ);
734  m_nt_larflag_noiseBurstVeto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO);
735  m_nt_larflag_dataCorrupted = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::DATACORRUPTED);
736  m_nt_larflag_dataCorruptedVeto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::DATACORRUPTEDVETO);
737  m_nt_larflag_badFEBS_w =eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS_W);
738  m_nt_larflag_mnbLoose = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTLOOSE);
739  m_nt_larflag_mnbTight = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTTIGHT);
740  m_nt_larflag_mnbTight_psveto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTTIGHT_PSVETO);
741  m_nt_larflag_badHVlines = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADHVLINES);
742 
743 
745 
746  //const AthenaAttributeList* attrList(0);
747  //ATH_CHECK( evtStore()->retrieve(attrList, "/TDAQ/RunCtrl/DataTakingMode") );
748  //if (attrList != 0) {
749  // ATH_MSG_DEBUG ("ReadyForPhysics is: " << (*attrList)["ReadyForPhysics"].data<uint32_t>());
750  // //m_valueCache = ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
751  // m_nt_atlasready = (*attrList)["ReadyForPhysics"].data<uint32_t>();
752  // }
753 
754  /*const AthenaAttributeList* fillstate(0);
755  sc = evtStore()->retrieve(fillstate, "/LHC/DCS/FILLSTATE");
756  if (sc.isFailure()) {
757  ATH_MSG_WARNING ("Unable to retrieve fillstate information; falling back to" );
758  return StatusCode::SUCCESS;
759  }
760  if (fillstate != 0) {
761  ATH_MSG_DEBUG ("Stable beams is: " << (*fillstate)["StableBeams"].data<uint32_t>());
762  //m_valueCache = ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
763  m_nt_stablebeams.push_back((*fillstate)["StableBeams"].data<uint32_t>());
764  }*/
765 
766 
767  // 29/11/10 : Debug messages removed by BT
768  // mLog << MSG::INFO << "Event LAr flags " << std::hex
769  // << eventInfo->errorState(xAOD::EventInfo::LAr) << " "
770  // << std::hex << eventInfo->eventFlags(xAOD::EventInfo::LAr)
771  // << ", bit 0: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,0)
772  // << ", bit 1: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,1)
773  // << ", bit 2: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,2)
774  // << endmsg;
775 
776  // Retrieve LArCollision Timing information
777  const LArCollisionTime * larTime=nullptr;
778  if (evtStore()->contains<LArCollisionTime>("LArCollisionTime")) {
779  StatusCode sc = evtStore()->retrieve(larTime,"LArCollisionTime");
780  if( sc.isFailure()){
781  ATH_MSG_WARNING ( "Unable to retrieve LArCollisionTime event store" );
782  //return StatusCode::SUCCESS; // Check if failure shd be returned. VB
783  }else {
784  ATH_MSG_DEBUG ( "LArCollisionTime successfully retrieved from event store" );
785  }
786  }
787 
788  if (larTime) {
789  m_nt_nCellA = larTime->ncellA();
790  m_nt_nCellC = larTime->ncellC();
791  if(m_nt_nCellA>0 && m_nt_nCellC>0){
792  // Calculate the time diff between ECC and ECA
793  m_nt_ECTimeDiff = larTime->timeC() - larTime->timeA();
794  m_nt_ECTimeAvg = (larTime->timeC() + larTime->timeA()) * 0.5;
795  ATH_MSG_DEBUG ( "LAr: Calculated time difference of " << m_nt_ECTimeDiff << " ns" );
796  }
797  }
798 
799  return StatusCode::SUCCESS;
800 }

◆ doLArNoiseBursts()

StatusCode LArNoiseBursts::doLArNoiseBursts ( )
private

Definition at line 805 of file LArNoiseBursts.cxx.

805  {
806  ATH_MSG_DEBUG ( "in doLarCellInfo " );
807  const EventContext& ctx = Gaudi::Hive::currentContext();
808 
809  SG::ReadCondHandle<LArOnOffIdMapping> larCablingHdl (m_cablingKey, ctx);
810  const LArOnOffIdMapping* cabling=*larCablingHdl;
811  if(!cabling) {
812  ATH_MSG_WARNING("Do not have cabling info, not storing LarCellInfo ");
813  return StatusCode::SUCCESS;
814  }
815 
816  SG::ReadCondHandle<LArBadChannelCont> bcHdl (m_BCKey, ctx);
817  const LArBadChannelCont* bcCont=*bcHdl;
818  if(!bcCont) {
819  ATH_MSG_WARNING("Do not have bad chan info, not storing LarCellInfo ");
820  return StatusCode::SUCCESS;
821  }
822 
823  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey, ctx};
824  ATH_CHECK(caloMgrHandle.isValid());
825  const CaloDetDescrManager* caloMgr = *caloMgrHandle;
826 
827  // first fill HVline from NoisyROSummary object
828  SG::ReadHandle<LArNoisyROSummary> noisyRO(m_NoisyROKey, ctx);
829  if(noisyRO.isValid()) {
830  auto hwidlist = noisyRO->get_noisy_hvlines();
831  for (auto hw : hwidlist) {
832  m_nt_badHVlines.push_back(hw.get_identifier32().get_compact());
833  }
834  m_nt_badHVPartitions = noisyRO->HVlineFlaggedPartitions();
835  } else {
836  ATH_MSG_WARNING("Do not have LArNoisyROSummary object, no HVlines filled !!");
837  }
838 
839  // Retrieve LAr calocells container
840  // or LArRawChannel container, whatsever available...
841  const CaloCellContainer* caloTES=nullptr;
842  const LArRawChannelContainer* LArTES=nullptr;
843  const LArRawChannelContainer* LArTES_dig=nullptr;
844  if(evtStore()->contains<CaloCellContainer>("AllCalo")) {
845  ATH_CHECK(evtStore()->retrieve( caloTES, "AllCalo"));
846  } else if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels") || evtStore()->contains<LArRawChannelContainer>("LArRawChannels_fB")) {
847  if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels")) {
848  ATH_CHECK(evtStore()->retrieve( LArTES_dig, "LArRawChannels"));
849  }
850  if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels_fB")) {
851  ATH_CHECK(evtStore()->retrieve( LArTES, "LArRawChannels_fB"));
852  }
853  }
854 
855  if (caloTES==nullptr && LArTES==nullptr) {
856  ATH_MSG_WARNING ( "Neither CaloCell nor LArRawChannel Containers found!" );
857  return StatusCode::SUCCESS;
858  }
859 
860  m_nb_sat = 0;
861  m_noisycell =0;
862  nlarcell = 0;
863  v_barrelec_noisy.clear(); v_posneg_noisy.clear();
864  v_ft_noisy.clear();v_slot_noisy.clear();v_channel_noisy.clear();
865  v_isbarrel.clear();v_isendcap.clear();v_isfcal.clear();v_ishec.clear();
866  v_layer.clear();v_partition.clear();v_energycell.clear();v_qfactorcell.clear();
867  v_phicell.clear();v_etacell.clear();v_signifcell.clear();v_isbadcell.clear();
868  v_IdHash.clear();v_noisycellHVeta.clear();v_noisycellHVphi.clear();
869  v_cellpartlayerindex.clear();v_cellIdentifier.clear();v_onlIdentifier.clear();
870 
871  float eCalo;
872  float qfactor;
873  CaloGain::CaloGain gain;
874 
875  SG::ReadCondHandle<CaloNoise> totalNoise (m_totalNoiseKey, ctx);
876 
877  if(caloTES) {
878  for (const CaloCell* cell : *caloTES) {
879  const CaloDetDescrElement* caloDDE = cell->caloDDE();
880  if (caloDDE->is_tile())continue;
881  HWIdentifier onlID;
882  try {onlID = cabling->createSignalChannelID(cell->ID());}
883  catch(LArID_Exception& except) {
884  ATH_MSG_ERROR ( "LArID_Exception " << m_LArEM_IDHelper->show_to_string(cell->ID()) << " " << (std::string) except );
885  ATH_MSG_ERROR ( "LArID_Exception " << m_LArHEC_IDHelper->show_to_string(cell->ID()) );
886  ATH_MSG_ERROR ( "LArID_Exception " << m_LArFCAL_IDHelper->show_to_string(cell->ID()) );
887  continue;
888  }
889  bool connected = cabling->isOnlineConnected(onlID);
890  if(!connected) continue;
891  eCalo = cell->energy();
892  qfactor = cell->quality();
893  gain = cell->gain();
894  //if(qfactor > 0. || cell->ID() == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cell->ID()<<" : "<<eCalo<<" "<<qfactor<<" "<<gain<<" prov.: "<<cell->provenance());
895  ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
896  }//loop over cells
897  ATH_MSG_DEBUG("Done cells "<<nlarcell);
898  } else {
899  std::vector<HWIdentifier> chdone;
900  if (LArTES_dig) {
901  LArRawChannelContainer::const_iterator caloItr;
902  for(caloItr=LArTES_dig->begin();caloItr!=LArTES_dig->end();++caloItr){
903  HWIdentifier onlID=caloItr->identify();
904  bool connected = cabling->isOnlineConnected(onlID);
905  if(!connected) continue;
906  eCalo = caloItr->energy();
907  qfactor = caloItr->quality();
908  gain = caloItr->gain();
909  //if(qfactor>0 || cabling->cnvToIdentifier((*caloItr).identify()) == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cabling->cnvToIdentifier((*caloItr).identify())<<" : "<<eCalo<<" "<<qfactor<<" "<<gain);
910  ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
911  chdone.push_back(onlID);
912  }//loop over raw channels
913  }
914  ATH_MSG_DEBUG("Done raw chan. from digi "<<nlarcell);
915  // dirty hack, if we are already complete:
916  if (nlarcell < 182468 && LArTES) { // add those raw channels, which were not from dig.
917  LArRawChannelContainer::const_iterator caloItr;
918  for(caloItr=LArTES->begin();caloItr!=LArTES->end();++caloItr){
919  HWIdentifier onlID=caloItr->identify();
920  if(std::find(chdone.begin(), chdone.end(), onlID) != chdone.end()) continue;
921  bool connected = cabling->isOnlineConnected(onlID);
922  if(!connected) continue;
923  eCalo = caloItr->energy();
924  qfactor = caloItr->quality();
925  gain = caloItr->gain();
926  //if(qfactor>0 || cabling->cnvToIdentifier((*caloItr).identify()) == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cabling->cnvToIdentifier((*caloItr).identify())<<" : "<<eCalo<<" "<<qfactor<<" "<<gain);
927  ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
928  }//loop over raw channels
929  }
930  ATH_MSG_DEBUG("Done raw chan. "<<nlarcell);
931  } // if raw chanels
932 
933  m_nt_larcellsize = nlarcell;
934  if(caloTES) {
935  m_nt_cellsize = caloTES->size();
936  }
937  else if (LArTES) {
938  m_nt_cellsize = LArTES->size();
939  }
940  ATH_MSG_DEBUG ("lar cell size = "<<int(nlarcell));
941  if(caloTES) ATH_MSG_DEBUG ("all cell size = "<<int(caloTES->size()));
942  else {
943  if(LArTES_dig) ATH_MSG_DEBUG ("all LArRawCh. from digi size = "<<int(LArTES_dig->size()));
944  if(LArTES) ATH_MSG_DEBUG ("all LArRawCh. size = "<<int(LArTES->size()));
945  }
946 
947  //if (nlarcell > 0)
948  // m_nt_noisycellpercent = 100.0*double(n_noisycell)/double(nlarcell);
949  //else
950  // m_nt_noisycellpercent = 0;
951 
952  bool checknoise = false;
953  //ratio of noisy cells per partition
954  for(unsigned int i=0;i<8;i++){
955  float noise = 100.0*(double(n_noisy_cell_part[i])/double(n_cell_part[i]));
956  m_nt_noisycellpart.push_back(noise);
957  if(noise> 1.0){
958  checknoise = true;
959  ATH_MSG_DEBUG ("noise burst in this event ");
960  }
961  }
962 
963  const LArDigitContainer* LArDigitCont=nullptr;
964  if (evtStore()->contains<LArDigitContainer>("FREE")) ATH_CHECK(evtStore()->retrieve( LArDigitCont, "FREE"));
965  if(!LArDigitCont) {
966  if (evtStore()->contains<LArDigitContainer>("LArDigitContainer_Thinned")) ATH_CHECK(evtStore()->retrieve( LArDigitCont, "LArDigitContainer_Thinned"));
967  }
968  if (!LArDigitCont) {
969  ATH_MSG_WARNING ( "LArDigitContainer Container not found!" );
970  return StatusCode::SUCCESS;
971  }
972 
973  bool store_condition = false;
974  // CosmicCalo stream : Store detailed infos of cells only if Y3Sigma>1% or burst found by LArNoisyRO
975  if(m_CosmicCaloStream){
976  if(checknoise==true || m_nt_larflag_badFEBs || m_nt_larflag_tightSaturatedDQ){
977  store_condition = true;
978  }
979  }
980  // Not cosmicCalo stream : Store detailed infos of cells only if burst found by LArNoisyRO
981  if(!m_CosmicCaloStream){
982  if(m_nt_larflag_badFEBs || m_nt_larflag_tightSaturatedDQ){
983  store_condition = true;
984  }
985  }
986 
987  //store the information of the noisy cell only when %noisycells > 1%.
988  if(store_condition){
989  std::vector<short> samples;
990  samples.clear();
991  for(unsigned int k=0;k<v_etacell.size();k++){
992  m_nt_samples.push_back(samples);
993  m_nt_gain.push_back(0);
994  }
995  for (const LArDigit* pLArDigit : *LArDigitCont) {
996  HWIdentifier id2 = pLArDigit->hardwareID();
997  IdentifierHash hashid2 = m_LArOnlineIDHelper->channel_Hash(id2);
998  for(unsigned int j=0;j<v_IdHash.size();j++){
999  if (hashid2 == v_IdHash[j] ){
1000  ATH_MSG_DEBUG ( "find a IdentifierHash of the noisy cell in LArDigit container " );
1001  samples = pLArDigit->samples();
1002  int gain=-1;
1003  if (pLArDigit->gain() == CaloGain::LARHIGHGAIN) gain = 0;
1004  if (pLArDigit->gain() == CaloGain::LARMEDIUMGAIN) gain = 1;
1005  if (pLArDigit->gain() == CaloGain::LARLOWGAIN) gain = 2;
1006  m_nt_gain.at(j)= gain;
1007  m_nt_samples.at(j) = samples;
1008  ATH_MSG_DEBUG ( "I got the samples!" );
1009  break;
1010  }
1011  }
1012  }
1013  for(unsigned int i=0;i<v_etacell.size();i++){
1014  m_nt_energycell.push_back( v_energycell[i]);
1015  m_nt_qfactorcell.push_back( v_qfactorcell[i]);
1016  m_nt_signifcell.push_back( v_signifcell[i]);
1017  m_nt_partition.push_back( v_partition[i]);
1018  m_nt_cellIdentifier.push_back(v_cellIdentifier[i].get_identifier32().get_compact());
1019  m_nt_onlIdentifier.push_back(v_onlIdentifier[i].get_identifier32().get_compact());
1020  if(!m_keepOnlyCellID){
1021  m_nt_barrelec_noisy.push_back( v_barrelec_noisy[i]);
1022  m_nt_posneg_noisy.push_back( v_posneg_noisy[i]);
1023  m_nt_ft_noisy.push_back( v_ft_noisy[i]);
1024  m_nt_slot_noisy.push_back( v_slot_noisy[i]);
1025  m_nt_channel_noisy.push_back( v_channel_noisy[i]);
1026 
1027  /*
1028  m_nt_isbarrel.push_back( v_isbarrel[i]);
1029  m_nt_isendcap.push_back( v_isendcap[i]);
1030  m_nt_isfcal.push_back( v_isfcal[i]);
1031  m_nt_ishec.push_back( v_ishec[i]);
1032  */
1033 
1034  m_nt_layer.push_back( v_layer[i]);
1035  m_nt_phicell.push_back( v_phicell[i]);
1036  m_nt_etacell.push_back( v_etacell[i]);
1037  m_nt_isbadcell.push_back( v_isbadcell[i]);
1038  m_nt_noisycellHVphi.push_back(v_noisycellHVphi[i]);
1039  m_nt_noisycellHVeta.push_back(v_noisycellHVeta[i]);
1040  m_nt_cellpartlayerindex.push_back(v_cellpartlayerindex[i]);
1041  }
1042  }
1043  ATH_MSG_DEBUG ("leaving if checknoise and larnoisyro");
1044 
1045  }//if(checknoisy==true ..)
1046 
1047  return StatusCode::SUCCESS;
1048 
1049 }

◆ doTrigger()

StatusCode LArNoiseBursts::doTrigger ( )
private

methods called by execute()

Definition at line 555 of file LArNoiseBursts.cxx.

555  {
556  ATH_MSG_DEBUG ("in doTrigger ");
557 
558  std::string mychain( "L1_J75" );
559  if( ! m_trigDec->getListOfTriggers(mychain).empty() ){
560  m_nt_L1_J75 = m_trigDec->isPassed( mychain );
561  }
562  mychain = "L1_J10_EMPTY";
563  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
564  m_nt_L1_J10_EMPTY = m_trigDec->isPassed( mychain );
565  }
566  mychain = "L1_J30_FIRSTEMPTY";
567  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
568  m_nt_L1_J30_FIRSTEMPTY = m_trigDec->isPassed( mychain );
569  }
570  mychain = "L1_J30_EMPTY";
571  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
572  m_nt_L1_J30_EMPTY = m_trigDec->isPassed( mychain );
573  }
574  mychain = "L1_XE40";
575  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
576  m_nt_L1_XE40 = m_trigDec->isPassed( mychain );
577  }
578  mychain = "L1_XE50";
579  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
580  m_nt_L1_XE50 = m_trigDec->isPassed( mychain );
581  }
582  mychain = "L1_XE50_BGRP7";
583  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
584  m_nt_L1_XE50_BGRP7 = m_trigDec->isPassed( mychain );
585  }
586  mychain = "L1_XE70";
587  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
588  m_nt_L1_XE70 = m_trigDec->isPassed( mychain );
589  }
590 
591  // EF
592  mychain = "EF_j165_u0uchad_LArNoiseBurst";
593  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
594  m_nt_EF_j165_u0uchad_LArNoiseBurst = m_trigDec->isPassed( mychain );
595  }
596  mychain = "EF_j30_u0uchad_empty_LArNoiseBurst";
597  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
598  m_nt_EF_j30_u0uchad_empty_LArNoiseBurst = m_trigDec->isPassed( mychain );
599  }
600  mychain = "EF_j55_u0uchad_firstempty_LArNoiseBurst";
601  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
602  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst = m_trigDec->isPassed( mychain );
603  }
604  mychain = "EF_j55_u0uchad_empty_LArNoiseBurst";
605  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
606  m_nt_EF_j55_u0uchad_empty_LArNoiseBurst = m_trigDec->isPassed( mychain );
607  }
608  mychain = "EF_xe45_LArNoiseBurst";
609  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
610  m_nt_EF_xe45_LArNoiseBurst = m_trigDec->isPassed( mychain );
611  }
612  mychain = "EF_xe55_LArNoiseBurst";
613  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
614  m_nt_EF_xe55_LArNoiseBurst = m_trigDec->isPassed( mychain );
615  }
616  mychain = "EF_xe60_LArNoiseBurst";
617  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
618  m_nt_EF_xe60_LArNoiseBurst = m_trigDec->isPassed( mychain );
619  }
620  mychain = "EF_j55_u0uchad_firstempty_LArNoiseBurstT";
621  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
622  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT = m_trigDec->isPassed( mychain );
623  }
624  mychain = "EF_j100_u0uchad_LArNoiseBurstT";
625  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
626  m_nt_EF_j100_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
627  }
628  mychain = "EF_j165_u0uchad_LArNoiseBurstT";
629  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
630  m_nt_EF_j165_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
631  }
632  mychain = "EF_j130_u0uchad_LArNoiseBurstT";
633  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
634  m_nt_EF_j130_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
635  }
636  mychain = "EF_j35_u0uchad_empty_LArNoiseBurst";
637  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
638  m_nt_EF_j35_u0uchad_empty_LArNoiseBurst = m_trigDec->isPassed( mychain );
639  }
640  mychain = "EF_j35_u0uchad_firstempty_LArNoiseBurst";
641  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
642  m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst = m_trigDec->isPassed( mychain );
643  }
644  mychain = "EF_j80_u0uchad_LArNoiseBurstT";
645  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
646  m_nt_EF_j80_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
647  }
648 
649  return StatusCode::SUCCESS;
650 }

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

511  {
512  ATH_MSG_DEBUG ( "in execute()" );
513 
514  StatusCode sc = clear();
515  if(sc.isFailure()) {
516  ATH_MSG_WARNING ( "The method clear() failed" );
517  return StatusCode::SUCCESS;
518  }
519 
520  if(!m_trigDec.empty()){
521 
522  sc = doTrigger();
523  if(sc.isFailure()) {
524  ATH_MSG_WARNING ( "The method doTrigger() failed" );
525  return StatusCode::SUCCESS;
526  }
527  }
528 
529  sc = doEventProperties();
530  if(sc.isFailure()) {
531  ATH_MSG_WARNING ( "The method doEventProperties() failed" );
532  return StatusCode::SUCCESS;
533  }
534 
535  sc = doLArNoiseBursts();
536  if (sc.isFailure()) {
537  ATH_MSG_WARNING ( "The method doLArNoiseBursts() failed" );
538  return StatusCode::SUCCESS;
539  }
540 
541 // sc = doPhysicsObjects();
542 // if (sc.isFailure()) {
543 // ATH_MSG_WARNING ( "The method doPhysicsObjects() failed" );
544 // return StatusCode::SUCCESS;
545 // }
546 
547  m_tree->Fill();
548 
549  return StatusCode::SUCCESS;
550 }

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

1059 {
1060  const Identifier idd = cabling->cnvToIdentifier(onlID);
1061  nlarcell++;
1062  IdentifierHash channelHash = m_LArOnlineIDHelper->channel_Hash(onlID);
1063  const CaloDetDescrElement *caloDDE = caloMgr->get_element(idd);
1064  int layer = caloDDE->getLayer();
1065  // CaloCell_ID::CaloSample sampling = (*caloItr)->caloDDE()->getSampling();
1066  float phi = caloDDE->phi();
1067  float noise = totalNoise.getNoise (idd, gain);
1068  float significance = eCalo / noise ;
1069  float eta = caloDDE->eta();
1070  bool badcell = ! (bcCont->status(onlID)).good();
1071  unsigned int partition = 0;
1072  bool is_lar_em_barrel = caloDDE->is_lar_em_barrel();
1073  if(is_lar_em_barrel){
1074  if(eta<0){
1075  partition = 0;
1076  }else{
1077  partition = 1;
1078  }
1079  }//barrel
1080  bool is_lar_em_endcap = caloDDE->is_lar_em_endcap();
1081  if(is_lar_em_endcap){
1082  if(eta<0){
1083  partition = 2;
1084  }else{
1085  partition = 3;
1086  }
1087  }//endcap
1088  bool is_lar_fcal = caloDDE->is_lar_fcal();
1089  if(is_lar_fcal){
1090  if(eta<0){
1091  partition = 4;
1092  }else{
1093  partition = 5;
1094  }
1095  }//fcal
1096  bool is_lar_hec = caloDDE->is_lar_hec();
1097  if(is_lar_hec){
1098  if(eta<0){
1099  partition = 6;
1100  }else{
1101  partition = 7;
1102  }
1103  }//hec
1104  for(unsigned int k=0;k<8;k++){
1105  if(partition==k){
1106  n_cell_part[k]++;
1107  }
1108  }
1109  if(qfactor <1000) {m_lowqfactor++;}
1110  if(qfactor>=1000 && qfactor<10000) {m_medqfactor++;}
1111  if(qfactor>=10000 && qfactor<65535){m_hiqfactor++;}
1112  if(qfactor==65535){
1113  ATH_MSG_DEBUG ("Satured cell at eta: "<<eta<<", phi: "<<phi<<", energy: "<<eCalo<<", partition: "<<partition);
1114  m_nb_sat = m_nb_sat +1;
1115  m_nt_partition_sat.push_back(partition);
1116  m_nt_energy_sat.push_back(eCalo);
1117  m_nt_cellIdentifier_sat.push_back((cabling->cnvToIdentifier(onlID)).get_identifier32().get_compact());
1118  if(!m_keepOnlyCellID){
1119  m_nt_barrelec_sat.push_back(m_LArOnlineIDHelper->barrel_ec(onlID));
1120  m_nt_posneg_sat.push_back(m_LArOnlineIDHelper->pos_neg(onlID));
1121  m_nt_ft_sat.push_back(m_LArOnlineIDHelper->feedthrough(onlID));
1122  m_nt_slot_sat.push_back(m_LArOnlineIDHelper->slot(onlID));
1123  m_nt_channel_sat.push_back(m_LArOnlineIDHelper->channel(onlID));
1124  m_nt_phicell_sat.push_back(phi);
1125  m_nt_etacell_sat.push_back(eta);
1126  m_nt_layer_sat.push_back(layer);
1127  m_nt_isbadcell_sat.push_back(badcell);
1128  }
1129  }
1130  // Store all cells in positive and negative 3 sigma tails...
1131  if(significance > m_sigmacut || qfactor > 4000){
1132  v_barrelec_noisy.push_back(m_LArOnlineIDHelper->barrel_ec(onlID));
1133  v_posneg_noisy.push_back(m_LArOnlineIDHelper->pos_neg(onlID));
1134  v_ft_noisy.push_back(m_LArOnlineIDHelper->feedthrough(onlID));
1135  v_slot_noisy.push_back(m_LArOnlineIDHelper->slot(onlID));
1136  v_channel_noisy.push_back(m_LArOnlineIDHelper->channel(onlID));
1137 
1138  /*
1139  v_isbarrel.push_back(is_lar_em_barrel);
1140  v_isendcap.push_back(is_lar_em_endcap);
1141  v_isfcal.push_back(is_lar_fcal);
1142  v_ishec.push_back(is_lar_hec);
1143  */
1144 
1145  v_layer.push_back(layer);
1146  v_energycell.push_back(eCalo);
1147  v_qfactorcell.push_back(qfactor);
1148  v_phicell.push_back(phi);
1149  v_etacell.push_back(eta);
1150  v_signifcell.push_back(significance);
1151  v_isbadcell.push_back(badcell);
1152  v_partition.push_back(partition);
1153  v_IdHash.push_back(channelHash);
1154  v_cellIdentifier.push_back(cabling->cnvToIdentifier(onlID));
1155  v_onlIdentifier.push_back(onlID);
1156  // ...but count only cells in positive 3 sigma tails!
1157  if (significance > m_sigmacut){
1158  m_noisycell++;
1159  ATH_MSG_DEBUG ("Noisy cell: "<<m_noisycell<<" "<<cabling->cnvToIdentifier(onlID)<<" q: "<<qfactor<<" sign.: "<<significance<<" noise: "<<noise);
1160  for(unsigned int k=0;k<8;k++){
1161  if(partition==k){
1162  n_noisy_cell_part[k]++;
1163  }
1164  }
1165  }
1166  int caloindex = GetPartitionLayerIndex(idd);
1167  v_cellpartlayerindex.push_back(caloindex);
1168  v_noisycellHVphi.push_back(m_LArElectrodeIDHelper->hv_phi(onlID));
1169  v_noisycellHVeta.push_back(m_LArElectrodeIDHelper->hv_eta(onlID));
1170 
1171 
1172  }
1173  return StatusCode::SUCCESS;
1174 }

◆ finalize()

StatusCode LArNoiseBursts::finalize ( )
overridevirtual

Finalize - delete any memory allocation from the heap.

Definition at line 370 of file LArNoiseBursts.cxx.

370  {
371  ATH_MSG_DEBUG ( "in finalize()" );
372  return StatusCode::SUCCESS;
373 }

◆ GetPartitionLayerIndex()

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

Definition at line 1176 of file LArNoiseBursts.cxx.

1177 {
1178  // O.Simard -- GetPartitionLayer index [0,32]:
1179  // Returns a single integer code that corresponds to the
1180  // mapping of CaloCells in CaloMonitoring histogram frames.
1181 
1182  int caloindex = -1;
1183  int bc = 0;
1184  int sampling = 0;
1185 
1186  if(m_LArEM_IDHelper->is_lar_em(id)){ // EMB
1187  bc = m_LArEM_IDHelper->barrel_ec(id);
1188  sampling = m_LArEM_IDHelper->sampling(id);
1189  if(abs(bc)==1){
1190  if(bc<0) caloindex = sampling+4;
1191  else caloindex = sampling;
1192  } else { // EMEC
1193  if(bc<0) caloindex = sampling+12;
1194  else caloindex = sampling+8;
1195  }
1196  } else if(m_LArHEC_IDHelper->is_lar_hec(id)) { // LAr HEC
1197  bc = m_LArHEC_IDHelper->pos_neg(id);
1198  sampling = m_LArHEC_IDHelper->sampling(id);
1199  if(bc<0) caloindex = sampling+20;
1200  else caloindex = sampling+16;
1201  } else if(m_LArFCAL_IDHelper->is_lar_fcal(id)) { // LAr FCAL
1202  bc = m_LArFCAL_IDHelper->pos_neg(id);
1203  sampling = (int)m_LArFCAL_IDHelper->module(id); // module instead of sampling
1204  if(bc<0) caloindex = sampling+26;
1205  else caloindex = sampling+23;
1206  }
1207 
1208  return caloindex;
1209 }

◆ initialize()

StatusCode LArNoiseBursts::initialize ( )
overridevirtual

get a handle on the NTuple and histogramming service

Prepare TTree

NEW Identifier of the cell

Definition at line 200 of file LArNoiseBursts.cxx.

200  {
201 
202  ATH_MSG_DEBUG ( "Initializing LArNoiseBursts" );
203 
204  // Trigger Decision Tool
205  ATH_CHECK( m_trigDec.retrieve() );
206 
207  ATH_CHECK( m_cablingKey.initialize() );
208  ATH_CHECK( m_BCKey.initialize() );
209  ATH_CHECK( m_totalNoiseKey.initialize() );
210  ATH_CHECK( m_bcDataKey.initialize() );
211  ATH_CHECK( m_NoisyROKey.initialize() );
212 
213  // Retrieve online ID helper
214  const LArOnlineID* LArOnlineIDHelper = nullptr;
215  ATH_CHECK( detStore()->retrieve(LArOnlineIDHelper, "LArOnlineID") );
216  m_LArOnlineIDHelper = LArOnlineIDHelper;
217  ATH_MSG_DEBUG( " Found LArOnline Helper");
218 
219  // Retrieve HV line ID helper
220  const LArHVLineID* LArHVLineIDHelper = nullptr;
221  ATH_CHECK( detStore()->retrieve(LArHVLineIDHelper, "LArHVLineID") );
222  m_LArHVLineIDHelper = LArHVLineIDHelper;
223  ATH_MSG_DEBUG( " Found LArOnlineIDHelper Helper");
224 
225  // Retrieve HV electrode ID helper
226  const LArElectrodeID* LArElectrodeIDHelper = nullptr;
227  ATH_CHECK( detStore()->retrieve(LArElectrodeIDHelper, "LArElectrodeID") );
228  m_LArElectrodeIDHelper = LArElectrodeIDHelper;
229  ATH_MSG_DEBUG( " Found LArElectrodeIDHelper Helper");
230 
231  ATH_CHECK(m_caloMgrKey.initialize());
232 
233  // Retrieve ID helpers
234  const CaloCell_ID* idHelper = nullptr;
235  ATH_CHECK( detStore()->retrieve (idHelper, "CaloCell_ID") );
236  m_LArEM_IDHelper = idHelper->em_idHelper();
237  m_LArHEC_IDHelper = idHelper->hec_idHelper();
238  m_LArFCAL_IDHelper = idHelper->fcal_idHelper();
239 
241  ATH_CHECK( m_thistSvc.retrieve() );
242 
244  m_tree = new TTree( "CollectionTree", "CollectionTree" );
245  std::string treeName = "/TTREE/CollectionTree" ;
246  ATH_CHECK( m_thistSvc->regTree(treeName, m_tree) );
247 
248  // General properties of events
249  m_tree->Branch("Run",&m_nt_run,"Run/I");// Event ID
250  m_tree->Branch("EventId",&m_nt_evtId,"EventId/l");// Event ID
251  m_tree->Branch("EventTime",&m_nt_evtTime,"EventTime/I");// Event time
252  m_tree->Branch("EventTime_ns",&m_nt_evtTime_ns,"EventTime_ns/I");// Event time in nanosecond
253  m_tree->Branch("LumiBlock",&m_nt_lb,"LumiBlock/I"); // LB
254  m_tree->Branch("BCID",&m_nt_bcid,"BCID/I"); // BCID
255  m_tree->Branch("StreamTagName",&m_nt_streamTagName);// stream tag name
256  m_tree->Branch("StreamTagType",&m_nt_streamTagType); // stream tag type
257  m_tree->Branch("IsBCIDFilled", &m_nt_isbcidFilled,"IsBCIDFilled/I"); // check if bunch is filled
258  m_tree->Branch("IsBCIDInTrain",&m_nt_isbcidInTrain,"ISBCIDInTrain/I"); // check if bunch belong to a train
259  m_tree->Branch("BunchesInFront",&m_nt_isBunchesInFront); // check front bunches
260  m_tree->Branch("BunchType",&m_nt_bunchtype,"BunchType/I");// Empty = 0, FirstEmpty=1,&middleEmpty=2, Single=100,Front=200,&middle=201,Tail=202
261  m_tree->Branch("TimeAfterBunch",&m_nt_bunchtime,"TimeAfterBunch/F"); //time "distance" between the colliding bunch and the nearest one.
262  m_tree->Branch("ATLASIsReady",&m_nt_atlasready,"AtlasIsReady/I"); //check if atlas is ready for physics
263  m_tree->Branch("StableBeams",&m_nt_stablebeams,"StableBeams/I");//check stablebeams
264 
265  // LAr event bit info
266  m_tree->Branch("larflag_badFEBs",&m_nt_larflag_badFEBs,"larflag_badFEBs/O");
267  m_tree->Branch("larflag_mediumSaturatedDQ",&m_nt_larflag_mediumSaturatedDQ,"larflag_mediumSaturatedDQ/O");
268  m_tree->Branch("larflag_tightSaturatedDQ",&m_nt_larflag_tightSaturatedDQ,"larflag_tightSaturatedDQ/O");
269  m_tree->Branch("larflag_noiseBurstVeto",&m_nt_larflag_noiseBurstVeto,"larflag_noiseBurstVeto/O");
270  m_tree->Branch("larflag_dataCorrupted",&m_nt_larflag_dataCorrupted,"larflag_dataCorrupted/O");
271  m_tree->Branch("larflag_dataCorruptedVeto",&m_nt_larflag_dataCorruptedVeto,"larflag_dataCorruptedVeto/O");
272  m_tree->Branch("larflag_badFEBS_w",&m_nt_larflag_badFEBS_w,"larflag_badFEBS_w/O");
273  m_tree->Branch("larflag_mnbLoose",&m_nt_larflag_mnbLoose,"larflag_mnbLoose/O");
274  m_tree->Branch("larflag_mnbTight",&m_nt_larflag_mnbTight,"larflag_mnbTight/O");
275  m_tree->Branch("larflag_mnbTight_psveto",&m_nt_larflag_mnbTight_psveto,"larflag_mnbTight_psveto/O");
276  m_tree->Branch("larflag_badHVlines",&m_nt_larflag_badHVlines,"larflag_badHVlines/O");
277 
278  m_tree->Branch("badHVlinesPartitions",&m_nt_badHVPartitions,"badHVlinesPartitions/b");
279  // Bad HVlines vector
280  m_tree->Branch("badHVlines",&m_nt_badHVlines);
281 
282  // trigger flags
283  m_tree->Branch("L1_J75",&m_nt_L1_J75,"L1_J75/O");
284  m_tree->Branch("L1_J10_EMPTY",&m_nt_L1_J10_EMPTY,"L1_J10_EMPTY/O");
285  m_tree->Branch("L1_J30_FIRSTEMPTY",&m_nt_L1_J30_FIRSTEMPTY,"L1_J30_FIRSTEMPTY/O");
286  m_tree->Branch("L1_J30_EMPTY",&m_nt_L1_J30_EMPTY,"L1_J30_EMPTY/O");
287  m_tree->Branch("L1_XE40",&m_nt_L1_XE40,"L1_XE40/O");
288  m_tree->Branch("L1_XE50",&m_nt_L1_XE50,"L1_XE50/O");
289  m_tree->Branch("L1_XE50_BGRP7",&m_nt_L1_XE50_BGRP7,"L1_XE50_BGRP7/O");
290  m_tree->Branch("L1_XE70",&m_nt_L1_XE70,"L1_XE70/O");
291 
292  m_tree->Branch("EF_j165_u0uchad_LArNoiseBurst",&m_nt_EF_j165_u0uchad_LArNoiseBurst,"EF_j165_u0uchad_LArNoiseBurst/O");
293  m_tree->Branch("EF_j30_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j30_u0uchad_empty_LArNoiseBurst,"EF_j30_u0uchad_empty_LArNoiseBurst/O");
294  m_tree->Branch("EF_j55_u0uchad_firstempty_LArNoiseBurst",&m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst,"EF_j55_u0uchad_firstempty_LArNoiseBurst/O");
295  m_tree->Branch("EF_j55_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j55_u0uchad_empty_LArNoiseBurst,"EF_j55_u0uchad_empty_LArNoiseBurst/O");
296  m_tree->Branch("EF_xe45_LArNoiseBurst",&m_nt_EF_xe45_LArNoiseBurst,"EF_xe45_LArNoiseBurst/O");
297  m_tree->Branch("EF_xe55_LArNoiseBurst",&m_nt_EF_xe55_LArNoiseBurst,"EF_xe55_LArNoiseBurst/O");
298  m_tree->Branch("EF_xe60_LArNoiseBurst",&m_nt_EF_xe60_LArNoiseBurst,"EF_xe60_LArNoiseBurst/O");
299  m_tree->Branch("EF_j55_u0uchad_firstempty_LArNoiseBurstT",&m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT,"EF_j55_u0uchad_firstempty_LArNoiseBurstT/O");
300  m_tree->Branch("EF_j100_u0uchad_LArNoiseBurstT",&m_nt_EF_j100_u0uchad_LArNoiseBurstT,"EF_j100_u0uchad_LArNoiseBurstT/O");
301  m_tree->Branch("EF_j165_u0uchad_LArNoiseBurstT",&m_nt_EF_j165_u0uchad_LArNoiseBurstT,"EF_j165_u0uchad_LArNoiseBurstT/O");
302  m_tree->Branch("EF_j130_u0uchad_LArNoiseBurstT",&m_nt_EF_j130_u0uchad_LArNoiseBurstT,"EF_j130_u0uchad_LArNoiseBurstT/O");
303  m_tree->Branch("EF_j35_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j35_u0uchad_empty_LArNoiseBurst,"EF_j35_u0uchad_empty_LArNoiseBurst/O");
304  m_tree->Branch("EF_j35_u0uchad_firstempty_LArNoiseBurst",&m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst,"EF_j35_u0uchad_firstempty_LArNoiseBurst/O");
305  m_tree->Branch("EF_j80_u0uchad_LArNoiseBurstT",&m_nt_EF_j80_u0uchad_LArNoiseBurstT,"EF_j80_u0uchad_LArNoiseBurstT/O");
306 
307  //
308  m_tree->Branch("LArCellSize", &m_nt_larcellsize,"LArCellSize/I"); // NEW number of online conected LAr cells
309  m_tree->Branch("CaloCellSize",&m_nt_cellsize,"CaloCellSize/I");// NEW number of total cells.
310  // LAr time difference as computed by LArCollisionTime info
311  m_tree->Branch("LArTime_Diff",&m_nt_ECTimeDiff,"LArTime_Diff/F"); // time diff between 2 endcaps
312  m_tree->Branch("LArTime_Avg",&m_nt_ECTimeAvg,"LArTime_Avg/F"); // time average of 2 endcaps
313  m_tree->Branch("LArTime_nCellA",&m_nt_nCellA,"LArTime_nCellA/I"); // nb of cells used to compute endcap A time
314  m_tree->Branch("LArTime_nCellC",&m_nt_nCellC,"LArTime_nCellC/I"); // nb of cells used to compute endcap C time
315 
316  // Event properties related to yield of channels in 3 sigma tails
317  //m_tree->Branch("PerCentNoisyCell",&m_nt_noisycellpercent,"PerCentNoisyCell/F"); // Yield of channels in 3sigma tails in whole LAr
318  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
319 
320 
321  // Properties of cells with fabs(energy/noise)>3
322  m_tree->Branch("NoisyCellPartitionLayerIndex",&m_nt_cellpartlayerindex);
323  m_tree->Branch("NoisyCellIdentifier",&m_nt_cellIdentifier); // Identifier of the noisy cell
324  m_tree->Branch("NoisyCellOnlineIdentifier",&m_nt_onlIdentifier); // Identifier of the noisy cell
325  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
326  m_tree->Branch("NoisyCellBarrelEc",&m_nt_barrelec_noisy); // BC
327  m_tree->Branch("NoisyCellPosNeg",&m_nt_posneg_noisy); // side
328  m_tree->Branch("NoisyCellFT",&m_nt_ft_noisy); // FT
329  m_tree->Branch("NoisyCellSlot",&m_nt_slot_noisy); // Slot
330  m_tree->Branch("NoisyCellChannel",&m_nt_channel_noisy); // Channel
331  m_tree->Branch("NoisyCellADCvalues", &m_nt_samples); // ADC values
332  m_tree->Branch("NoisyCellGain",&m_nt_gain); // Gain
333  m_tree->Branch("NoisyCellPhi",&m_nt_phicell); // Phi
334  m_tree->Branch("NoisyCellEta",&m_nt_etacell); // Eta
335  m_tree->Branch("NoisyCellLayer", &m_nt_layer); // layer
336  m_tree->Branch("NoisyCellHVphi", &m_nt_noisycellHVphi); // Phi of HV
337  m_tree->Branch("NoisyCellHVeta", &m_nt_noisycellHVeta); // Eta of HV
338  m_tree->Branch("NoisyCellEnergy",&m_nt_energycell); // Energy
339  m_tree->Branch("NoisyCellSignificance",&m_nt_signifcell); // Significance (energy/noise)
340  m_tree->Branch("NoisyCellQFactor",&m_nt_qfactorcell); // Q factor
341  m_tree->Branch("NoisyCellIsBad",&m_nt_isbadcell); // Bad channel status
342  // Event properties related to q factor
343  m_tree->Branch("nbLowQFactor", &m_lowqfactor,"m_lowqfactor/i"); // Nb of cells per event with q factor<1000
344  m_tree->Branch("nbMedQFactor", &m_medqfactor,"m_medqfactor/i"); // Nb of cells per event with 1000<q factor<10000
345  m_tree->Branch("nbHighQFactor", &m_hiqfactor,"m_hiqfactor/i"); // Nb of cells per event with q 10000<factor<65535
346  m_tree->Branch("nbSatQFactor",&m_nb_sat,"nbSat/i"); // Nb of cells per event with saturated q factor (65535)
347  // Properties of cells with q factor saturated
348  m_tree->Branch("SatCellPartition",&m_nt_partition_sat);
349  m_tree->Branch("SatCellBarrelEc",&m_nt_barrelec_sat);
350  m_tree->Branch("SatCellPosNeg",&m_nt_posneg_sat);
351  m_tree->Branch("SatCellFT",&m_nt_ft_sat);
352  m_tree->Branch("SatCellSlot",&m_nt_slot_sat);
353  m_tree->Branch("SatCellChannel",&m_nt_channel_sat);
354  m_tree->Branch("SatCellEnergy",&m_nt_energy_sat);
355  m_tree->Branch("SatCellPhi", &m_nt_phicell_sat);
356  m_tree->Branch("SatCellEta",&m_nt_etacell_sat);
357  m_tree->Branch("SatCellLayer",&m_nt_layer_sat);
358  m_tree->Branch("SatCellIsBad", &m_nt_isbadcell_sat);
359  m_tree->Branch("SatCellOnlineIdentifier",&m_nt_cellIdentifier_sat);
360 
361 
362  ATH_MSG_DEBUG ( "End of Initializing LArNoiseBursts" );
363 
364  return StatusCode::SUCCESS;
365 }

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

◆ m_BCKey

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

Definition at line 94 of file LArNoiseBursts.h.

◆ m_cablingKey

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

Definition at line 93 of file LArNoiseBursts.h.

◆ m_caloMgrKey

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

Definition at line 110 of file LArNoiseBursts.h.

◆ m_CosmicCaloStream

bool LArNoiseBursts::m_CosmicCaloStream
private

Definition at line 121 of file LArNoiseBursts.h.

◆ m_detStore

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

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_elecContainerName

std::string LArNoiseBursts::m_elecContainerName
private

Definition at line 117 of file LArNoiseBursts.h.

◆ m_evtStore

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

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_extendedExtraObjects

DataObjIDColl AthAlgorithm::m_extendedExtraObjects
privateinherited

Definition at line 79 of file AthAlgorithm.h.

◆ m_frontbunches

unsigned int LArNoiseBursts::m_frontbunches
private

Definition at line 122 of file LArNoiseBursts.h.

◆ m_hiqfactor

int LArNoiseBursts::m_hiqfactor
private

Definition at line 129 of file LArNoiseBursts.h.

◆ m_keepOnlyCellID

bool LArNoiseBursts::m_keepOnlyCellID
private

Definition at line 123 of file LArNoiseBursts.h.

◆ m_LArElectrodeIDHelper

const LArElectrodeID* LArNoiseBursts::m_LArElectrodeIDHelper
private

Definition at line 106 of file LArNoiseBursts.h.

◆ m_LArEM_IDHelper

const LArEM_ID* LArNoiseBursts::m_LArEM_IDHelper
private

Definition at line 107 of file LArNoiseBursts.h.

◆ m_LArFCAL_IDHelper

const LArFCAL_ID* LArNoiseBursts::m_LArFCAL_IDHelper
private

Definition at line 108 of file LArNoiseBursts.h.

◆ m_LArHEC_IDHelper

const LArHEC_ID* LArNoiseBursts::m_LArHEC_IDHelper
private

Definition at line 109 of file LArNoiseBursts.h.

◆ m_LArHVLineIDHelper

const LArHVLineID* LArNoiseBursts::m_LArHVLineIDHelper
private

Definition at line 105 of file LArNoiseBursts.h.

◆ m_LArOnlineIDHelper

const LArOnlineID* LArNoiseBursts::m_LArOnlineIDHelper
private

Definition at line 104 of file LArNoiseBursts.h.

◆ m_lowqfactor

int LArNoiseBursts::m_lowqfactor
private

Definition at line 127 of file LArNoiseBursts.h.

◆ m_medqfactor

int LArNoiseBursts::m_medqfactor
private

Definition at line 128 of file LArNoiseBursts.h.

◆ m_nb_sat

int LArNoiseBursts::m_nb_sat
private

Definition at line 126 of file LArNoiseBursts.h.

◆ m_noisycell

long LArNoiseBursts::m_noisycell
private

Definition at line 130 of file LArNoiseBursts.h.

◆ m_NoisyROKey

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

Definition at line 102 of file LArNoiseBursts.h.

◆ m_nt_atlasready

unsigned int LArNoiseBursts::m_nt_atlasready
private

Definition at line 145 of file LArNoiseBursts.h.

◆ m_nt_badHVlines

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

Definition at line 165 of file LArNoiseBursts.h.

◆ m_nt_badHVPartitions

uint8_t LArNoiseBursts::m_nt_badHVPartitions
private

Definition at line 163 of file LArNoiseBursts.h.

◆ m_nt_barrelec_noisy

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

Definition at line 206 of file LArNoiseBursts.h.

◆ m_nt_barrelec_sat

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

Definition at line 226 of file LArNoiseBursts.h.

◆ m_nt_bcid

int LArNoiseBursts::m_nt_bcid
private

Definition at line 138 of file LArNoiseBursts.h.

◆ m_nt_bunchtime

float LArNoiseBursts::m_nt_bunchtime
private

Definition at line 144 of file LArNoiseBursts.h.

◆ m_nt_bunchtype

int LArNoiseBursts::m_nt_bunchtype
private

Definition at line 143 of file LArNoiseBursts.h.

◆ m_nt_cellIdentifier

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

Definition at line 212 of file LArNoiseBursts.h.

◆ m_nt_cellIdentifier_sat

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

Definition at line 236 of file LArNoiseBursts.h.

◆ m_nt_cellpartlayerindex

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

Definition at line 211 of file LArNoiseBursts.h.

◆ m_nt_cellsize

int LArNoiseBursts::m_nt_cellsize
private

Definition at line 132 of file LArNoiseBursts.h.

◆ m_nt_channel_noisy

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

Definition at line 210 of file LArNoiseBursts.h.

◆ m_nt_channel_sat

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

Definition at line 230 of file LArNoiseBursts.h.

◆ m_nt_ECTimeAvg

float LArNoiseBursts::m_nt_ECTimeAvg
private

Definition at line 194 of file LArNoiseBursts.h.

◆ m_nt_ECTimeDiff

float LArNoiseBursts::m_nt_ECTimeDiff
private

Definition at line 193 of file LArNoiseBursts.h.

◆ m_nt_EF_j100_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j100_u0uchad_LArNoiseBurstT
private

Definition at line 185 of file LArNoiseBursts.h.

◆ m_nt_EF_j130_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j130_u0uchad_LArNoiseBurstT
private

Definition at line 187 of file LArNoiseBursts.h.

◆ m_nt_EF_j165_u0uchad_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurst
private

Definition at line 177 of file LArNoiseBursts.h.

◆ m_nt_EF_j165_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurstT
private

Definition at line 186 of file LArNoiseBursts.h.

◆ m_nt_EF_j30_u0uchad_empty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j30_u0uchad_empty_LArNoiseBurst
private

Definition at line 178 of file LArNoiseBursts.h.

◆ m_nt_EF_j35_u0uchad_empty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j35_u0uchad_empty_LArNoiseBurst
private

Definition at line 188 of file LArNoiseBursts.h.

◆ m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst
private

Definition at line 189 of file LArNoiseBursts.h.

◆ m_nt_EF_j55_u0uchad_empty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j55_u0uchad_empty_LArNoiseBurst
private

Definition at line 180 of file LArNoiseBursts.h.

◆ m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst
private

Definition at line 179 of file LArNoiseBursts.h.

◆ m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT
private

Definition at line 184 of file LArNoiseBursts.h.

◆ m_nt_EF_j80_u0uchad_LArNoiseBurstT

bool LArNoiseBursts::m_nt_EF_j80_u0uchad_LArNoiseBurstT
private

Definition at line 190 of file LArNoiseBursts.h.

◆ m_nt_EF_xe45_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_xe45_LArNoiseBurst
private

Definition at line 181 of file LArNoiseBursts.h.

◆ m_nt_EF_xe55_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_xe55_LArNoiseBurst
private

Definition at line 182 of file LArNoiseBursts.h.

◆ m_nt_EF_xe60_LArNoiseBurst

bool LArNoiseBursts::m_nt_EF_xe60_LArNoiseBurst
private

Definition at line 183 of file LArNoiseBursts.h.

◆ m_nt_energy_sat

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

Definition at line 232 of file LArNoiseBursts.h.

◆ m_nt_energycell

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

Definition at line 200 of file LArNoiseBursts.h.

◆ m_nt_etacell

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

Definition at line 203 of file LArNoiseBursts.h.

◆ m_nt_etacell_sat

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

Definition at line 234 of file LArNoiseBursts.h.

◆ m_nt_evtId

unsigned long LArNoiseBursts::m_nt_evtId
private

Definition at line 134 of file LArNoiseBursts.h.

◆ m_nt_evtTime

int LArNoiseBursts::m_nt_evtTime
private

Definition at line 135 of file LArNoiseBursts.h.

◆ m_nt_evtTime_ns

int LArNoiseBursts::m_nt_evtTime_ns
private

Definition at line 136 of file LArNoiseBursts.h.

◆ m_nt_ft_noisy

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

Definition at line 208 of file LArNoiseBursts.h.

◆ m_nt_ft_sat

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

Definition at line 228 of file LArNoiseBursts.h.

◆ m_nt_gain

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

Definition at line 218 of file LArNoiseBursts.h.

◆ m_nt_isbadcell

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

Definition at line 219 of file LArNoiseBursts.h.

◆ m_nt_isbadcell_sat

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

Definition at line 225 of file LArNoiseBursts.h.

◆ m_nt_isbcidFilled

int LArNoiseBursts::m_nt_isbcidFilled
private

Definition at line 140 of file LArNoiseBursts.h.

◆ m_nt_isbcidInTrain

int LArNoiseBursts::m_nt_isbcidInTrain
private

Definition at line 141 of file LArNoiseBursts.h.

◆ m_nt_isBunchesInFront

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

Definition at line 142 of file LArNoiseBursts.h.

◆ m_nt_L1_J10_EMPTY

bool LArNoiseBursts::m_nt_L1_J10_EMPTY
private

Definition at line 169 of file LArNoiseBursts.h.

◆ m_nt_L1_J30_EMPTY

bool LArNoiseBursts::m_nt_L1_J30_EMPTY
private

Definition at line 171 of file LArNoiseBursts.h.

◆ m_nt_L1_J30_FIRSTEMPTY

bool LArNoiseBursts::m_nt_L1_J30_FIRSTEMPTY
private

Definition at line 170 of file LArNoiseBursts.h.

◆ m_nt_L1_J75

bool LArNoiseBursts::m_nt_L1_J75
private

Definition at line 168 of file LArNoiseBursts.h.

◆ m_nt_L1_XE40

bool LArNoiseBursts::m_nt_L1_XE40
private

Definition at line 172 of file LArNoiseBursts.h.

◆ m_nt_L1_XE50

bool LArNoiseBursts::m_nt_L1_XE50
private

Definition at line 173 of file LArNoiseBursts.h.

◆ m_nt_L1_XE50_BGRP7

bool LArNoiseBursts::m_nt_L1_XE50_BGRP7
private

Definition at line 174 of file LArNoiseBursts.h.

◆ m_nt_L1_XE70

bool LArNoiseBursts::m_nt_L1_XE70
private

Definition at line 175 of file LArNoiseBursts.h.

◆ m_nt_larcellsize

int LArNoiseBursts::m_nt_larcellsize
private

Definition at line 131 of file LArNoiseBursts.h.

◆ m_nt_larflag_badFEBs

bool LArNoiseBursts::m_nt_larflag_badFEBs
private

Definition at line 151 of file LArNoiseBursts.h.

◆ m_nt_larflag_badFEBS_w

bool LArNoiseBursts::m_nt_larflag_badFEBS_w
private

Definition at line 157 of file LArNoiseBursts.h.

◆ m_nt_larflag_badHVlines

bool LArNoiseBursts::m_nt_larflag_badHVlines
private

Definition at line 161 of file LArNoiseBursts.h.

◆ m_nt_larflag_dataCorrupted

bool LArNoiseBursts::m_nt_larflag_dataCorrupted
private

Definition at line 155 of file LArNoiseBursts.h.

◆ m_nt_larflag_dataCorruptedVeto

bool LArNoiseBursts::m_nt_larflag_dataCorruptedVeto
private

Definition at line 156 of file LArNoiseBursts.h.

◆ m_nt_larflag_mediumSaturatedDQ

bool LArNoiseBursts::m_nt_larflag_mediumSaturatedDQ
private

Definition at line 152 of file LArNoiseBursts.h.

◆ m_nt_larflag_mnbLoose

bool LArNoiseBursts::m_nt_larflag_mnbLoose
private

Definition at line 158 of file LArNoiseBursts.h.

◆ m_nt_larflag_mnbTight

bool LArNoiseBursts::m_nt_larflag_mnbTight
private

Definition at line 159 of file LArNoiseBursts.h.

◆ m_nt_larflag_mnbTight_psveto

bool LArNoiseBursts::m_nt_larflag_mnbTight_psveto
private

Definition at line 160 of file LArNoiseBursts.h.

◆ m_nt_larflag_noiseBurstVeto

bool LArNoiseBursts::m_nt_larflag_noiseBurstVeto
private

Definition at line 154 of file LArNoiseBursts.h.

◆ m_nt_larflag_tightSaturatedDQ

bool LArNoiseBursts::m_nt_larflag_tightSaturatedDQ
private

Definition at line 153 of file LArNoiseBursts.h.

◆ m_nt_layer

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

Definition at line 222 of file LArNoiseBursts.h.

◆ m_nt_layer_sat

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

Definition at line 235 of file LArNoiseBursts.h.

◆ m_nt_lb

int LArNoiseBursts::m_nt_lb
private

Definition at line 137 of file LArNoiseBursts.h.

◆ m_nt_nCellA

int LArNoiseBursts::m_nt_nCellA
private

Definition at line 195 of file LArNoiseBursts.h.

◆ m_nt_nCellC

int LArNoiseBursts::m_nt_nCellC
private

Definition at line 196 of file LArNoiseBursts.h.

◆ m_nt_noisycellHVeta

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

Definition at line 216 of file LArNoiseBursts.h.

◆ m_nt_noisycellHVphi

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

Definition at line 215 of file LArNoiseBursts.h.

◆ m_nt_noisycellpart

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

Definition at line 214 of file LArNoiseBursts.h.

◆ m_nt_onlIdentifier

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

Definition at line 213 of file LArNoiseBursts.h.

◆ m_nt_partition

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

Definition at line 221 of file LArNoiseBursts.h.

◆ m_nt_partition_sat

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

Definition at line 231 of file LArNoiseBursts.h.

◆ m_nt_phicell

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

Definition at line 202 of file LArNoiseBursts.h.

◆ m_nt_phicell_sat

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

Definition at line 233 of file LArNoiseBursts.h.

◆ m_nt_posneg_noisy

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

Definition at line 207 of file LArNoiseBursts.h.

◆ m_nt_posneg_sat

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

Definition at line 227 of file LArNoiseBursts.h.

◆ m_nt_qfactorcell

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

Definition at line 201 of file LArNoiseBursts.h.

◆ m_nt_run

int LArNoiseBursts::m_nt_run
private

Definition at line 133 of file LArNoiseBursts.h.

◆ m_nt_samples

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

Definition at line 217 of file LArNoiseBursts.h.

◆ m_nt_signifcell

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

Definition at line 204 of file LArNoiseBursts.h.

◆ m_nt_slot_noisy

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

Definition at line 209 of file LArNoiseBursts.h.

◆ m_nt_slot_sat

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

Definition at line 229 of file LArNoiseBursts.h.

◆ m_nt_stablebeams

unsigned int LArNoiseBursts::m_nt_stablebeams
private

Definition at line 146 of file LArNoiseBursts.h.

◆ m_nt_streamTagName

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

Definition at line 147 of file LArNoiseBursts.h.

◆ m_nt_streamTagType

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

Definition at line 148 of file LArNoiseBursts.h.

◆ m_sigmacut

double LArNoiseBursts::m_sigmacut
private

Definition at line 120 of file LArNoiseBursts.h.

◆ m_thistSvc

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

Definition at line 89 of file LArNoiseBursts.h.

◆ m_totalNoiseKey

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

Definition at line 95 of file LArNoiseBursts.h.

◆ m_tree

TTree* LArNoiseBursts::m_tree
private

Definition at line 91 of file LArNoiseBursts.h.

◆ m_trigDec

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

Definition at line 100 of file LArNoiseBursts.h.

◆ 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:120
LArNoiseBursts::m_nt_phicell_sat
std::vector< float > m_nt_phicell_sat
Definition: LArNoiseBursts.h:233
LArNoiseBursts::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArNoiseBursts.h:93
v_phicell
std::vector< float > v_phicell
Definition: LArNoiseBursts.cxx:73
LArNoiseBursts::m_nt_channel_sat
std::vector< short > m_nt_channel_sat
Definition: LArNoiseBursts.h:230
LArNoiseBursts::m_nt_signifcell
std::vector< float > m_nt_signifcell
Definition: LArNoiseBursts.h:204
LArNoiseBursts::m_BCKey
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey
Definition: LArNoiseBursts.h:94
LArNoiseBursts::m_nb_sat
int m_nb_sat
Definition: LArNoiseBursts.h:126
LArNoiseBursts::m_nt_samples
std::vector< std::vector< short > > m_nt_samples
Definition: LArNoiseBursts.h:217
LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurstT
bool m_nt_EF_j165_u0uchad_LArNoiseBurstT
Definition: LArNoiseBursts.h:186
LArNoiseBursts::m_nt_qfactorcell
std::vector< float > m_nt_qfactorcell
Definition: LArNoiseBursts.h:201
LArNoiseBursts::m_nt_partition
std::vector< int > m_nt_partition
Definition: LArNoiseBursts.h:221
LArOnlineID_Base::channel_Hash
IdentifierHash channel_Hash(HWIdentifier channelId) const
Create channel_hash from channel_Id.
Definition: LArOnlineID_Base.cxx:1632
LArNoiseBursts::m_nt_ft_sat
std::vector< short > m_nt_ft_sat
Definition: LArNoiseBursts.h:228
v_isfcal
std::vector< bool > v_isfcal
Definition: LArNoiseBursts.cxx:69
BunchCrossingCondData
Definition: BunchCrossingCondData.h:23
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
LArNoiseBursts::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: LArNoiseBursts.h:89
LArNoiseBursts::m_nt_atlasready
unsigned int m_nt_atlasready
Definition: LArNoiseBursts.h:145
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LArNoiseBursts::m_nt_larflag_mnbTight
bool m_nt_larflag_mnbTight
Definition: LArNoiseBursts.h:159
LArNoiseBursts::m_nt_L1_J75
bool m_nt_L1_J75
Definition: LArNoiseBursts.h:168
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:156
v_barrelec_noisy
std::vector< short > v_barrelec_noisy
Definition: LArNoiseBursts.cxx:68
AtlasDetectorID::is_lar_fcal
bool is_lar_fcal(Identifier id) const
Definition: AtlasDetectorID.h:839
LArNoiseBursts::m_nt_barrelec_noisy
std::vector< short > m_nt_barrelec_noisy
Definition: LArNoiseBursts.h:206
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:83
LArElectrodeID
Helper for the Liquid Argon Calorimeter cell at the electrode level.
Definition: LArElectrodeID.h:101
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
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:128
v_qfactorcell
std::vector< float > v_qfactorcell
Definition: LArNoiseBursts.cxx:72
LArNoiseBursts::m_nt_streamTagName
std::vector< std::string > m_nt_streamTagName
Definition: LArNoiseBursts.h:147
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:213
LArNoiseBursts::m_nt_posneg_noisy
std::vector< short > m_nt_posneg_noisy
Definition: LArNoiseBursts.h:207
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:210
v_cellpartlayerindex
std::vector< int > v_cellpartlayerindex
Definition: LArNoiseBursts.cxx:76
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:187
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
LArNoiseBursts::m_nt_evtId
unsigned long m_nt_evtId
Definition: LArNoiseBursts.h:134
LArEventBitInfo::BADHVLINES
@ BADHVLINES
Definition: LArEventBitInfo.h:20
LArNoiseBursts::m_nt_energycell
std::vector< float > m_nt_energycell
Definition: LArNoiseBursts.h:200
n_noisy_cell_part
int n_noisy_cell_part[8]
Definition: LArNoiseBursts.cxx:66
LArNoiseBursts::m_nt_bcid
int m_nt_bcid
Definition: LArNoiseBursts.h:138
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:1957
LArNoiseBursts::doLArNoiseBursts
StatusCode doLArNoiseBursts()
Definition: LArNoiseBursts.cxx:805
LArNoiseBursts::m_nt_L1_XE50_BGRP7
bool m_nt_L1_XE50_BGRP7
Definition: LArNoiseBursts.h:174
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
v_cellIdentifier
std::vector< Identifier > v_cellIdentifier
Definition: LArNoiseBursts.cxx:77
LArNoiseBursts::doEventProperties
StatusCode doEventProperties()
Definition: LArNoiseBursts.cxx:655
LArNoiseBursts::m_nt_L1_XE50
bool m_nt_L1_XE50
Definition: LArNoiseBursts.h:173
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
v_isendcap
std::vector< bool > v_isendcap
Definition: LArNoiseBursts.cxx:69
LArNoiseBursts::m_nt_posneg_sat
std::vector< int > m_nt_posneg_sat
Definition: LArNoiseBursts.h:227
v_isbarrel
std::vector< bool > v_isbarrel
Definition: LArNoiseBursts.cxx:69
LArNoiseBursts::m_nt_cellIdentifier
std::vector< unsigned int > m_nt_cellIdentifier
Definition: LArNoiseBursts.h:212
LArNoiseBursts::m_nt_isBunchesInFront
std::vector< int > m_nt_isBunchesInFront
Definition: LArNoiseBursts.h:142
CaloDetDescrElement::is_lar_em_endcap
bool is_lar_em_endcap() const
cell belongs to EM end cap
Definition: CaloDetDescrElement.cxx:105
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
LArNoiseBursts::m_nt_larflag_badFEBs
bool m_nt_larflag_badFEBs
Definition: LArNoiseBursts.h:151
LArNoiseBursts::m_nt_larflag_mediumSaturatedDQ
bool m_nt_larflag_mediumSaturatedDQ
Definition: LArNoiseBursts.h:152
LArNoiseBursts::m_nt_larflag_tightSaturatedDQ
bool m_nt_larflag_tightSaturatedDQ
Definition: LArNoiseBursts.h:153
LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst
bool m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst
Definition: LArNoiseBursts.h:179
v_onlIdentifier
std::vector< HWIdentifier > v_onlIdentifier
Definition: LArNoiseBursts.cxx:78
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:236
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:1938
v_noisycellHVeta
std::vector< int > v_noisycellHVeta
Definition: LArNoiseBursts.cxx:71
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:175
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:96
LArNoiseBursts::m_nt_streamTagType
std::vector< std::string > m_nt_streamTagType
Definition: LArNoiseBursts.h:148
LArNoiseBursts::m_LArOnlineIDHelper
const LArOnlineID * m_LArOnlineIDHelper
Definition: LArNoiseBursts.h:104
LArNoiseBursts::m_LArEM_IDHelper
const LArEM_ID * m_LArEM_IDHelper
Definition: LArNoiseBursts.h:107
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
LArNoiseBursts::m_nt_cellsize
int m_nt_cellsize
Definition: LArNoiseBursts.h:132
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:195
LArNoiseBursts::m_hiqfactor
int m_hiqfactor
Definition: LArNoiseBursts.h:129
LArNoiseBursts::m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst
bool m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst
Definition: LArNoiseBursts.h:189
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
v_partition
std::vector< int > v_partition
Definition: LArNoiseBursts.cxx:71
LArNoiseBursts::m_nt_ECTimeAvg
float m_nt_ECTimeAvg
Definition: LArNoiseBursts.h:194
LArNoiseBursts::m_nt_badHVPartitions
uint8_t m_nt_badHVPartitions
Definition: LArNoiseBursts.h:163
LArNoiseBursts::m_nt_larflag_noiseBurstVeto
bool m_nt_larflag_noiseBurstVeto
Definition: LArNoiseBursts.h:154
LArNoiseBursts::m_nt_slot_noisy
std::vector< short > m_nt_slot_noisy
Definition: LArNoiseBursts.h:209
LArNoiseBursts::m_nt_partition_sat
std::vector< int > m_nt_partition_sat
Definition: LArNoiseBursts.h:231
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_larflag_mnbTight_psveto
bool m_nt_larflag_mnbTight_psveto
Definition: LArNoiseBursts.h:160
LArNoiseBursts::m_nt_noisycellHVphi
std::vector< int > m_nt_noisycellHVphi
Definition: LArNoiseBursts.h:215
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:1963
LArNoiseBursts::m_nt_etacell_sat
std::vector< float > m_nt_etacell_sat
Definition: LArNoiseBursts.h:234
LArEventBitInfo::TIGHTSATURATEDQ
@ TIGHTSATURATEDQ
Definition: LArEventBitInfo.h:12
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
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
LArEventBitInfo::MININOISEBURSTTIGHT_PSVETO
@ MININOISEBURSTTIGHT_PSVETO
Definition: LArEventBitInfo.h:19
id2
HWIdentifier id2
Definition: LArRodBlockPhysicsV0.cxx:562
LArNoiseBursts::m_nt_EF_xe55_LArNoiseBurst
bool m_nt_EF_xe55_LArNoiseBurst
Definition: LArNoiseBursts.h:182
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:172
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
LArNoiseBursts::m_tree
TTree * m_tree
Definition: LArNoiseBursts.h:91
lumiFormat.i
int i
Definition: lumiFormat.py:85
LArNoiseBursts::m_CosmicCaloStream
bool m_CosmicCaloStream
Definition: LArNoiseBursts.h:121
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:1051
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
LArNoiseBursts::m_nt_EF_xe45_LArNoiseBurst
bool m_nt_EF_xe45_LArNoiseBurst
Definition: LArNoiseBursts.h:181
LArNoiseBursts::m_nt_layer
std::vector< int > m_nt_layer
Definition: LArNoiseBursts.h:222
LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT
bool m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT
Definition: LArNoiseBursts.h:184
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LArNoiseBursts::m_nt_ECTimeDiff
float m_nt_ECTimeDiff
Definition: LArNoiseBursts.h:193
LArNoiseBursts::m_nt_cellpartlayerindex
std::vector< short > m_nt_cellpartlayerindex
Definition: LArNoiseBursts.h:211
LArNoiseBursts::m_nt_EF_j100_u0uchad_LArNoiseBurstT
bool m_nt_EF_j100_u0uchad_LArNoiseBurstT
Definition: LArNoiseBursts.h:185
python.LArMinBiasAlgConfig.int
int
Definition: LArMinBiasAlgConfig.py:59
LArNoiseBursts::m_nt_larflag_badFEBS_w
bool m_nt_larflag_badFEBS_w
Definition: LArNoiseBursts.h:157
v_IdHash
std::vector< IdentifierHash > v_IdHash
Definition: LArNoiseBursts.cxx:75
LArEventBitInfo::BADFEBS_W
@ BADFEBS_W
Definition: LArEventBitInfo.h:16
LArNoiseBursts::m_LArElectrodeIDHelper
const LArElectrodeID * m_LArElectrodeIDHelper
Definition: LArNoiseBursts.h:106
BunchCrossingCondData::BunchCrossings
@ BunchCrossings
Distance in units of 25 nanoseconds.
Definition: BunchCrossingCondData.h:132
LArNoiseBursts::m_keepOnlyCellID
bool m_keepOnlyCellID
Definition: LArNoiseBursts.h:123
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:1950
LArNoiseBursts::m_nt_EF_j80_u0uchad_LArNoiseBurstT
bool m_nt_EF_j80_u0uchad_LArNoiseBurstT
Definition: LArNoiseBursts.h:190
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:69
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:127
AthCommonDataStore< AthCommonMsg< Algorithm > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
CaloDetDescrElement::is_lar_fcal
bool is_lar_fcal() const
cell belongs to FCAL
Definition: CaloDetDescrElement.cxx:137
LArNoiseBursts::GetPartitionLayerIndex
int GetPartitionLayerIndex(const Identifier &id)
Definition: LArNoiseBursts.cxx:1176
LArNoiseBursts::m_nt_stablebeams
unsigned int m_nt_stablebeams
Definition: LArNoiseBursts.h:146
LArNoiseBursts::m_nt_noisycellpart
std::vector< float > m_nt_noisycellpart
Definition: LArNoiseBursts.h:214
LArEventBitInfo::MININOISEBURSTLOOSE
@ MININOISEBURSTLOOSE
Definition: LArEventBitInfo.h:17
LArNoiseBursts::m_nt_L1_J30_EMPTY
bool m_nt_L1_J30_EMPTY
Definition: LArNoiseBursts.h:171
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:38
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:180
LArNoiseBursts::m_nt_L1_J10_EMPTY
bool m_nt_L1_J10_EMPTY
Definition: LArNoiseBursts.h:169
v_posneg_noisy
std::vector< short > v_posneg_noisy
Definition: LArNoiseBursts.cxx:68
LArNoiseBursts::m_nt_larcellsize
int m_nt_larcellsize
Definition: LArNoiseBursts.h:131
LArNoiseBursts::m_caloMgrKey
SG::ReadCondHandleKey< CaloDetDescrManager > m_caloMgrKey
Definition: LArNoiseBursts.h:110
v_noisycellHVphi
std::vector< int > v_noisycellHVphi
Definition: LArNoiseBursts.cxx:71
LArNoiseBursts::m_nt_energy_sat
std::vector< float > m_nt_energy_sat
Definition: LArNoiseBursts.h:232
LArNoiseBursts::m_frontbunches
unsigned int m_frontbunches
Definition: LArNoiseBursts.h:122
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:235
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
LArNoiseBursts::m_trigDec
PublicToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: LArNoiseBursts.h:100
v_slot_noisy
std::vector< short > v_slot_noisy
Definition: LArNoiseBursts.cxx:68
LArNoiseBursts::m_nt_bunchtype
int m_nt_bunchtype
Definition: LArNoiseBursts.h:143
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:555
nlarcell
int nlarcell
Definition: LArNoiseBursts.cxx:65
LArNoiseBursts::m_bcDataKey
SG::ReadCondHandleKey< BunchCrossingCondData > m_bcDataKey
Definition: LArNoiseBursts.h:98
v_signifcell
std::vector< float > v_signifcell
Definition: LArNoiseBursts.cxx:72
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:226
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
LArNoiseBursts::m_nt_isbadcell
std::vector< int > m_nt_isbadcell
Definition: LArNoiseBursts.h:219
columnar::ContainerId::eventInfo
@ eventInfo
LArNoiseBursts::m_nt_L1_J30_FIRSTEMPTY
bool m_nt_L1_J30_FIRSTEMPTY
Definition: LArNoiseBursts.h:170
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
LArNoiseBursts::m_nt_phicell
std::vector< float > m_nt_phicell
Definition: LArNoiseBursts.h:202
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
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:97
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:1944
LArNoiseBursts::m_NoisyROKey
SG::ReadHandleKey< LArNoisyROSummary > m_NoisyROKey
Definition: LArNoiseBursts.h:102
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:136
CaloDetDescrElement::getLayer
virtual int getLayer() const
cell layer
Definition: CaloDetDescrElement.cxx:84
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_nt_larflag_mnbLoose
bool m_nt_larflag_mnbLoose
Definition: LArNoiseBursts.h:158
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:350
v_etacell
std::vector< float > v_etacell
Definition: LArNoiseBursts.cxx:73
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_nCellC
int m_nt_nCellC
Definition: LArNoiseBursts.h:196
LArNoiseBursts::m_nt_etacell
std::vector< float > m_nt_etacell
Definition: LArNoiseBursts.h:203
LArNoiseBursts::m_nt_gain
std::vector< int > m_nt_gain
Definition: LArNoiseBursts.h:218
BunchCrossingCondData::bcType
BunchCrossingType bcType(const bcid_type bcid) const
Convenience function for the type of the specific bunch crossing.
Definition: BunchCrossingCondData.cxx:198
LArNoiseBursts::m_LArHVLineIDHelper
const LArHVLineID * m_LArHVLineIDHelper
Definition: LArNoiseBursts.h:105
LArNoiseBursts::m_nt_run
int m_nt_run
Definition: LArNoiseBursts.h:133
n_cell_part
int n_cell_part[8]
Definition: LArNoiseBursts.cxx:67
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:72
LArNoiseBursts::m_nt_larflag_dataCorrupted
bool m_nt_larflag_dataCorrupted
Definition: LArNoiseBursts.h:155
LArNoiseBursts::m_noisycell
long m_noisycell
Definition: LArNoiseBursts.h:130
LArHEC_Base_ID::pos_neg
int pos_neg(const Identifier id) const
return pos_neg -2 (C side) or 2 (A side)
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:629
LArNoiseBursts::m_nt_isbcidFilled
int m_nt_isbcidFilled
Definition: LArNoiseBursts.h:140
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
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:137
LArNoiseBursts::m_nt_EF_xe60_LArNoiseBurst
bool m_nt_EF_xe60_LArNoiseBurst
Definition: LArNoiseBursts.h:183
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
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:109
LArNoiseBursts::m_nt_isbadcell_sat
std::vector< int > m_nt_isbadcell_sat
Definition: LArNoiseBursts.h:225
LHEF::Writer
Pythia8::Writer Writer
Definition: Prophecy4fMerger.cxx:12
LArNoiseBursts::m_nt_ft_noisy
std::vector< short > m_nt_ft_noisy
Definition: LArNoiseBursts.h:208
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:129
LArNoiseBursts::m_nt_EF_j35_u0uchad_empty_LArNoiseBurst
bool m_nt_EF_j35_u0uchad_empty_LArNoiseBurst
Definition: LArNoiseBursts.h:188
LArNoiseBursts::m_nt_isbcidInTrain
int m_nt_isbcidInTrain
Definition: LArNoiseBursts.h:141
v_ft_noisy
std::vector< short > v_ft_noisy
Definition: LArNoiseBursts.cxx:68
v_channel_noisy
std::vector< short > v_channel_noisy
Definition: LArNoiseBursts.cxx:68
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_bunchtime
float m_nt_bunchtime
Definition: LArNoiseBursts.h:144
LArNoiseBursts::m_nt_evtTime
int m_nt_evtTime
Definition: LArNoiseBursts.h:135
v_isbadcell
std::vector< bool > v_isbadcell
Definition: LArNoiseBursts.cxx:74
LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurst
bool m_nt_EF_j165_u0uchad_LArNoiseBurst
Definition: LArNoiseBursts.h:177
LArNoiseBursts::m_LArFCAL_IDHelper
const LArFCAL_ID * m_LArFCAL_IDHelper
Definition: LArNoiseBursts.h:108
LArID_Exception
Exception class for LAr Identifiers.
Definition: LArID_Exception.h:20
LArNoiseBursts::m_nt_larflag_badHVlines
bool m_nt_larflag_badHVlines
Definition: LArNoiseBursts.h:161
LArNoiseBursts::m_nt_badHVlines
std::vector< unsigned int > m_nt_badHVlines
Definition: LArNoiseBursts.h:165
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
LArNoiseBursts::m_nt_noisycellHVeta
std::vector< int > m_nt_noisycellHVeta
Definition: LArNoiseBursts.h:216
v_layer
std::vector< short > v_layer
Definition: LArNoiseBursts.cxx:70
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:229
LArNoiseBursts::m_nt_EF_j30_u0uchad_empty_LArNoiseBurst
bool m_nt_EF_j30_u0uchad_empty_LArNoiseBurst
Definition: LArNoiseBursts.h:178
Identifier
Definition: IdentifierFieldParser.cxx:14
LArNoiseBursts::clear
virtual StatusCode clear()
Clear - clear CBNT members.
Definition: LArNoiseBursts.cxx:377
LArHVLineID
Helper for the Liquid Argon Calorimeter High-Voltage identifiers.
Definition: LArHVLineID.h:48
Generated on Thu Apr 17 2025 21:35:20 for ATLAS Offline Software by   doxygen 1.8.18