ATLAS Offline Software
LArNoiseBursts.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
10 
11 #include "GaudiKernel/ThreadLocalContext.h"
12 #include "StoreGate/ReadCondHandle.h"
13 
14 #include "CaloIdentifier/CaloCell_ID.h"
15 #include "CaloIdentifier/CaloDM_ID.h"
16 #include "CaloIdentifier/CaloLVL1_ID.h"
17 #include "CaloIdentifier/LArEM_ID.h"
18 #include "CaloIdentifier/LArHEC_ID.h"
19 #include "CaloIdentifier/LArFCAL_ID.h"
20 #include "CaloIdentifier/LArMiniFCAL_ID.h"
21 #include "CaloIdentifier/LArID_Exception.h"
22 
23 #include "AthenaPoolUtilities/AthenaAttributeList.h"
24 
25 #include "Identifier/Range.h"
26 #include "Identifier/IdentifierHash.h"
27 #include "Identifier/HWIdentifier.h"
28 
29 #include "LArIdentifier/LArOnlineID.h"
30 #include "LArIdentifier/LArHVLineID.h"
31 #include "LArIdentifier/LArElectrodeID.h"
32 
33 #include "LArRecEvent/LArEventBitInfo.h"
34 #include "LArRawEvent/LArDigit.h"
35 #include "LArRawEvent/LArDigitContainer.h"
36 #include "LArRawEvent/LArRawChannelContainer.h"
37 #include "LArRecEvent/LArNoisyROSummary.h"
38 #include "LArRecEvent/LArCollisionTime.h"
39 #include "CaloConditions/CaloNoise.h"
40 
41 #include "NavFourMom/IParticleContainer.h"
42 #include "NavFourMom/INavigable4MomentumCollection.h"
43 
44 // Lar HV
45 #include "CaloDetDescr/CaloDetectorElements.h"
46 #include "AthenaPoolUtilities/CondAttrListCollection.h"
47 
49 
50 #include "TTree.h"
51 #include "CLHEP/Vector/LorentzVector.h"
52 
53 #include "xAODEventInfo/EventInfo.h"
54 
55 #include "CaloEvent/CaloCellContainer.h"
56 
57 #include "LArCafJobs/LArNoiseBursts.h"
58 
59 #include <algorithm>
60 #include <math.h>
61 #include <functional>
62 #include <iostream>
63 
64 using namespace std;
65 
66 int nlarcell=0;
67 int n_noisy_cell_part[8] = {0,0,0,0,0,0,0,0};
68 int n_cell_part[8] = {0,0,0,0,0,0,0,0};
69 std::vector<short> v_barrelec_noisy, v_posneg_noisy,v_ft_noisy, v_slot_noisy, v_channel_noisy;
70 std::vector<bool> v_isbarrel, v_isendcap, v_isfcal, v_ishec;
71 std::vector<short> v_layer;
72 std::vector<int> v_partition,v_noisycellHVphi,v_noisycellHVeta;
73 std::vector<float> v_energycell, v_qfactorcell, v_signifcell;
74 std::vector<float> v_phicell, v_etacell;
75 std::vector<bool> v_isbadcell;
76 std::vector<IdentifierHash> v_IdHash;
77 std::vector<int> v_cellpartlayerindex;
78 std::vector<Identifier> v_cellIdentifier;
79 std::vector<HWIdentifier> v_onlIdentifier;
80 
83 
84 
85 LArNoiseBursts::LArNoiseBursts(const std::string& name,
86  ISvcLocator* pSvcLocator)
87  : AthAlgorithm(name, pSvcLocator),
88  m_tree(nullptr),
89  m_LArOnlineIDHelper(nullptr),
90  m_LArHVLineIDHelper(nullptr),
91  m_LArElectrodeIDHelper(nullptr),
92  m_LArEM_IDHelper(nullptr),
93  m_LArFCAL_IDHelper(nullptr),
94  m_LArHEC_IDHelper(nullptr),
95  m_CosmicCaloStream(false),
96  m_nb_sat(0),
97  m_lowqfactor(0),
98  m_medqfactor(0),
99  m_hiqfactor(0),
100  m_noisycell(0),
101  m_nt_larcellsize(0),
102  m_nt_cellsize(0),
103  m_nt_run(0),
104  m_nt_evtId(0),
105  m_nt_evtTime(0),
106  m_nt_evtTime_ns(0),
107  m_nt_lb(0),
108  m_nt_bcid(0),
109  //m_nt_ntracks(0),
110  m_nt_isbcidFilled(0),
111  m_nt_isbcidInTrain(0),
112  m_nt_isBunchesInFront(0),
113  m_nt_bunchtype(0),
114  m_nt_bunchtime(0),
115  m_nt_atlasready(0),
116  m_nt_stablebeams(0),
117  m_nt_streamTagName(0),
118  m_nt_streamTagType(0),
119  m_nt_larnoisyro(0),
120  m_nt_larnoisyro_opt(0),
121  m_nt_larnoisyro_satTwo(0),
122  m_nt_larmnbnoisy(0),
123  m_nt_larmnbnoisy_sat(0),
124 // m_nt_veto_mbts(0),
125 // //m_nt_veto_indet(0),
126 // m_nt_veto_bcm(0),
127 // m_nt_veto_lucid(0),
128 // m_nt_veto_pixel(0),
129 // m_nt_veto_sct(0),
130 // m_nt_veto_mbtstdHalo(0),
131 // m_nt_veto_mbtstdCol(0),
132 // m_nt_veto_lartdHalo(0),
133 // m_nt_veto_lartdCol(0),
134 // m_nt_veto_csctdHalo(0),
135 // m_nt_veto_csctdCol(0),
136 // m_nt_veto_bcmtHalo(0),
137 // m_nt_veto_bcmtCol(0),
138 // m_nt_veto_muontCol(0),
139 // m_nt_veto_muontCosmic(0),
140  m_nt_larflag_badFEBs(false),
141  m_nt_larflag_mediumSaturatedDQ(false),
142  m_nt_larflag_tightSaturatedDQ(false),
143  m_nt_larflag_noiseBurstVeto(false),
144  m_nt_larflag_dataCorrupted(false),
145  m_nt_larflag_dataCorruptedVeto(false),
146  m_nt_L1_J75(false),
147  m_nt_L1_J10_EMPTY(false),
148  m_nt_L1_J30_FIRSTEMPTY(false),
149  m_nt_L1_J30_EMPTY(false),
150  m_nt_L1_XE40(false),
151  m_nt_L1_XE50(false),
152  m_nt_L1_XE50_BGRP7(false),
153  m_nt_L1_XE70(false),
154  m_nt_EF_j165_u0uchad_LArNoiseBurst(false),
155  m_nt_EF_j30_u0uchad_empty_LArNoiseBurst(false),
156  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst(false),
157  m_nt_EF_j55_u0uchad_empty_LArNoiseBurst(false),
158  m_nt_EF_xe45_LArNoiseBurst(false),
159  m_nt_EF_xe55_LArNoiseBurst(false),
160  m_nt_EF_xe60_LArNoiseBurst(false),
161  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT(false),
162  m_nt_EF_j100_u0uchad_LArNoiseBurstT(false),
163  m_nt_EF_j165_u0uchad_LArNoiseBurstT(false),
164  m_nt_EF_j130_u0uchad_LArNoiseBurstT(false),
165  m_nt_EF_j35_u0uchad_empty_LArNoiseBurst(false),
166  m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst(false),
167  m_nt_EF_j80_u0uchad_LArNoiseBurstT(false),
168  m_nt_ECTimeDiff(0),
169  m_nt_ECTimeAvg(0),
170  m_nt_nCellA(0),
171  m_nt_nCellC(0),
172  m_nt_energycell(0),
173  m_nt_qfactorcell(0),
174  m_nt_phicell(0),
175  m_nt_etacell(0),
176  m_nt_signifcell(0),
177  //m_nt_noisycellpercent(0),
178  m_nt_barrelec_noisy(0),
179  m_nt_posneg_noisy(0),
180  m_nt_ft_noisy(0),
181  m_nt_slot_noisy(0),
182  m_nt_channel_noisy(0),
183  m_nt_cellpartlayerindex(0),
184  m_nt_cellIdentifier(0),
185  m_nt_onlIdentifier(0),
186  m_nt_noisycellpart(0),
187  m_nt_noisycellHVphi(0),
188  m_nt_noisycellHVeta(0),
189  m_nt_samples(0),
190  m_nt_gain(0),
191  m_nt_isbadcell(0),
192  m_nt_partition(0),
193  m_nt_layer(0),
194  m_nt_isbadcell_sat(0),
195  m_nt_barrelec_sat(0),
196  m_nt_posneg_sat(0),
197  m_nt_ft_sat(0),
198  m_nt_slot_sat(0),
199  m_nt_channel_sat(0),
200  m_nt_partition_sat(0),
201  m_nt_energy_sat(0),
202  m_nt_phicell_sat(0),
203  m_nt_etacell_sat(0),
204  m_nt_layer_sat(0),
205  m_nt_cellIdentifier_sat(0)
206  {
207 
208  //event cuts
209  declareProperty("SigmaCut", m_sigmacut = 3.0);
210  declareProperty("NumberOfBunchesInFront",m_frontbunches = 36);
211 
212  // Keep cell properties
213  declareProperty("KeepOnlyCellID", m_keepOnlyCellID = false);
214  }
215 
216 StatusCode LArNoiseBursts::initialize() {
217 
218  ATH_MSG_DEBUG ( "Initializing LArNoiseBursts" );
219 
220  // Trigger Decision Tool
221  ATH_CHECK( m_trigDec.retrieve() );
222 
223  ATH_CHECK( m_cablingKey.initialize() );
224  ATH_CHECK( m_BCKey.initialize() );
225  ATH_CHECK( m_totalNoiseKey.initialize() );
226  ATH_CHECK( m_bcDataKey.initialize() );
227 
228  // Retrieve online ID helper
229  const LArOnlineID* LArOnlineIDHelper = nullptr;
230  ATH_CHECK( detStore()->retrieve(LArOnlineIDHelper, "LArOnlineID") );
231  m_LArOnlineIDHelper = LArOnlineIDHelper;
232  ATH_MSG_DEBUG( " Found LArOnline Helper");
233 
234  // Retrieve HV line ID helper
235  const LArHVLineID* LArHVLineIDHelper = nullptr;
236  ATH_CHECK( detStore()->retrieve(LArHVLineIDHelper, "LArHVLineID") );
237  m_LArHVLineIDHelper = LArHVLineIDHelper;
238  ATH_MSG_DEBUG( " Found LArOnlineIDHelper Helper");
239 
240  // Retrieve HV electrode ID helper
241  const LArElectrodeID* LArElectrodeIDHelper = nullptr;
242  ATH_CHECK( detStore()->retrieve(LArElectrodeIDHelper, "LArElectrodeID") );
243  m_LArElectrodeIDHelper = LArElectrodeIDHelper;
244  ATH_MSG_DEBUG( " Found LArElectrodeIDHelper Helper");
245 
246  ATH_CHECK(m_caloMgrKey.initialize());
247 
248  // Retrieve ID helpers
249  const CaloCell_ID* idHelper = nullptr;
250  ATH_CHECK( detStore()->retrieve (idHelper, "CaloCell_ID") );
251  m_LArEM_IDHelper = idHelper->em_idHelper();
252  m_LArHEC_IDHelper = idHelper->hec_idHelper();
253  m_LArFCAL_IDHelper = idHelper->fcal_idHelper();
254 
256  ATH_CHECK( m_thistSvc.retrieve() );
257 
259  m_tree = new TTree( "CollectionTree", "CollectionTree" );
260  std::string treeName = "/TTREE/CollectionTree" ;
261  ATH_CHECK( m_thistSvc->regTree(treeName, m_tree) );
262 
263  // General properties of events
264  m_tree->Branch("Run",&m_nt_run,"Run/I");// Event ID
265  m_tree->Branch("EventId",&m_nt_evtId,"EventId/l");// Event ID
266  m_tree->Branch("EventTime",&m_nt_evtTime,"EventTime/I");// Event time
267  m_tree->Branch("EventTime_ns",&m_nt_evtTime_ns,"EventTime_ns/I");// Event time in nanosecond
268  m_tree->Branch("LumiBlock",&m_nt_lb,"LumiBlock/I"); // LB
269  m_tree->Branch("BCID",&m_nt_bcid,"BCID/I"); // BCID
270  m_tree->Branch("StreamTagName",&m_nt_streamTagName);// stream tag name
271  m_tree->Branch("StreamTagType",&m_nt_streamTagType); // stream tag type
272  m_tree->Branch("IsBCIDFilled", &m_nt_isbcidFilled,"IsBCIDFilled/I"); // check if bunch is filled
273  m_tree->Branch("IsBCIDInTrain",&m_nt_isbcidInTrain,"ISBCIDInTrain/I"); // check if bunch belong to a train
274  m_tree->Branch("BunchesInFront",&m_nt_isBunchesInFront); // check front bunches
275  m_tree->Branch("BunchType",&m_nt_bunchtype,"BunchType/I");// Empty = 0, FirstEmpty=1,&middleEmpty=2, Single=100,Front=200,&middle=201,Tail=202
276  m_tree->Branch("TimeAfterBunch",&m_nt_bunchtime,"TimeAfterBunch/F"); //time "distance" between the colliding bunch and the nearest one.
277  m_tree->Branch("ATLASIsReady",&m_nt_atlasready,"AtlasIsReady/I"); //check if atlas is ready for physics
278  m_tree->Branch("StableBeams",&m_nt_stablebeams,"StableBeams/I");//check stablebeams
279 
280  // LAr event bit info
281  m_tree->Branch("larflag_badFEBs",&m_nt_larflag_badFEBs,"larflag_badFEBs/O");
282  m_tree->Branch("larflag_mediumSaturatedDQ",&m_nt_larflag_mediumSaturatedDQ,"larflag_mediumSaturatedDQ/O");
283  m_tree->Branch("larflag_tightSaturatedDQ",&m_nt_larflag_tightSaturatedDQ,"larflag_tightSaturatedDQ/O");
284  m_tree->Branch("larflag_noiseBurstVeto",&m_nt_larflag_noiseBurstVeto,"larflag_noiseBurstVeto/O");
285  m_tree->Branch("larflag_dataCorrupted",&m_nt_larflag_dataCorrupted,"larflag_dataCorrupted/O");
286  m_tree->Branch("larflag_dataCorruptedVeto",&m_nt_larflag_dataCorruptedVeto,"larflag_dataCorruptedVeto/O");
287 
288  // trigger flags
289  m_tree->Branch("L1_J75",&m_nt_L1_J75,"L1_J75/O");
290  m_tree->Branch("L1_J10_EMPTY",&m_nt_L1_J10_EMPTY,"L1_J10_EMPTY/O");
291  m_tree->Branch("L1_J30_FIRSTEMPTY",&m_nt_L1_J30_FIRSTEMPTY,"L1_J30_FIRSTEMPTY/O");
292  m_tree->Branch("L1_J30_EMPTY",&m_nt_L1_J30_EMPTY,"L1_J30_EMPTY/O");
293  m_tree->Branch("L1_XE40",&m_nt_L1_XE40,"L1_XE40/O");
294  m_tree->Branch("L1_XE50",&m_nt_L1_XE50,"L1_XE50/O");
295  m_tree->Branch("L1_XE50_BGRP7",&m_nt_L1_XE50_BGRP7,"L1_XE50_BGRP7/O");
296  m_tree->Branch("L1_XE70",&m_nt_L1_XE70,"L1_XE70/O");
297 
298  m_tree->Branch("EF_j165_u0uchad_LArNoiseBurst",&m_nt_EF_j165_u0uchad_LArNoiseBurst,"EF_j165_u0uchad_LArNoiseBurst/O");
299  m_tree->Branch("EF_j30_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j30_u0uchad_empty_LArNoiseBurst,"EF_j30_u0uchad_empty_LArNoiseBurst/O");
300  m_tree->Branch("EF_j55_u0uchad_firstempty_LArNoiseBurst",&m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst,"EF_j55_u0uchad_firstempty_LArNoiseBurst/O");
301  m_tree->Branch("EF_j55_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j55_u0uchad_empty_LArNoiseBurst,"EF_j55_u0uchad_empty_LArNoiseBurst/O");
302  m_tree->Branch("EF_xe45_LArNoiseBurst",&m_nt_EF_xe45_LArNoiseBurst,"EF_xe45_LArNoiseBurst/O");
303  m_tree->Branch("EF_xe55_LArNoiseBurst",&m_nt_EF_xe55_LArNoiseBurst,"EF_xe55_LArNoiseBurst/O");
304  m_tree->Branch("EF_xe60_LArNoiseBurst",&m_nt_EF_xe60_LArNoiseBurst,"EF_xe60_LArNoiseBurst/O");
305  m_tree->Branch("EF_j55_u0uchad_firstempty_LArNoiseBurstT",&m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT,"EF_j55_u0uchad_firstempty_LArNoiseBurstT/O");
306  m_tree->Branch("EF_j100_u0uchad_LArNoiseBurstT",&m_nt_EF_j100_u0uchad_LArNoiseBurstT,"EF_j100_u0uchad_LArNoiseBurstT/O");
307  m_tree->Branch("EF_j165_u0uchad_LArNoiseBurstT",&m_nt_EF_j165_u0uchad_LArNoiseBurstT,"EF_j165_u0uchad_LArNoiseBurstT/O");
308  m_tree->Branch("EF_j130_u0uchad_LArNoiseBurstT",&m_nt_EF_j130_u0uchad_LArNoiseBurstT,"EF_j130_u0uchad_LArNoiseBurstT/O");
309  m_tree->Branch("EF_j35_u0uchad_empty_LArNoiseBurst",&m_nt_EF_j35_u0uchad_empty_LArNoiseBurst,"EF_j35_u0uchad_empty_LArNoiseBurst/O");
310  m_tree->Branch("EF_j35_u0uchad_firstempty_LArNoiseBurst",&m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst,"EF_j35_u0uchad_firstempty_LArNoiseBurst/O");
311  m_tree->Branch("EF_j80_u0uchad_LArNoiseBurstT",&m_nt_EF_j80_u0uchad_LArNoiseBurstT,"EF_j80_u0uchad_LArNoiseBurstT/O");
312 
313  //
314  m_tree->Branch("LArCellSize", &m_nt_larcellsize,"LArCellSize/I"); // NEW number of online conected LAr cells
315  m_tree->Branch("CaloCellSize",&m_nt_cellsize,"CaloCellSize/I");// NEW number of total cells.
316  // LAr time difference as computed by LArCollisionTime info
317  m_tree->Branch("LArTime_Diff",&m_nt_ECTimeDiff,"LArTime_Diff/F"); // time diff between 2 endcaps
318  m_tree->Branch("LArTime_Avg",&m_nt_ECTimeAvg,"LArTime_Avg/F"); // time average of 2 endcaps
319  m_tree->Branch("LArTime_nCellA",&m_nt_nCellA,"LArTime_nCellA/I"); // nb of cells used to compute endcap A time
320  m_tree->Branch("LArTime_nCellC",&m_nt_nCellC,"LArTime_nCellC/I"); // nb of cells used to compute endcap C time
321 
322  // Event properties related to yield of channels in 3 sigma tails
323  //m_tree->Branch("PerCentNoisyCell",&m_nt_noisycellpercent,"PerCentNoisyCell/F"); // Yield of channels in 3sigma tails in whole LAr
324  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
325 
326  // LArNoisyRO output
327  m_tree->Branch("LArNoisyRO_Std", &m_nt_larnoisyro,"LArNoisyRO_Std/S"); // standard flag (>5 FEB with more than 30 cells with q factor > 4000)
328  m_tree->Branch("LArNoisyRO_Std_optimized", &m_nt_larnoisyro_opt,"LArNoisyRO_Std_optimized/S"); // standard flag with a double weight for critical FEB (>5 FEB with more than 30 cells with q factor > 4000)
329  m_tree->Branch("LArNoisyRO_SatTight",&m_nt_larnoisyro_satTwo,"LArNoisyRO_SatTight/S"); // tight flag (> 20 cells with E>1000MeV and saturated q factor)
330  m_tree->Branch("LArNoisyRO_MNB",&m_nt_larmnbnoisy,"LArNoisyRO_MNB/S");
331  m_tree->Branch("LArNoisyRO_MNB_Sat",&m_nt_larmnbnoisy_sat,"LArNoisyRO_MNB_Sat/S");
332 
333  // Properties of cells with fabs(energy/noise)>3
334  m_tree->Branch("NoisyCellPartitionLayerIndex",&m_nt_cellpartlayerindex);
335  m_tree->Branch("NoisyCellIdentifier",&m_nt_cellIdentifier); // Identifier of the noisy cell
336  m_tree->Branch("NoisyCellOnlineIdentifier",&m_nt_onlIdentifier); // Identifier of the noisy cell
337  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
338  m_tree->Branch("NoisyCellBarrelEc",&m_nt_barrelec_noisy); // BC
339  m_tree->Branch("NoisyCellPosNeg",&m_nt_posneg_noisy); // side
340  m_tree->Branch("NoisyCellFT",&m_nt_ft_noisy); // FT
341  m_tree->Branch("NoisyCellSlot",&m_nt_slot_noisy); // Slot
342  m_tree->Branch("NoisyCellChannel",&m_nt_channel_noisy); // Channel
343  m_tree->Branch("NoisyCellADCvalues", &m_nt_samples); // ADC values
344  m_tree->Branch("NoisyCellGain",&m_nt_gain); // Gain
345  m_tree->Branch("NoisyCellPhi",&m_nt_phicell); // Phi
346  m_tree->Branch("NoisyCellEta",&m_nt_etacell); // Eta
347  m_tree->Branch("NoisyCellLayer", &m_nt_layer); // layer
348  m_tree->Branch("NoisyCellHVphi", &m_nt_noisycellHVphi); // Phi of HV
349  m_tree->Branch("NoisyCellHVeta", &m_nt_noisycellHVeta); // Eta of HV
350  m_tree->Branch("NoisyCellEnergy",&m_nt_energycell); // Energy
351  m_tree->Branch("NoisyCellSignificance",&m_nt_signifcell); // Significance (energy/noise)
352  m_tree->Branch("NoisyCellQFactor",&m_nt_qfactorcell); // Q factor
353  m_tree->Branch("NoisyCellIsBad",&m_nt_isbadcell); // Bad channel status
354  // Event properties related to q factor
355  m_tree->Branch("nbLowQFactor", &m_lowqfactor,"m_lowqfactor/i"); // Nb of cells per event with q factor<1000
356  m_tree->Branch("nbMedQFactor", &m_medqfactor,"m_medqfactor/i"); // Nb of cells per event with 1000<q factor<10000
357  m_tree->Branch("nbHighQFactor", &m_hiqfactor,"m_hiqfactor/i"); // Nb of cells per event with q 10000<factor<65535
358  m_tree->Branch("nbSatQFactor",&m_nb_sat,"nbSat/i"); // Nb of cells per event with saturated q factor (65535)
359  // Properties of cells with q factor saturated
360  m_tree->Branch("SatCellPartition",&m_nt_partition_sat);
361  m_tree->Branch("SatCellBarrelEc",&m_nt_barrelec_sat);
362  m_tree->Branch("SatCellPosNeg",&m_nt_posneg_sat);
363  m_tree->Branch("SatCellFT",&m_nt_ft_sat);
364  m_tree->Branch("SatCellSlot",&m_nt_slot_sat);
365  m_tree->Branch("SatCellChannel",&m_nt_channel_sat);
366  m_tree->Branch("SatCellEnergy",&m_nt_energy_sat);
367  m_tree->Branch("SatCellPhi", &m_nt_phicell_sat);
368  m_tree->Branch("SatCellEta",&m_nt_etacell_sat);
369  m_tree->Branch("SatCellLayer",&m_nt_layer_sat);
370  m_tree->Branch("SatCellIsBad", &m_nt_isbadcell_sat);
371  m_tree->Branch("SatCellOnlineIdentifier",&m_nt_cellIdentifier_sat);
372 
373 
374  ATH_MSG_DEBUG ( "End of Initializing LArNoiseBursts" );
375 
376  return StatusCode::SUCCESS;
377 }
378 
381 
382 StatusCode LArNoiseBursts::finalize() {
383  ATH_MSG_DEBUG ( "in finalize()" );
384  return StatusCode::SUCCESS;
385 }
386 
389 StatusCode LArNoiseBursts::clear() {
391 
392  ATH_MSG_DEBUG ( "start clearing variables " );
393 
394  m_nb_sat = 0;
395  m_noisycell = 0;
396  m_lowqfactor = 0;
397  m_medqfactor = 0;
398  m_hiqfactor = 0;
399 
400  m_nt_run = 0;
401  m_nt_evtId = 0;
402  m_nt_evtTime = 0;
403  m_nt_evtTime_ns = 0;
404  m_nt_lb = 0;
405  m_nt_bcid = -1;
406 
407  m_nt_streamTagName.clear();
408  m_nt_streamTagType.clear();
409  m_nt_isbcidFilled = -1;
410  m_nt_isbcidInTrain = -1;
411  m_nt_isBunchesInFront.clear();
412  m_nt_bunchtype = -1;
413  m_nt_bunchtime = -1.0;
414  m_nt_atlasready = -1;
415  m_nt_stablebeams = -1;
416  m_nt_larnoisyro = -1;
417  m_nt_larnoisyro_opt = -1;
418  m_nt_larnoisyro_satTwo= -1;
419  m_nt_larmnbnoisy = -1;
420  m_nt_larmnbnoisy_sat = -1;
421 
422  ATH_MSG_DEBUG ( "clearing event info veto variables " );
423 
424  //clearing event info veto variables
425 // m_nt_veto_mbts = -1;
426 // m_nt_veto_pixel = -1;
427 // m_nt_veto_sct = -1;
428 // m_nt_veto_bcm = -1;
429 // m_nt_veto_lucid = -1;
430 // m_nt_veto_mbtstdHalo = -1;
431 // m_nt_veto_mbtstdCol = -1;
432 // m_nt_veto_lartdHalo = -1;
433 // m_nt_veto_lartdCol = -1;
434 // m_nt_veto_csctdHalo = -1;
435 // m_nt_veto_csctdCol = -1;
436 // m_nt_veto_bcmtHalo = -1;
437 // m_nt_veto_bcmtCol = -1;
438 // m_nt_veto_muontCol = -1;
439 // m_nt_veto_muontCosmic = -1;
440 //
441 // mLog << MSG::DEBUG << "clearing LAr event flags " << endmsg;
442 
443  ATH_MSG_DEBUG ( "clearing LAr event flags " );
444 
445  // lar bit event info
446  m_nt_larflag_badFEBs = false;
447  m_nt_larflag_mediumSaturatedDQ = false;
448  m_nt_larflag_tightSaturatedDQ = false;
449  m_nt_larflag_noiseBurstVeto = false;
450  m_nt_larflag_dataCorrupted = false;
451  m_nt_larflag_dataCorruptedVeto = false;
452 
453  ATH_MSG_DEBUG ( "clearing Pixel variables " );
454 
455  // Trigger flags
456  m_nt_L1_J75 = true; // turned on for tests
457  m_nt_L1_J10_EMPTY = false;
458  m_nt_L1_J30_FIRSTEMPTY = false;
459  m_nt_L1_J30_EMPTY = false;
460  m_nt_L1_XE40 = false;
461  m_nt_L1_XE50 = false;
462  m_nt_L1_XE50_BGRP7 = false;
463  m_nt_L1_XE70 = false;
464 
465  m_nt_EF_j165_u0uchad_LArNoiseBurst = false;
466  m_nt_EF_j30_u0uchad_empty_LArNoiseBurst = false;
467  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst = false;
468  m_nt_EF_j55_u0uchad_empty_LArNoiseBurst = false;
469  m_nt_EF_xe45_LArNoiseBurst = false;
470  m_nt_EF_xe55_LArNoiseBurst = false;
471  m_nt_EF_xe60_LArNoiseBurst = false;
472  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT = false;
473  m_nt_EF_j100_u0uchad_LArNoiseBurstT = false;
474  m_nt_EF_j165_u0uchad_LArNoiseBurstT = false;
475  m_nt_EF_j130_u0uchad_LArNoiseBurstT = false;
476  m_nt_EF_j35_u0uchad_empty_LArNoiseBurst = false;
477  m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst = false;
478  m_nt_EF_j80_u0uchad_LArNoiseBurstT = false;
479 
480  ATH_MSG_DEBUG ( "clearing trigger flags " );
481 
482  ATH_MSG_DEBUG ( "clearing noisy cells variables " );
483 
484  //Quantities for noisy cells
485  m_nt_energycell.clear();
486  m_nt_qfactorcell.clear();
487  m_nt_phicell.clear();
488  m_nt_etacell.clear();
489  m_nt_signifcell.clear();
490  m_nt_isbadcell.clear();
491  m_nt_partition.clear();
492  m_nt_layer.clear();
493  //m_nt_noisycellpercent = -1;
494  m_nt_barrelec_noisy.clear();
495  m_nt_posneg_noisy.clear();
496  m_nt_ft_noisy.clear();
497  m_nt_slot_noisy.clear();
498  m_nt_channel_noisy.clear();
499  m_nt_larcellsize = -1;
500  m_nt_cellsize = -1;
501  m_nt_cellpartlayerindex.clear();
502  m_nt_cellIdentifier.clear();
503  m_nt_onlIdentifier.clear();
504  m_nt_noisycellpart.clear();
505  m_nt_samples.clear();
506  m_nt_gain.clear();
507 
509  m_nt_noisycellHVphi.clear();
510  m_nt_noisycellHVeta.clear();
511 
512  ATH_MSG_DEBUG ( "clearing saturated cell variables " );
513 
514  //clearing quantities for sat cells
515  m_nt_barrelec_sat.clear();
516  m_nt_posneg_sat.clear();
517  m_nt_ft_sat.clear();
518  m_nt_slot_sat.clear();
519  m_nt_channel_sat.clear();
520  m_nt_partition_sat.clear();
521  m_nt_energy_sat.clear();
522  m_nt_phicell_sat.clear();
523  m_nt_etacell_sat.clear();
524  m_nt_layer_sat.clear();
525  m_nt_cellIdentifier_sat.clear();
526  m_nt_isbadcell_sat.clear();
527 
528  ATH_MSG_DEBUG ( "clearing LArTimeDiff variables " );
529 
530  //DiffTime computed with LAR
531  m_nt_ECTimeDiff = 9999;
532  m_nt_ECTimeAvg = 9999;
533  m_nt_nCellA = -1;
534  m_nt_nCellC = -1;
535 
536  return StatusCode::SUCCESS;
537 }
538 
541 
542 StatusCode LArNoiseBursts::execute() {
543  ATH_MSG_DEBUG ( "in execute()" );
544 
545  StatusCode sc = clear();
546  if(sc.isFailure()) {
547  ATH_MSG_WARNING ( "The method clear() failed" );
548  return StatusCode::SUCCESS;
549  }
550 
551  if(!m_trigDec.empty()){
552 
553  sc = doTrigger();
554  if(sc.isFailure()) {
555  ATH_MSG_WARNING ( "The method doTrigger() failed" );
556  return StatusCode::SUCCESS;
557  }
558  }
559 
560  sc = doEventProperties();
561  if(sc.isFailure()) {
562  ATH_MSG_WARNING ( "The method doEventProperties() failed" );
563  return StatusCode::SUCCESS;
564  }
565 
566  sc = doLArNoiseBursts();
567  if (sc.isFailure()) {
568  ATH_MSG_WARNING ( "The method doLArNoiseBursts() failed" );
569  return StatusCode::SUCCESS;
570  }
571 
572 // sc = doPhysicsObjects();
573 // if (sc.isFailure()) {
574 // ATH_MSG_WARNING ( "The method doPhysicsObjects() failed" );
575 // return StatusCode::SUCCESS;
576 // }
577 
578  m_tree->Fill();
579 
580  return StatusCode::SUCCESS;
581 }
582 
586 StatusCode LArNoiseBursts::doTrigger(){
587  ATH_MSG_DEBUG ("in doTrigger ");
588 
589  std::string mychain( "L1_J75" );
590  if( ! m_trigDec->getListOfTriggers(mychain).empty() ){
591  m_nt_L1_J75 = m_trigDec->isPassed( mychain );
592  }
593  mychain = "L1_J10_EMPTY";
594  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
595  m_nt_L1_J10_EMPTY = m_trigDec->isPassed( mychain );
596  }
597  mychain = "L1_J30_FIRSTEMPTY";
598  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
599  m_nt_L1_J30_FIRSTEMPTY = m_trigDec->isPassed( mychain );
600  }
601  mychain = "L1_J30_EMPTY";
602  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
603  m_nt_L1_J30_EMPTY = m_trigDec->isPassed( mychain );
604  }
605  mychain = "L1_XE40";
606  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
607  m_nt_L1_XE40 = m_trigDec->isPassed( mychain );
608  }
609  mychain = "L1_XE50";
610  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
611  m_nt_L1_XE50 = m_trigDec->isPassed( mychain );
612  }
613  mychain = "L1_XE50_BGRP7";
614  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
615  m_nt_L1_XE50_BGRP7 = m_trigDec->isPassed( mychain );
616  }
617  mychain = "L1_XE70";
618  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
619  m_nt_L1_XE70 = m_trigDec->isPassed( mychain );
620  }
621 
622  // EF
623  mychain = "EF_j165_u0uchad_LArNoiseBurst";
624  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
625  m_nt_EF_j165_u0uchad_LArNoiseBurst = m_trigDec->isPassed( mychain );
626  }
627  mychain = "EF_j30_u0uchad_empty_LArNoiseBurst";
628  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
629  m_nt_EF_j30_u0uchad_empty_LArNoiseBurst = m_trigDec->isPassed( mychain );
630  }
631  mychain = "EF_j55_u0uchad_firstempty_LArNoiseBurst";
632  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
633  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst = m_trigDec->isPassed( mychain );
634  }
635  mychain = "EF_j55_u0uchad_empty_LArNoiseBurst";
636  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
637  m_nt_EF_j55_u0uchad_empty_LArNoiseBurst = m_trigDec->isPassed( mychain );
638  }
639  mychain = "EF_xe45_LArNoiseBurst";
640  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
641  m_nt_EF_xe45_LArNoiseBurst = m_trigDec->isPassed( mychain );
642  }
643  mychain = "EF_xe55_LArNoiseBurst";
644  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
645  m_nt_EF_xe55_LArNoiseBurst = m_trigDec->isPassed( mychain );
646  }
647  mychain = "EF_xe60_LArNoiseBurst";
648  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
649  m_nt_EF_xe60_LArNoiseBurst = m_trigDec->isPassed( mychain );
650  }
651  mychain = "EF_j55_u0uchad_firstempty_LArNoiseBurstT";
652  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
653  m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT = m_trigDec->isPassed( mychain );
654  }
655  mychain = "EF_j100_u0uchad_LArNoiseBurstT";
656  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
657  m_nt_EF_j100_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
658  }
659  mychain = "EF_j165_u0uchad_LArNoiseBurstT";
660  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
661  m_nt_EF_j165_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
662  }
663  mychain = "EF_j130_u0uchad_LArNoiseBurstT";
664  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
665  m_nt_EF_j130_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
666  }
667  mychain = "EF_j35_u0uchad_empty_LArNoiseBurst";
668  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
669  m_nt_EF_j35_u0uchad_empty_LArNoiseBurst = m_trigDec->isPassed( mychain );
670  }
671  mychain = "EF_j35_u0uchad_firstempty_LArNoiseBurst";
672  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
673  m_nt_EF_j35_u0uchad_firstempty_LArNoiseBurst = m_trigDec->isPassed( mychain );
674  }
675  mychain = "EF_j80_u0uchad_LArNoiseBurstT";
676  if( ! m_trigDec->getListOfTriggers(mychain).empty()){
677  m_nt_EF_j80_u0uchad_LArNoiseBurstT = m_trigDec->isPassed( mychain );
678  }
679 
680  return StatusCode::SUCCESS;
681 }
682 
686 StatusCode LArNoiseBursts::doEventProperties(){
687  ATH_MSG_DEBUG ("in doEventProperties ");
688 
689 
691  // Retrieve event info
692  const xAOD::EventInfo* eventInfo = nullptr;
693  ATH_CHECK( evtStore()->retrieve(eventInfo) );
694 
695  int run = eventInfo->runNumber();
696  m_nt_run = eventInfo->runNumber();
697  m_nt_evtId = eventInfo->eventNumber();
698  m_nt_evtTime = eventInfo->timeStamp();
699  m_nt_evtTime_ns = eventInfo->timeStampNSOffset();
700  m_nt_lb = eventInfo->lumiBlock();
701  m_nt_bcid = eventInfo->bcid();
702 
703  ATH_MSG_DEBUG("Run Number: "<<run<<", event Id "<<m_nt_evtId<<", bcid = "<<m_nt_bcid);
704 
705  SG::ReadCondHandle<BunchCrossingCondData> bccd (m_bcDataKey);
706  const BunchCrossingCondData* bunchCrossing=*bccd;
707  if (!bunchCrossing) {
708  ATH_MSG_ERROR("Failed to retrieve Bunch Crossing obj");
709  return StatusCode::FAILURE;
710  }
711 
712  m_nt_isbcidFilled = bunchCrossing->isFilled(m_nt_bcid);
713  m_nt_isbcidInTrain = bunchCrossing->isInTrain(m_nt_bcid);
714  m_nt_bunchtype = bunchCrossing->bcType(m_nt_bcid);
715  ATH_MSG_DEBUG("BCID is Filled: "<<m_nt_isbcidFilled);
716  ATH_MSG_DEBUG("BCID is in Train: "<<m_nt_isbcidInTrain);
717  ATH_MSG_DEBUG("bunch type "<<m_nt_bunchtype);
718 
719  unsigned int distFromFront = bunchCrossing->distanceFromFront(m_nt_bcid,BunchCrossingCondData::BunchCrossings);
720  if(m_frontbunches < distFromFront) distFromFront=m_frontbunches;
721 
722  bool checkfirstbunch = true;
723  for(unsigned int i=1;i<=distFromFront;i++){
724  bool isFilled=bunchCrossing->isFilled(m_nt_bcid-i);
725  ATH_MSG_DEBUG("bunch "<<i<<" is Filled "<<isFilled);
726  m_nt_isBunchesInFront.push_back(isFilled);
727  if(isFilled){
728  if(i!=1){
729  if(checkfirstbunch){
730  float time = 25.0*i;
731  m_nt_bunchtime = time;
732  ATH_MSG_DEBUG("next bunch time: "<<time<<" ns ");
733  checkfirstbunch = false;
734  }
735  }
736  }
737  }
738 
739  m_CosmicCaloStream = false;
740  //std::vector<TriggerInfo::StreamTag>::const_iterator streamInfoIt=myTriggerInfo->streamTags().begin();
741  //std::vector<TriggerInfo::StreamTag>::const_iterator streamInfoIt_e=myTriggerInfo->streamTags().end();
742  //for (;streamInfoIt!=streamInfoIt_e;streamInfoIt++) {
743  for (const auto& streamInfo : eventInfo->streamTags()) {
744  const std::string& stream_name = streamInfo.name();
745  const std::string& stream_type = streamInfo.type();
746  m_nt_streamTagName.push_back(stream_name);
747  m_nt_streamTagType.push_back(stream_type);
748  ATH_MSG_DEBUG("event stream tag name "<<streamInfo.name());
749  ATH_MSG_DEBUG("event stream tag type "<<streamInfo.type());
750  if(streamInfo.name()=="CosmicCalo" && streamInfo.type()=="physics"){
751  m_CosmicCaloStream = true;
752  }
753  }
754 
755 
756  ATH_MSG_DEBUG("CosmicCalo stream value: "<<m_CosmicCaloStream);
757 
758  // Retrieve output of LArNoisyRO
759  bool larnoisyro = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS);
760  bool larnoisyro_opt =eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS_W);
761  bool larnoisyro_satTwo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ);
762  bool larmnbnoisy = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTLOOSE);
763  bool larmnbnoisy_sat = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MININOISEBURSTTIGHT);
764  m_nt_larnoisyro = larnoisyro ? 1 : 0;
765  m_nt_larnoisyro_opt = larnoisyro_opt ? 1 : 0;
766  m_nt_larnoisyro_satTwo = larnoisyro_satTwo ? 1 : 0;
767  m_nt_larmnbnoisy = larmnbnoisy ? 1 : 0;
768  m_nt_larmnbnoisy_sat = larmnbnoisy_sat ? 1 : 0;
769 
770  // Retrieve output of EventInfo veto - COMMENTED NOW TO MAKE IT COMPLIANT WITH xAOD::EventInfo
771 // mLog << MSG::DEBUG <<"Background: MBTSBeamVeto "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSBeamVeto)<<endmsg;
772 // mLog << MSG::DEBUG <<"Background: PixSPNonEmpty "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::PixSPNonEmpty)<<endmsg;
773 // mLog << MSG::DEBUG <<"Background: SCTSPNonEmpty "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::SCTSPNonEmpty)<<endmsg;
774 // mLog << MSG::DEBUG <<"Background: BCMBeamVeto "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMBeamVeto)<<endmsg;
775 // mLog << MSG::DEBUG <<"Background: LUCIDBeamVeto "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LUCIDBeamVeto)<<endmsg;
776 // mLog << MSG::DEBUG <<"Background: MBTSTimeDiffHalo "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSTimeDiffHalo)<<endmsg;
777 // mLog << MSG::DEBUG <<"Background: MBTSTimeDiffCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSTimeDiffCol)<<endmsg;
778 // mLog << MSG::DEBUG <<"Background: LArECTimeDiffHalo "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LArECTimeDiffHalo)<<endmsg;
779 // mLog << MSG::DEBUG <<"Background: LArECTimeDiffCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LArECTimeDiffCol)<<endmsg;
780 // mLog << MSG::DEBUG <<"Background: CSCTimeDiffHalo "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::CSCTimeDiffHalo)<<endmsg;
781 // mLog << MSG::DEBUG <<"Background: CSCTimeDiffCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::CSCTimeDiffCol)<<endmsg;
782 // mLog << MSG::DEBUG <<"Background: BCMTimeDiffHalo "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMTimeDiffHalo)<<endmsg;
783 // mLog << MSG::DEBUG <<"Background: BCMTimeDiffCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMTimeDiffCol)<<endmsg;
784 // mLog << MSG::DEBUG <<"Background: MuonTimmingCol "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MuonTimingCol)<<endmsg;
785 // mLog << MSG::DEBUG <<"Background: MuonTimmingCosmic "<<eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MuonTimingCosmic)<<endmsg;
786 //
787 // m_nt_veto_mbts = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSBeamVeto);
788 // m_nt_veto_pixel = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::PixSPNonEmpty);
789 // m_nt_veto_sct = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::SCTSPNonEmpty);
790 // m_nt_veto_bcm = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMBeamVeto);
791 // m_nt_veto_lucid = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LUCIDBeamVeto);
792 //
793 // //more variables
794 // m_nt_veto_mbtstdHalo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSTimeDiffHalo);
795 // m_nt_veto_mbtstdCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MBTSTimeDiffCol);
796 // m_nt_veto_lartdHalo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LArECTimeDiffHalo);
797 // m_nt_veto_lartdCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::LArECTimeDiffCol);
798 // m_nt_veto_csctdHalo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::CSCTimeDiffHalo);
799 // m_nt_veto_csctdCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::CSCTimeDiffCol);
800 // m_nt_veto_bcmtHalo = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMTimeDiffHalo);
801 // m_nt_veto_bcmtCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::BCMTimeDiffCol);
802 // m_nt_veto_muontCol = eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MuonTimingCol);
803 // m_nt_veto_muontCosmic= eventInfo->isEventFlagBitSet(xAOD::EventInfo::Background,xAOD::EventInfo::MuonTimingCosmic);
804 
805  // LArEventInfo
806 
807  ATH_MSG_DEBUG ("NOISEBURSTVETO bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO) );
808  ATH_MSG_DEBUG ("BADFEBS bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS));
809  ATH_MSG_DEBUG ("TIGHTSATURATEDQ bit " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ));
810 
811  m_nt_larflag_badFEBs = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::BADFEBS);
812  m_nt_larflag_mediumSaturatedDQ = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::MEDIUMSATURATEDQ);
813  m_nt_larflag_tightSaturatedDQ = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::TIGHTSATURATEDQ);
814  m_nt_larflag_noiseBurstVeto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::NOISEBURSTVETO);
815  m_nt_larflag_dataCorrupted = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::DATACORRUPTED);
816  m_nt_larflag_dataCorruptedVeto = eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,LArEventBitInfo::DATACORRUPTEDVETO);
817 
819 
820  //const AthenaAttributeList* attrList(0);
821  //ATH_CHECK( evtStore()->retrieve(attrList, "/TDAQ/RunCtrl/DataTakingMode") );
822  //if (attrList != 0) {
823  // ATH_MSG_DEBUG ("ReadyForPhysics is: " << (*attrList)["ReadyForPhysics"].data<uint32_t>());
824  // //m_valueCache = ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
825  // m_nt_atlasready = (*attrList)["ReadyForPhysics"].data<uint32_t>();
826  // }
827 
828  /*const AthenaAttributeList* fillstate(0);
829  sc = evtStore()->retrieve(fillstate, "/LHC/DCS/FILLSTATE");
830  if (sc.isFailure()) {
831  ATH_MSG_WARNING ("Unable to retrieve fillstate information; falling back to" );
832  return StatusCode::SUCCESS;
833  }
834  if (fillstate != 0) {
835  ATH_MSG_DEBUG ("Stable beams is: " << (*fillstate)["StableBeams"].data<uint32_t>());
836  //m_valueCache = ((*attrList)["ReadyForPhysics"].data<uint32_t>() != 0);
837  m_nt_stablebeams.push_back((*fillstate)["StableBeams"].data<uint32_t>());
838  }*/
839 
840 
841  // 29/11/10 : Debug messages removed by BT
842  // mLog << MSG::INFO << "Event LAr flags " << std::hex
843  // << eventInfo->errorState(xAOD::EventInfo::LAr) << " "
844  // << std::hex << eventInfo->eventFlags(xAOD::EventInfo::LAr)
845  // << ", bit 0: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,0)
846  // << ", bit 1: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,1)
847  // << ", bit 2: " << eventInfo->isEventFlagBitSet(xAOD::EventInfo::LAr,2)
848  // << endmsg;
849 
850  // Retrieve LArCollision Timing information
851  const LArCollisionTime * larTime=nullptr;
852  if (evtStore()->contains<LArCollisionTime>("LArCollisionTime")) {
853  StatusCode sc = evtStore()->retrieve(larTime,"LArCollisionTime");
854  if( sc.isFailure()){
855  ATH_MSG_WARNING ( "Unable to retrieve LArCollisionTime event store" );
856  //return StatusCode::SUCCESS; // Check if failure shd be returned. VB
857  }else {
858  ATH_MSG_DEBUG ( "LArCollisionTime successfully retrieved from event store" );
859  }
860  }
861 
862  if (larTime) {
863  m_nt_nCellA = larTime->ncellA();
864  m_nt_nCellC = larTime->ncellC();
865  if(m_nt_nCellA>0 && m_nt_nCellC>0){
866  // Calculate the time diff between ECC and ECA
867  m_nt_ECTimeDiff = larTime->timeC() - larTime->timeA();
868  m_nt_ECTimeAvg = (larTime->timeC() + larTime->timeA()) * 0.5;
869  ATH_MSG_DEBUG ( "LAr: Calculated time difference of " << m_nt_ECTimeDiff << " ns" );
870  }
871  }
872 
873  return StatusCode::SUCCESS;
874 }
875 
879 StatusCode LArNoiseBursts::doLArNoiseBursts(){
880  ATH_MSG_DEBUG ( "in doLarCellInfo " );
881  const EventContext& ctx = Gaudi::Hive::currentContext();
882 
883  SG::ReadCondHandle<LArOnOffIdMapping> larCablingHdl (m_cablingKey, ctx);
884  const LArOnOffIdMapping* cabling=*larCablingHdl;
885  if(!cabling) {
886  ATH_MSG_WARNING("Do not have cabling info, not storing LarCellInfo ");
887  return StatusCode::SUCCESS;
888  }
889 
890  SG::ReadCondHandle<LArBadChannelCont> bcHdl (m_BCKey, ctx);
891  const LArBadChannelCont* bcCont=*bcHdl;
892  if(!bcCont) {
893  ATH_MSG_WARNING("Do not have bad chan info, not storing LarCellInfo ");
894  return StatusCode::SUCCESS;
895  }
896 
897  SG::ReadCondHandle<CaloDetDescrManager> caloMgrHandle{m_caloMgrKey};
898  ATH_CHECK(caloMgrHandle.isValid());
899  const CaloDetDescrManager* caloMgr = *caloMgrHandle;
900 
901  // Retrieve LAr calocells container
902  // or LArRawChannel container, whatsever available...
903  const CaloCellContainer* caloTES=nullptr;
904  const LArRawChannelContainer* LArTES=nullptr;
905  const LArRawChannelContainer* LArTES_dig=nullptr;
906  if(evtStore()->contains<CaloCellContainer>("AllCalo")) {
907  ATH_CHECK(evtStore()->retrieve( caloTES, "AllCalo"));
908  } else if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels") || evtStore()->contains<LArRawChannelContainer>("LArRawChannels_fB")) {
909  if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels")) {
910  ATH_CHECK(evtStore()->retrieve( LArTES_dig, "LArRawChannels"));
911  }
912  if (evtStore()->contains<LArRawChannelContainer>("LArRawChannels_fB")) {
913  ATH_CHECK(evtStore()->retrieve( LArTES, "LArRawChannels_fB"));
914  }
915  }
916 
917  if (caloTES==nullptr && LArTES==nullptr) {
918  ATH_MSG_WARNING ( "Neither CaloCell nor LArRawChannel Containers found!" );
919  return StatusCode::SUCCESS;
920  }
921 
922  m_nb_sat = 0;
923  m_noisycell =0;
924  nlarcell = 0;
925  v_barrelec_noisy.clear(); v_posneg_noisy.clear();
926  v_ft_noisy.clear();v_slot_noisy.clear();v_channel_noisy.clear();
927  v_isbarrel.clear();v_isendcap.clear();v_isfcal.clear();v_ishec.clear();
928  v_layer.clear();v_partition.clear();v_energycell.clear();v_qfactorcell.clear();
929  v_phicell.clear();v_etacell.clear();v_signifcell.clear();v_isbadcell.clear();
930  v_IdHash.clear();v_noisycellHVeta.clear();v_noisycellHVphi.clear();
931  v_cellpartlayerindex.clear();v_cellIdentifier.clear();v_onlIdentifier.clear();
932 
933  float eCalo;
934  float qfactor;
935  CaloGain::CaloGain gain;
936 
937  SG::ReadCondHandle<CaloNoise> totalNoise (m_totalNoiseKey, ctx);
938 
939  if(caloTES) {
940  for (const CaloCell* cell : *caloTES) {
941  const CaloDetDescrElement* caloDDE = cell->caloDDE();
942  if (caloDDE->is_tile())continue;
943  HWIdentifier onlID;
944  try {onlID = cabling->createSignalChannelID(cell->ID());}
945  catch(LArID_Exception& except) {
946  ATH_MSG_ERROR ( "LArID_Exception " << m_LArEM_IDHelper->show_to_string(cell->ID()) << " " << (std::string) except );
947  ATH_MSG_ERROR ( "LArID_Exception " << m_LArHEC_IDHelper->show_to_string(cell->ID()) );
948  ATH_MSG_ERROR ( "LArID_Exception " << m_LArFCAL_IDHelper->show_to_string(cell->ID()) );
949  continue;
950  }
951  bool connected = cabling->isOnlineConnected(onlID);
952  if(!connected) continue;
953  eCalo = cell->energy();
954  qfactor = cell->quality();
955  gain = cell->gain();
956  //if(qfactor > 0. || cell->ID() == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cell->ID()<<" : "<<eCalo<<" "<<qfactor<<" "<<gain<<" prov.: "<<cell->provenance());
957  ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
958  }//loop over cells
959  ATH_MSG_DEBUG("Done cells "<<nlarcell);
960  } else {
961  std::vector<HWIdentifier> chdone;
962  if (LArTES_dig) {
963  LArRawChannelContainer::const_iterator caloItr;
964  for(caloItr=LArTES_dig->begin();caloItr!=LArTES_dig->end();++caloItr){
965  HWIdentifier onlID=caloItr->identify();
966  bool connected = cabling->isOnlineConnected(onlID);
967  if(!connected) continue;
968  eCalo = caloItr->energy();
969  qfactor = caloItr->quality();
970  gain = caloItr->gain();
971  //if(qfactor>0 || cabling->cnvToIdentifier((*caloItr).identify()) == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cabling->cnvToIdentifier((*caloItr).identify())<<" : "<<eCalo<<" "<<qfactor<<" "<<gain);
972  ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
973  chdone.push_back(onlID);
974  }//loop over raw channels
975  }
976  ATH_MSG_DEBUG("Done raw chan. from digi "<<nlarcell);
977  // dirty hack, if we are already complete:
978  if (nlarcell < 182468 && LArTES) { // add those raw channels, which were not from dig.
979  LArRawChannelContainer::const_iterator caloItr;
980  for(caloItr=LArTES->begin();caloItr!=LArTES->end();++caloItr){
981  HWIdentifier onlID=caloItr->identify();
982  if(std::find(chdone.begin(), chdone.end(), onlID) != chdone.end()) continue;
983  bool connected = cabling->isOnlineConnected(onlID);
984  if(!connected) continue;
985  eCalo = caloItr->energy();
986  qfactor = caloItr->quality();
987  gain = caloItr->gain();
988  //if(qfactor>0 || cabling->cnvToIdentifier((*caloItr).identify()) == Identifier((IDENTIFIER_TYPE)0x33c9500000000000) ) ATH_MSG_DEBUG(cabling->cnvToIdentifier((*caloItr).identify())<<" : "<<eCalo<<" "<<qfactor<<" "<<gain);
989  ATH_CHECK(fillCell(onlID, eCalo, qfactor, gain, cabling, bcCont, **totalNoise,caloMgr));
990  }//loop over raw channels
991  }
992  ATH_MSG_DEBUG("Done raw chan. "<<nlarcell);
993  } // if raw chanels
994 
995  m_nt_larcellsize = nlarcell;
996  if(caloTES) {
997  m_nt_cellsize = caloTES->size();
998  }
999  else if (LArTES) {
1000  m_nt_cellsize = LArTES->size();
1001  }
1002  ATH_MSG_DEBUG ("lar cell size = "<<int(nlarcell));
1003  if(caloTES) ATH_MSG_DEBUG ("all cell size = "<<int(caloTES->size()));
1004  else {
1005  if(LArTES_dig) ATH_MSG_DEBUG ("all LArRawCh. from digi size = "<<int(LArTES_dig->size()));
1006  if(LArTES) ATH_MSG_DEBUG ("all LArRawCh. size = "<<int(LArTES->size()));
1007  }
1008 
1009  //if (nlarcell > 0)
1010  // m_nt_noisycellpercent = 100.0*double(n_noisycell)/double(nlarcell);
1011  //else
1012  // m_nt_noisycellpercent = 0;
1013 
1014  bool checknoise = false;
1015  //ratio of noisy cells per partition
1016  for(unsigned int i=0;i<8;i++){
1017  float noise = 100.0*(double(n_noisy_cell_part[i])/double(n_cell_part[i]));
1018  m_nt_noisycellpart.push_back(noise);
1019  if(noise> 1.0){
1020  checknoise = true;
1021  ATH_MSG_DEBUG ("noise burst in this event ");
1022  }
1023  }
1024 
1025  const LArDigitContainer* LArDigitCont=nullptr;
1026  if (evtStore()->contains<LArDigitContainer>("FREE")) ATH_CHECK(evtStore()->retrieve( LArDigitCont, "FREE"));
1027  if(!LArDigitCont) {
1028  if (evtStore()->contains<LArDigitContainer>("LArDigitContainer_Thinned")) ATH_CHECK(evtStore()->retrieve( LArDigitCont, "LArDigitContainer_Thinned"));
1029  }
1030  if (!LArDigitCont) {
1031  ATH_MSG_WARNING ( "LArDigitContainer Container not found!" );
1032  return StatusCode::SUCCESS;
1033  }
1034 
1035  bool store_condition = false;
1036  // CosmicCalo stream : Store detailed infos of cells only if Y3Sigma>1% or burst found by LArNoisyRO
1037  if(m_CosmicCaloStream){
1038  if(checknoise==true || m_nt_larnoisyro==1 || m_nt_larnoisyro_satTwo==1){
1039  store_condition = true;
1040  }
1041  }
1042  // Not cosmicCalo stream : Store detailed infos of cells only if burst found by LArNoisyRO
1043  if(!m_CosmicCaloStream){
1044  if(m_nt_larnoisyro==1 || m_nt_larnoisyro_satTwo==1){
1045  store_condition = true;
1046  }
1047  }
1048 
1049  //store the information of the noisy cell only when %noisycells > 1%.
1050  if(store_condition){
1051  std::vector<short> samples;
1052  samples.clear();
1053  for(unsigned int k=0;k<v_etacell.size();k++){
1054  m_nt_samples.push_back(samples);
1055  m_nt_gain.push_back(0);
1056  }
1057  for (const LArDigit* pLArDigit : *LArDigitCont) {
1058  HWIdentifier id2 = pLArDigit->hardwareID();
1059  IdentifierHash hashid2 = m_LArOnlineIDHelper->channel_Hash(id2);
1060  for(unsigned int j=0;j<v_IdHash.size();j++){
1061  if (hashid2 == v_IdHash[j] ){
1062  ATH_MSG_DEBUG ( "find a IdentifierHash of the noisy cell in LArDigit container " );
1063  samples = pLArDigit->samples();
1064  int gain=-1;
1065  if (pLArDigit->gain() == CaloGain::LARHIGHGAIN) gain = 0;
1066  if (pLArDigit->gain() == CaloGain::LARMEDIUMGAIN) gain = 1;
1067  if (pLArDigit->gain() == CaloGain::LARLOWGAIN) gain = 2;
1068  m_nt_gain.at(j)= gain;
1069  m_nt_samples.at(j) = samples;
1070  ATH_MSG_DEBUG ( "I got the samples!" );
1071  break;
1072  }
1073  }
1074  }
1075  for(unsigned int i=0;i<v_etacell.size();i++){
1076  m_nt_energycell.push_back( v_energycell[i]);
1077  m_nt_qfactorcell.push_back( v_qfactorcell[i]);
1078  m_nt_signifcell.push_back( v_signifcell[i]);
1079  m_nt_partition.push_back( v_partition[i]);
1080  m_nt_cellIdentifier.push_back(v_cellIdentifier[i].get_identifier32().get_compact());
1081  m_nt_onlIdentifier.push_back(v_onlIdentifier[i].get_identifier32().get_compact());
1082  if(!m_keepOnlyCellID){
1083  m_nt_barrelec_noisy.push_back( v_barrelec_noisy[i]);
1084  m_nt_posneg_noisy.push_back( v_posneg_noisy[i]);
1085  m_nt_ft_noisy.push_back( v_ft_noisy[i]);
1086  m_nt_slot_noisy.push_back( v_slot_noisy[i]);
1087  m_nt_channel_noisy.push_back( v_channel_noisy[i]);
1088 
1089  /*
1090  m_nt_isbarrel.push_back( v_isbarrel[i]);
1091  m_nt_isendcap.push_back( v_isendcap[i]);
1092  m_nt_isfcal.push_back( v_isfcal[i]);
1093  m_nt_ishec.push_back( v_ishec[i]);
1094  */
1095 
1096  m_nt_layer.push_back( v_layer[i]);
1097  m_nt_phicell.push_back( v_phicell[i]);
1098  m_nt_etacell.push_back( v_etacell[i]);
1099  m_nt_isbadcell.push_back( v_isbadcell[i]);
1100  m_nt_noisycellHVphi.push_back(v_noisycellHVphi[i]);
1101  m_nt_noisycellHVeta.push_back(v_noisycellHVeta[i]);
1102  m_nt_cellpartlayerindex.push_back(v_cellpartlayerindex[i]);
1103  }
1104  }
1105  ATH_MSG_DEBUG ("leaving if checknoise and larnoisyro");
1106 
1107  }//if(checknoisy==true ..)
1108 
1109  return StatusCode::SUCCESS;
1110 
1111 }
1112 
1113 StatusCode LArNoiseBursts::fillCell(HWIdentifier onlID
1114  , float eCalo
1115  , float qfactor
1116  , CaloGain::CaloGain gain
1117  , const LArOnOffIdMapping* cabling
1118  , const LArBadChannelCont* bcCont
1119  , const CaloNoise& totalNoise
1120  , const CaloDetDescrManager* caloMgr)
1121 {
1122  const Identifier idd = cabling->cnvToIdentifier(onlID);
1123  nlarcell++;
1124  IdentifierHash channelHash = m_LArOnlineIDHelper->channel_Hash(onlID);
1125  const CaloDetDescrElement *caloDDE = caloMgr->get_element(idd);
1126  int layer = caloDDE->getLayer();
1127  // CaloCell_ID::CaloSample sampling = (*caloItr)->caloDDE()->getSampling();
1128  float phi = caloDDE->phi();
1129  float noise = totalNoise.getNoise (idd, gain);
1130  float significance = eCalo / noise ;
1131  float eta = caloDDE->eta();
1132  bool badcell = ! (bcCont->status(onlID)).good();
1133  unsigned int partition = 0;
1134  bool is_lar_em_barrel = caloDDE->is_lar_em_barrel();
1135  if(is_lar_em_barrel){
1136  if(eta<0){
1137  partition = 0;
1138  }else{
1139  partition = 1;
1140  }
1141  }//barrel
1142  bool is_lar_em_endcap = caloDDE->is_lar_em_endcap();
1143  if(is_lar_em_endcap){
1144  if(eta<0){
1145  partition = 2;
1146  }else{
1147  partition = 3;
1148  }
1149  }//endcap
1150  bool is_lar_fcal = caloDDE->is_lar_fcal();
1151  if(is_lar_fcal){
1152  if(eta<0){
1153  partition = 4;
1154  }else{
1155  partition = 5;
1156  }
1157  }//fcal
1158  bool is_lar_hec = caloDDE->is_lar_hec();
1159  if(is_lar_hec){
1160  if(eta<0){
1161  partition = 6;
1162  }else{
1163  partition = 7;
1164  }
1165  }//hec
1166  for(unsigned int k=0;k<8;k++){
1167  if(partition==k){
1168  n_cell_part[k]++;
1169  }
1170  }
1171  if(qfactor <1000) {m_lowqfactor++;}
1172  if(qfactor>=1000 && qfactor<10000) {m_medqfactor++;}
1173  if(qfactor>=10000 && qfactor<65535){m_hiqfactor++;}
1174  if(qfactor==65535){
1175  ATH_MSG_DEBUG ("Satured cell at eta: "<<eta<<", phi: "<<phi<<", energy: "<<eCalo<<", partition: "<<partition);
1176  m_nb_sat = m_nb_sat +1;
1177  m_nt_partition_sat.push_back(partition);
1178  m_nt_energy_sat.push_back(eCalo);
1179  m_nt_cellIdentifier_sat.push_back((cabling->cnvToIdentifier(onlID)).get_identifier32().get_compact());
1180  if(!m_keepOnlyCellID){
1181  m_nt_barrelec_sat.push_back(m_LArOnlineIDHelper->barrel_ec(onlID));
1182  m_nt_posneg_sat.push_back(m_LArOnlineIDHelper->pos_neg(onlID));
1183  m_nt_ft_sat.push_back(m_LArOnlineIDHelper->feedthrough(onlID));
1184  m_nt_slot_sat.push_back(m_LArOnlineIDHelper->slot(onlID));
1185  m_nt_channel_sat.push_back(m_LArOnlineIDHelper->channel(onlID));
1186  m_nt_phicell_sat.push_back(phi);
1187  m_nt_etacell_sat.push_back(eta);
1188  m_nt_layer_sat.push_back(layer);
1189  m_nt_isbadcell_sat.push_back(badcell);
1190  }
1191  }
1192  // Store all cells in positive and negative 3 sigma tails...
1193  if(significance > m_sigmacut || qfactor > 4000){
1194  v_barrelec_noisy.push_back(m_LArOnlineIDHelper->barrel_ec(onlID));
1195  v_posneg_noisy.push_back(m_LArOnlineIDHelper->pos_neg(onlID));
1196  v_ft_noisy.push_back(m_LArOnlineIDHelper->feedthrough(onlID));
1197  v_slot_noisy.push_back(m_LArOnlineIDHelper->slot(onlID));
1198  v_channel_noisy.push_back(m_LArOnlineIDHelper->channel(onlID));
1199 
1200  /*
1201  v_isbarrel.push_back(is_lar_em_barrel);
1202  v_isendcap.push_back(is_lar_em_endcap);
1203  v_isfcal.push_back(is_lar_fcal);
1204  v_ishec.push_back(is_lar_hec);
1205  */
1206 
1207  v_layer.push_back(layer);
1208  v_energycell.push_back(eCalo);
1209  v_qfactorcell.push_back(qfactor);
1210  v_phicell.push_back(phi);
1211  v_etacell.push_back(eta);
1212  v_signifcell.push_back(significance);
1213  v_isbadcell.push_back(badcell);
1214  v_partition.push_back(partition);
1215  v_IdHash.push_back(channelHash);
1216  v_cellIdentifier.push_back(cabling->cnvToIdentifier(onlID));
1217  v_onlIdentifier.push_back(onlID);
1218  // ...but count only cells in positive 3 sigma tails!
1219  if (significance > m_sigmacut){
1220  m_noisycell++;
1221  ATH_MSG_DEBUG ("Noisy cell: "<<m_noisycell<<" "<<cabling->cnvToIdentifier(onlID)<<" q: "<<qfactor<<" sign.: "<<significance<<" noise: "<<noise);
1222  for(unsigned int k=0;k<8;k++){
1223  if(partition==k){
1224  n_noisy_cell_part[k]++;
1225  }
1226  }
1227  }
1228  int caloindex = GetPartitionLayerIndex(idd);
1229  v_cellpartlayerindex.push_back(caloindex);
1230  v_noisycellHVphi.push_back(m_LArElectrodeIDHelper->hv_phi(onlID));
1231  v_noisycellHVeta.push_back(m_LArElectrodeIDHelper->hv_eta(onlID));
1232 
1233 
1234  }
1235  return StatusCode::SUCCESS;
1236 }
1240 StatusCode LArNoiseBursts::doPhysicsObjects(){
1241  ATH_MSG_DEBUG ("in doPhysicsObjects ");
1242 
1243 // const ElectronContainer* elecTES = 0;
1244 // StatusCode sc=evtStore()->retrieve( elecTES, m_elecContainerName);
1245 // if( sc.isFailure() || !elecTES ) {
1246 // ATH_MSG_WARNING ( "No ESD electron container found in StoreGate" );
1247 // return StatusCode::SUCCESS;
1248 // }
1249 // ATH_MSG_DEBUG ( "ElectronContainer successfully retrieved. Size = " << elecTES->size() );
1250 
1251  return StatusCode::SUCCESS;
1252 }
1253 
1254 
1255 //
1256 
1257 int LArNoiseBursts::GetPartitionLayerIndex(const Identifier& id)
1258 {
1259  // O.Simard -- GetPartitionLayer index [0,32]:
1260  // Returns a single integer code that corresponds to the
1261  // mapping of CaloCells in CaloMonitoring histogram frames.
1262 
1263  int caloindex = -1;
1264  int bc = 0;
1265  int sampling = 0;
1266 
1267  if(m_LArEM_IDHelper->is_lar_em(id)){ // EMB
1268  bc = m_LArEM_IDHelper->barrel_ec(id);
1269  sampling = m_LArEM_IDHelper->sampling(id);
1270  if(abs(bc)==1){
1271  if(bc<0) caloindex = sampling+4;
1272  else caloindex = sampling;
1273  } else { // EMEC
1274  if(bc<0) caloindex = sampling+12;
1275  else caloindex = sampling+8;
1276  }
1277  } else if(m_LArHEC_IDHelper->is_lar_hec(id)) { // LAr HEC
1278  bc = m_LArHEC_IDHelper->pos_neg(id);
1279  sampling = m_LArHEC_IDHelper->sampling(id);
1280  if(bc<0) caloindex = sampling+20;
1281  else caloindex = sampling+16;
1282  } else if(m_LArFCAL_IDHelper->is_lar_fcal(id)) { // LAr FCAL
1283  bc = m_LArFCAL_IDHelper->pos_neg(id);
1284  sampling = (int)m_LArFCAL_IDHelper->module(id); // module instead of sampling
1285  if(bc<0) caloindex = sampling+26;
1286  else caloindex = sampling+23;
1287  }
1288 
1289  return caloindex;
1290 }
1291 
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:254
LArNoiseBursts::finalize
virtual StatusCode finalize() override
Finalize - delete any memory allocation from the heap.
Definition: LArNoiseBursts.cxx:382
LArNoiseBursts::m_cablingKey
SG::ReadCondHandleKey< LArOnOffIdMapping > m_cablingKey
Definition: LArNoiseBursts.h:94
v_phicell
std::vector< float > v_phicell
Definition: LArNoiseBursts.cxx:74
LArNoiseBursts::m_nt_channel_sat
std::vector< short > m_nt_channel_sat
Definition: LArNoiseBursts.h:251
LArNoiseBursts::m_nt_signifcell
std::vector< float > m_nt_signifcell
Definition: LArNoiseBursts.h:218
LArNoiseBursts::m_BCKey
SG::ReadCondHandleKey< LArBadChannelCont > m_BCKey
Definition: LArNoiseBursts.h:95
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:231
LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurstT
bool m_nt_EF_j165_u0uchad_LArNoiseBurstT
Definition: LArNoiseBursts.h:200
LArNoiseBursts::m_nt_qfactorcell
std::vector< float > m_nt_qfactorcell
Definition: LArNoiseBursts.h:215
LArNoiseBursts::m_nt_partition
std::vector< int > m_nt_partition
Definition: LArNoiseBursts.h:242
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:249
LArEM_ID.h
v_isfcal
std::vector< bool > v_isfcal
Definition: LArNoiseBursts.cxx:70
BunchCrossingCondData
Definition: BunchCrossingCondData.h:23
ReadCellNoiseFromCool.cell
cell
Definition: ReadCellNoiseFromCool.py:53
LArNoiseBursts::m_thistSvc
ServiceHandle< ITHistSvc > m_thistSvc
Definition: LArNoiseBursts.h:90
LArNoiseBursts::m_nt_atlasready
unsigned int m_nt_atlasready
Definition: LArNoiseBursts.h:145
phi
Scalar phi() const
phi method
Definition: AmgMatrixBasePlugin.h:67
CondAttrListCollection.h
This file defines the class for a collection of AttributeLists where each one is associated with a ch...
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
LArNoiseBursts::m_nt_L1_J75
bool m_nt_L1_J75
Definition: LArNoiseBursts.h:182
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:179
xAOD::EventInfo_v1::eventNumber
uint64_t eventNumber() const
The current event's event number.
v_barrelec_noisy
std::vector< short > v_barrelec_noisy
Definition: LArNoiseBursts.cxx:69
AtlasDetectorID::is_lar_fcal
bool is_lar_fcal(Identifier id) const
Definition: AtlasDetectorID.h:839
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
LArNoiseBursts::m_nt_barrelec_noisy
std::vector< short > m_nt_barrelec_noisy
Definition: LArNoiseBursts.h:220
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
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:73
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:227
LArNoiseBursts::m_nt_posneg_noisy
std::vector< short > m_nt_posneg_noisy
Definition: LArNoiseBursts.h:221
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:224
LArID_Exception.h
v_cellpartlayerindex
std::vector< int > v_cellpartlayerindex
Definition: LArNoiseBursts.cxx:77
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:201
Range.h
ReadCellNoiseFromCool.cabling
cabling
Definition: ReadCellNoiseFromCool.py:154
LArNoiseBursts::m_nt_evtId
unsigned long m_nt_evtId
Definition: LArNoiseBursts.h:134
LArNoiseBursts::m_nt_energycell
std::vector< float > m_nt_energycell
Definition: LArNoiseBursts.h:214
n_noisy_cell_part
int n_noisy_cell_part[8]
Definition: LArNoiseBursts.cxx:67
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:879
LArNoiseBursts::m_nt_L1_XE50_BGRP7
bool m_nt_L1_XE50_BGRP7
Definition: LArNoiseBursts.h:188
LArEventBitInfo::DATACORRUPTED
@ DATACORRUPTED
Definition: LArEventBitInfo.h:14
LArFCAL_Base_ID::module
int module(const Identifier id) const
module [1,3]
LArEventBitInfo::BADFEBS
@ BADFEBS
Definition: LArEventBitInfo.h:10
LArNoiseBursts::m_nt_larmnbnoisy
short m_nt_larmnbnoisy
Definition: LArNoiseBursts.h:152
v_cellIdentifier
std::vector< Identifier > v_cellIdentifier
Definition: LArNoiseBursts.cxx:78
LArNoiseBursts::doEventProperties
StatusCode doEventProperties()
Definition: LArNoiseBursts.cxx:686
LArNoiseBursts::m_nt_L1_XE50
bool m_nt_L1_XE50
Definition: LArNoiseBursts.h:187
LArEM_Base_ID::sampling
int sampling(const Identifier id) const
return sampling according to :
LArNoiseBursts::LArNoiseBursts
LArNoiseBursts(const std::string &name, ISvcLocator *pSvcLocator)
Constructor.
Definition: LArNoiseBursts.cxx:85
v_isendcap
std::vector< bool > v_isendcap
Definition: LArNoiseBursts.cxx:70
LArNoiseBursts::m_nt_posneg_sat
std::vector< int > m_nt_posneg_sat
Definition: LArNoiseBursts.h:248
LArNoiseBursts::m_nt_larnoisyro
short m_nt_larnoisyro
Definition: LArNoiseBursts.h:149
v_isbarrel
std::vector< bool > v_isbarrel
Definition: LArNoiseBursts.cxx:70
LArNoiseBursts::m_nt_cellIdentifier
std::vector< unsigned int > m_nt_cellIdentifier
Definition: LArNoiseBursts.h:226
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:106
LArNoiseBursts::m_nt_larflag_badFEBs
bool m_nt_larflag_badFEBs
Definition: LArNoiseBursts.h:174
LArNoiseBursts::m_nt_larflag_mediumSaturatedDQ
bool m_nt_larflag_mediumSaturatedDQ
Definition: LArNoiseBursts.h:175
xAOD::EventInfo_v1::timeStampNSOffset
uint32_t timeStampNSOffset() const
Nanosecond time offset wrt. the time stamp.
LArNoiseBursts::m_nt_larflag_tightSaturatedDQ
bool m_nt_larflag_tightSaturatedDQ
Definition: LArNoiseBursts.h:176
LArHEC_ID.h
LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst
bool m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurst
Definition: LArNoiseBursts.h:193
v_onlIdentifier
std::vector< HWIdentifier > v_onlIdentifier
Definition: LArNoiseBursts.cxx:79
LArHVLineID.h
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:257
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:72
AthenaAttributeList.h
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:189
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:97
xAOD::EventInfo_v1::runNumber
uint32_t runNumber() const
The current event's run number.
ReadCondHandle.h
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::execute
virtual StatusCode execute() override
Execute - on event by event.
Definition: LArNoiseBursts.cxx:542
LArEventBitInfo.h
LArNoiseBursts::m_nt_cellsize
int m_nt_cellsize
Definition: LArNoiseBursts.h:132
CaloCell_ID.h
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
LArNoiseBursts::doPhysicsObjects
StatusCode doPhysicsObjects()
Definition: LArNoiseBursts.cxx:1240
LArNoiseBursts::m_nt_nCellA
int m_nt_nCellA
Definition: LArNoiseBursts.h:209
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:203
v_partition
std::vector< int > v_partition
Definition: LArNoiseBursts.cxx:72
LArNoiseBursts::m_nt_ECTimeAvg
float m_nt_ECTimeAvg
Definition: LArNoiseBursts.h:208
LArNoiseBursts::m_nt_larflag_noiseBurstVeto
bool m_nt_larflag_noiseBurstVeto
Definition: LArNoiseBursts.h:177
LArNoiseBursts::m_nt_slot_noisy
std::vector< short > m_nt_slot_noisy
Definition: LArNoiseBursts.h:223
LArNoiseBursts::m_nt_partition_sat
std::vector< int > m_nt_partition_sat
Definition: LArNoiseBursts.h:252
LArCollisionTime::ncellC
int ncellC() const
get number of cells for time C side
Definition: LArCollisionTime.h:33
AthCommonDataStore< AthCommonMsg< Algorithm > >::evtStore
ServiceHandle< StoreGateSvc > & evtStore()
The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:85
LArEventBitInfo::NOISEBURSTVETO
@ NOISEBURSTVETO
Definition: LArEventBitInfo.h:13
LArNoiseBursts::m_nt_noisycellHVphi
std::vector< int > m_nt_noisycellHVphi
Definition: LArNoiseBursts.h:229
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:255
LArEventBitInfo::TIGHTSATURATEDQ
@ TIGHTSATURATEDQ
Definition: LArEventBitInfo.h:12
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
LArDigit.h
id2
HWIdentifier id2
Definition: LArRodBlockPhysicsV0.cxx:562
LArNoiseBursts::m_nt_EF_xe55_LArNoiseBurst
bool m_nt_EF_xe55_LArNoiseBurst
Definition: LArNoiseBursts.h:196
LArNoiseBursts::m_nt_L1_XE40
bool m_nt_L1_XE40
Definition: LArNoiseBursts.h:186
LArDigit
Liquid Argon digit base class.
Definition: LArDigit.h:25
LArNoiseBursts::m_tree
TTree * m_tree
Definition: LArNoiseBursts.h:92
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:1113
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:195
LArNoiseBursts::m_nt_layer
std::vector< int > m_nt_layer
Definition: LArNoiseBursts.h:243
LArNoiseBursts::m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT
bool m_nt_EF_j55_u0uchad_firstempty_LArNoiseBurstT
Definition: LArNoiseBursts.h:198
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
LArNoiseBursts::m_nt_ECTimeDiff
float m_nt_ECTimeDiff
Definition: LArNoiseBursts.h:207
LArNoiseBursts::m_nt_cellpartlayerindex
std::vector< short > m_nt_cellpartlayerindex
Definition: LArNoiseBursts.h:225
LArNoiseBursts::m_nt_EF_j100_u0uchad_LArNoiseBurstT
bool m_nt_EF_j100_u0uchad_LArNoiseBurstT
Definition: LArNoiseBursts.h:199
INavigable4MomentumCollection.h
v_IdHash
std::vector< IdentifierHash > v_IdHash
Definition: LArNoiseBursts.cxx:76
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:204
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:70
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
xAOD::double
double
Definition: CompositeParticle_v1.cxx:159
CaloDetDescrElement::is_lar_fcal
bool is_lar_fcal() const
cell belongs to FCAL
Definition: CaloDetDescrElement.cxx:138
LArNoiseBursts::GetPartitionLayerIndex
int GetPartitionLayerIndex(const Identifier &id)
Definition: LArNoiseBursts.cxx:1257
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
CaloDM_ID.h
AthAlgorithm
Definition: AthAlgorithm.h:47
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:228
LArEventBitInfo::MININOISEBURSTLOOSE
@ MININOISEBURSTLOOSE
Definition: LArEventBitInfo.h:17
LArNoiseBursts::m_nt_L1_J30_EMPTY
bool m_nt_L1_J30_EMPTY
Definition: LArNoiseBursts.h:185
BunchCrossingCondData::distanceFromFront
int distanceFromFront(const bcid_type bcid, const BunchDistanceType type=NanoSec) const
The distance of the specific bunch crossing from the front of the train.
Definition: BunchCrossingCondData.cxx:35
LArNoiseBursts::initialize
virtual StatusCode initialize() override
Definition: LArNoiseBursts.cxx:216
CaloDetDescrElement::is_tile
bool is_tile() const
cell belongs to Tile
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:442
CaloNoise
Definition: CaloNoise.h:16
LArNoiseBursts::m_nt_EF_j55_u0uchad_empty_LArNoiseBurst
bool m_nt_EF_j55_u0uchad_empty_LArNoiseBurst
Definition: LArNoiseBursts.h:194
LArNoiseBursts::m_nt_L1_J10_EMPTY
bool m_nt_L1_J10_EMPTY
Definition: LArNoiseBursts.h:183
v_posneg_noisy
std::vector< short > v_posneg_noisy
Definition: LArNoiseBursts.cxx:69
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:72
LArNoiseBursts::m_nt_energy_sat
std::vector< float > m_nt_energy_sat
Definition: LArNoiseBursts.h:253
LArNoiseBursts::m_frontbunches
unsigned int m_frontbunches
Definition: LArNoiseBursts.h:122
HWIdentifier.h
LArNoiseBursts::m_nt_layer_sat
std::vector< int > m_nt_layer_sat
Definition: LArNoiseBursts.h:256
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:221
IdentifierHash.h
LArNoiseBursts::m_trigDec
PublicToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: LArNoiseBursts.h:101
v_slot_noisy
std::vector< short > v_slot_noisy
Definition: LArNoiseBursts.cxx:69
LArNoiseBursts::m_nt_bunchtype
int m_nt_bunchtype
Definition: LArNoiseBursts.h:143
CaloNoise.h
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:586
nlarcell
int nlarcell
Definition: LArNoiseBursts.cxx:66
LArNoisyROSummary.h
LArNoiseBursts::m_bcDataKey
SG::ReadCondHandleKey< BunchCrossingCondData > m_bcDataKey
Definition: LArNoiseBursts.h:99
v_signifcell
std::vector< float > v_signifcell
Definition: LArNoiseBursts.cxx:73
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
LArOnlineID
Definition: LArOnlineID.h:20
CaloGain::LARHIGHGAIN
@ LARHIGHGAIN
Definition: CaloGain.h:18
LArDigitContainer.h
LArNoiseBursts::m_nt_barrelec_sat
std::vector< int > m_nt_barrelec_sat
Definition: LArNoiseBursts.h:247
CaloCellContainer.h
CaloCellContainer
Container class for CaloCell.
Definition: CaloCellContainer.h:55
LArNoiseBursts::m_nt_isbadcell
std::vector< int > m_nt_isbadcell
Definition: LArNoiseBursts.h:233
LArNoiseBursts::m_nt_L1_J30_FIRSTEMPTY
bool m_nt_L1_J30_FIRSTEMPTY
Definition: LArNoiseBursts.h:184
EventInfo.h
CaloGain::CaloGain
CaloGain
Definition: CaloGain.h:11
LArNoiseBursts::m_nt_phicell
std::vector< float > m_nt_phicell
Definition: LArNoiseBursts.h:216
BunchCrossingCondData::isInTrain
bool isInTrain(const bcid_type bcid) const
Function deciding if a given bunch crossing is in a filled train.
Definition: BunchCrossingCondData.h:376
xAOD::EventInfo_v1
Class describing the basic event information.
Definition: EventInfo_v1.h:43
xAOD::EventInfo_v1::streamTags
const std::vector< StreamTag > & streamTags() const
Get the streams that the event was put in.
Definition: EventInfo_v1.cxx:283
LArCollisionTime::ncellA
int ncellA() const
get number of cells for time A side
Definition: LArCollisionTime.h:30
LArFCAL_ID.h
CaloGain::LARMEDIUMGAIN
@ LARMEDIUMGAIN
Definition: CaloGain.h:18
CaloDetDescrElement::is_lar_em_barrel
bool is_lar_em_barrel() const
cell belongs to EM barrel
Definition: CaloDetDescrElement.cxx:98
LArOnlineID_Base::feedthrough
int feedthrough(const HWIdentifier id) const
Return the feedthrough of a hardware cell identifier : feedthrough = [0,31] Barrel - A/C side or H/...
Definition: LArOnlineID_Base.cxx:1944
ReadBchFromCool.good
good
Definition: ReadBchFromCool.py:433
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:85
CaloLVL1_ID.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
AtlasDetectorID::show_to_string
std::string show_to_string(Identifier id, const IdContext *context=0, char sep='.') const
or provide the printout in string form
Definition: AtlasDetectorID.cxx:574
v_etacell
std::vector< float > v_etacell
Definition: LArNoiseBursts.cxx:74
CaloSwCorrections.time
def time(flags, cells_name, *args, **kw)
Definition: CaloSwCorrections.py:242
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
LArNoiseBursts::m_nt_larnoisyro_satTwo
short m_nt_larnoisyro_satTwo
Definition: LArNoiseBursts.h:151
LArNoiseBursts::m_nt_nCellC
int m_nt_nCellC
Definition: LArNoiseBursts.h:210
LArNoiseBursts::m_nt_etacell
std::vector< float > m_nt_etacell
Definition: LArNoiseBursts.h:217
LArNoiseBursts::m_nt_gain
std::vector< int > m_nt_gain
Definition: LArNoiseBursts.h:232
LArMiniFCAL_ID.h
BunchCrossingCondData::bcType
BunchCrossingType bcType(const bcid_type bcid) const
Convenience function for the type of the specific bunch crossing.
Definition: BunchCrossingCondData.cxx:195
LArNoiseBursts::m_LArHVLineIDHelper
const LArHVLineID * m_LArHVLineIDHelper
Definition: LArNoiseBursts.h:105
LArNoiseBursts::m_nt_run
int m_nt_run
Definition: LArNoiseBursts.h:133
n_cell_part
int n_cell_part[8]
Definition: LArNoiseBursts.cxx:68
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:73
LArNoiseBursts::m_nt_larflag_dataCorrupted
bool m_nt_larflag_dataCorrupted
Definition: LArNoiseBursts.h:178
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)
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
xAOD::EventInfo_v1::timeStamp
uint32_t timeStamp() const
POSIX time in seconds from 1970. January 1st.
xAOD::EventInfo_v1::isEventFlagBitSet
bool isEventFlagBitSet(EventFlagSubDet subDet, size_t bit) const
Check one particular bit of one particular sub-detector.
Definition: EventInfo_v1.cxx:703
IParticleContainer.h
CaloDetDescrElement::eta
float eta() const
cell eta
Definition: Calorimeter/CaloDetDescr/CaloDetDescr/CaloDetDescrElement.h:344
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:197
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
LArElectrodeID.h
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:246
LArCollisionTime.h
LArNoiseBursts::m_nt_ft_noisy
std::vector< short > m_nt_ft_noisy
Definition: LArNoiseBursts.h:222
CaloGain::LARLOWGAIN
@ LARLOWGAIN
Definition: CaloGain.h:18
LArEventBitInfo::DATACORRUPTEDVETO
@ DATACORRUPTEDVETO
Definition: LArEventBitInfo.h:15
CaloDetDescrElement::is_lar_hec
bool is_lar_hec() const
cell belongs to HEC
Definition: CaloDetDescrElement.cxx:130
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
LArNoiseBursts::m_nt_EF_j35_u0uchad_empty_LArNoiseBurst
bool m_nt_EF_j35_u0uchad_empty_LArNoiseBurst
Definition: LArNoiseBursts.h:202
LArNoiseBursts::m_nt_isbcidInTrain
int m_nt_isbcidInTrain
Definition: LArNoiseBursts.h:141
v_ft_noisy
std::vector< short > v_ft_noisy
Definition: LArNoiseBursts.cxx:69
v_channel_noisy
std::vector< short > v_channel_noisy
Definition: LArNoiseBursts.cxx:69
LArNoiseBursts.h
AtlasDetectorID::is_lar_em
bool is_lar_em(Identifier id) const
Definition: AtlasDetectorID.h:818
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
LArNoiseBursts::m_nt_larmnbnoisy_sat
short m_nt_larmnbnoisy_sat
Definition: LArNoiseBursts.h:153
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:75
LArNoiseBursts::m_nt_EF_j165_u0uchad_LArNoiseBurst
bool m_nt_EF_j165_u0uchad_LArNoiseBurst
Definition: LArNoiseBursts.h:191
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
WriteCellNoiseToCool.noise
noise
Definition: WriteCellNoiseToCool.py:380
LArRawChannelContainer.h
LArNoiseBursts::m_nt_larnoisyro_opt
short m_nt_larnoisyro_opt
Definition: LArNoiseBursts.h:150
LArNoiseBursts::m_nt_noisycellHVeta
std::vector< int > m_nt_noisycellHVeta
Definition: LArNoiseBursts.h:230
CaloDetectorElements.h
Calo Subsystem specific Detector Elements + Dummy element for testing.
v_layer
std::vector< short > v_layer
Definition: LArNoiseBursts.cxx:71
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
LArOnlineID.h
LArRawChannelContainer
Container for LArRawChannel (IDC using LArRawChannelCollection)
Definition: LArRawChannelContainer.h:26
LArNoiseBursts::m_nt_slot_sat
std::vector< short > m_nt_slot_sat
Definition: LArNoiseBursts.h:250
LArNoiseBursts::m_nt_EF_j30_u0uchad_empty_LArNoiseBurst
bool m_nt_EF_j30_u0uchad_empty_LArNoiseBurst
Definition: LArNoiseBursts.h:192
Identifier
Definition: IdentifierFieldParser.cxx:14
LArNoiseBursts::clear
virtual StatusCode clear()
Clear - clear CBNT members.
Definition: LArNoiseBursts.cxx:389
LArHVLineID
Helper for the Liquid Argon Calorimeter High-Voltage identifiers.
Definition: LArHVLineID.h:48
Generated on Thu Nov 7 2024 21:19:46 for ATLAS Offline Software by   doxygen 1.8.18