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