ATLAS Offline Software
BackgroundWordFiller.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 /* Algorihtm to fill the background word that is stored in the EventInfo
6 
7 background word contains:
8 =========================
9 MBTSTimeDiffHalo, MBTSTimeDiffCol, // these bits are set in
10 MBTSTimeDiffEventInfoAlg due to ordering reasons.... MBTSBeamVeto
11 LArECTimeDiffHalo, LArECTimeDiffCol
12 PixMultiplicityHuge, PixSPNonEmpty,
13 SCTMultiplicityHuge, SCTSPNonEmpty
14 CSCTimeDiffHalo, CSCTimeDiffCol
15 BCMTimeDiffHalo, BCMTimeDiffCol, BCMBeamVeto
16 MuonTimingCol, MuonTimingCosmic,
17 LUCIDBeamVeto
18 
19 Jamie Boyd 7/2/2010
20 
21 added for 2012 in addition to above:
22 ====================================
23 HaloMuonSegment, HaloClusterShape,
24 HaloMuonOneSided, HaloMuonTwoSided,
25 HaloTileClusterPattern,
26 BeamGasPixel,
27 CosmicStandAlone, CosmicStandAloneTight,
28 CosmicCombined, CosmicCombinedTight,
29 BkgdResvBit1, BkgdResvBit2,
30 BkgdResvBit3, BkgdResvBit4,
31 BkgdResvBit5,
32 
33 Mark Tibbetts 6/3/2012
34 
35 */
36 
37 #include "BackgroundWordFiller.h"
38 
39 #include "TileEvent/MBTSCollisionTime.h"
40 
41 //----------------------------------------------------------------
42 
43 using xAOD::EventInfo;
44 
45 BackgroundWordFiller::BackgroundWordFiller(const std::string& name,
46  ISvcLocator* pSvcLocator)
47  : AthAlgorithm(name, pSvcLocator),
48  m_HaloNumSegment_Cut(0),
49  m_HaloNumClusterShape_Cut(0),
50  m_HaloNumOneSidedLoose_Cut(0),
51  m_HaloNumTwoSided_Cut(0),
52  m_PixMultiplicityHuge_Cut(0),
53  m_PixSPNonEmpty_Cut(0),
54  m_SCTMultiplicityHuge_Cut(0),
55  m_SCTSPNonEmpty_Cut(0),
56  m_LUCIDBeamVeto_Cut(0),
57  m_BCMTimeDiffCol_Cut(0),
58  m_BCMTimeDiffHalo_CutLo(0),
59  m_BCMHiGainCut(0),
60  m_BCMLowGainCut(0),
61  m_MBTSBeamVeto_MultiplicityCut(0),
62  m_MBTSBeamVeto_TimeCut(0),
63  m_MBTSBeamVeto_ThresholdCut(0),
64  m_MBTSmask(TileCell::MASK_BADCH | TileCell::MASK_OVER |
65  TileCell::MASK_TIME),
66  m_MBTSpattern(TileCell::MASK_TIME),
67  m_LArEC_SideCut(0),
68  m_LArECTimeDiffCol_Cut(0),
69  m_LArECTimeDiffHalo_CutLo(0),
70  m_LArECTimeDiffHalo_CutHi(0),
71  m_totalcnt(0),
72  m_bitnamevec{{"MBTSTimeDiffHalo", "MBTSTimeDiffCol",
73  "LArECTimeDiffHalo", "LArECTimeDiffCol",
74  "PixMultiplicityHuge", "PixSPNonEmpty",
75  "SCTMultiplicityHuge", "SCTSPNonEmpty",
76  "CSCTimeDiffHalo", "CSCTimeDiffCol",
77  "BCMTimeDiffHalo", "BCMTimeDiffCol",
78  "MuonTimingCol", "MuonTimingCosmic",
79  "MBTSBeamVeto", "BCMBeamVeto",
80  "LUCIDBeamVeto", "HaloMuonSegment",
81  "HaloClusterShape", "HaloMuonOneSided",
82  "HaloMuonTwoSided", "HaloTileClusterPattern",
83  "BeamGasPixel", "CosmicStandAlone",
84  "CosmicStandAloneTight", "CosmicCombined",
85  "CosmicCombinedTight", "BkgdResvBit1",
86  "BkgdResvBit2", "BkgdResvBit3",
87  "BkgdResvBit4", "BkgdResvBit5"}}
88 
89 {
90  // ID
91  declareProperty("HaloNumSegment_Cut", m_HaloNumSegment_Cut = 0);
92  declareProperty("HaloNumClusterShape_Cut", m_HaloNumClusterShape_Cut = 0);
93  declareProperty("HaloNumOneSidedLoose_Cut", m_HaloNumOneSidedLoose_Cut = 0);
94  declareProperty("HaloNumTwoSided_Cut", m_HaloNumTwoSided_Cut = 0);
95  declareProperty("PixMultiplicityHuge_Cut",
96  m_PixMultiplicityHuge_Cut = 100000);
97  declareProperty("PixSPNonEmpty_Cut", m_PixSPNonEmpty_Cut = 10);
98  declareProperty("SCTMultiplicityHuge_Cut",
99  m_SCTMultiplicityHuge_Cut = 100000);
100  declareProperty("SCTSPNonEmpty_Cut", m_SCTSPNonEmpty_Cut = 10);
101 
102  // LUCID
103  declareProperty("LUCIDBeamVeto_Cut", m_LUCIDBeamVeto_Cut = 0); // >0
104 
105  declareProperty("BCMTimeDiffCol_Cut", m_BCMTimeDiffCol_Cut = 6.);
106  declareProperty("BCMTimeDiffHalo_CutLo", m_BCMTimeDiffHalo_CutLo = 6.);
107  declareProperty("BCMLowGainCut", m_BCMLowGainCut = 1);
108  declareProperty("BCMHiGainCut", m_BCMHiGainCut = 1);
109 
110  declareProperty("MBTSBeamVeto_MultiplicityCut",
111  m_MBTSBeamVeto_MultiplicityCut = 0); // >0
112  declareProperty("MBTSBeamVeto_TimeCut", m_MBTSBeamVeto_TimeCut = 15.);
113  declareProperty("MBTSBeamVeto_ThresholdCut",
114  m_MBTSBeamVeto_ThresholdCut = 40.0 / 222.0);
115  // LAr
116  declareProperty("LArEC_SideCut", m_LArEC_SideCut = 1);
117  declareProperty("LArECTimeDiffCol_Cut", m_LArECTimeDiffCol_Cut = 10.);
118  declareProperty("LArECTimeDiffHalo_CutLo", m_LArECTimeDiffHalo_CutLo = 10.);
119  declareProperty("LArECTimeDiffHalo_CutHi", m_LArECTimeDiffHalo_CutHi = 30.);
120 
121  // Reset counter-array
122  m_bitcntvec.fill(0);
123 }
124 
125 //----------------------------------------------------------------
126 
127 BackgroundWordFiller::~BackgroundWordFiller() {}
128 
129 //----------------------------------------------------------------
130 
131 StatusCode BackgroundWordFiller::initialize() {
132 
133  // initialise the read handle keys
134  ATH_CHECK(m_eventInfoKey.initialize());
135  ATH_CHECK(m_beamBackgroundDataKey.initialize(!m_isMC));
136  ATH_CHECK(m_LUCID_rawDataContainerKey.initialize(!m_isMC));
137  ATH_CHECK(m_bcmCollisionTimeKey.initialize());
138  ATH_CHECK(m_sctSpacePointKey.initialize(!m_isMC));
139  ATH_CHECK(m_pixSpacePointKey.initialize(!m_isMC));
140  ATH_CHECK(m_tileCellContainerKey.initialize());
141  ATH_CHECK(m_lArCollisionTimeKey.initialize(!m_isMC));
142  ATH_CHECK(m_eventInfoDecorKey.initialize());
143 
144  return StatusCode::SUCCESS;
145 }
146 
147 //----------------------------------------------------------------
148 
149 StatusCode BackgroundWordFiller::execute() {
150 
152  // get the EventInfo
154 
155  SG::ReadHandle<xAOD::EventInfo> eventInfoReadHandle(m_eventInfoKey);
156 
157  m_totalcnt++;
158 
160  // NOW SET THE BITS!!
162 
164  // Halo Identification
166  if (!m_isMC) { // do not request in MC
167  SG::ReadHandle<BeamBackgroundData> beamBackgroundDataReadHandle(
168  m_beamBackgroundDataKey);
169 
170  if (!beamBackgroundDataReadHandle.isValid())
171  ATH_MSG_WARNING("Invalid ReadHandle to BeamBackgoundData with name: "
172  << m_beamBackgroundDataKey.key());
173  else {
174  if (beamBackgroundDataReadHandle->GetNumSegment() >
175  m_HaloNumSegment_Cut) {
176  if (eventInfoReadHandle->updateEventFlagBit(
177  EventInfo::Background, EventInfo::HaloMuonSegment) == false)
178  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
179  << m_bitnamevec[EventInfo::HaloMuonSegment]);
180  else
181  m_bitcntvec[EventInfo::HaloMuonSegment]++;
182  }
183  if (beamBackgroundDataReadHandle->GetNumClusterShape() >
184  m_HaloNumClusterShape_Cut) {
185  if (eventInfoReadHandle->updateEventFlagBit(
186  EventInfo::Background, EventInfo::HaloClusterShape) == false)
187  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
188  << m_bitnamevec[EventInfo::HaloClusterShape]);
189  else
190  m_bitcntvec[EventInfo::HaloClusterShape]++;
191  }
192  if (beamBackgroundDataReadHandle->GetNumNoTimeLoose() >
193  m_HaloNumOneSidedLoose_Cut) {
194  if (eventInfoReadHandle->updateEventFlagBit(
195  EventInfo::Background, EventInfo::HaloMuonOneSided) == false)
196  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
197  << m_bitnamevec[EventInfo::HaloMuonOneSided]);
198  else
199  m_bitcntvec[EventInfo::HaloMuonOneSided]++;
200  }
201  if (beamBackgroundDataReadHandle->GetNumTwoSidedNoTime() >
202  m_HaloNumTwoSided_Cut) {
203  if (eventInfoReadHandle->updateEventFlagBit(
204  EventInfo::Background, EventInfo::HaloMuonTwoSided) == false)
205  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
206  << m_bitnamevec[EventInfo::HaloMuonTwoSided]);
207  else
208  m_bitcntvec[EventInfo::HaloMuonTwoSided]++;
209  }
210  }
211  }
212 
214  // LUCID: LUCIDBeamVeto
216 
217  if (!m_isMC) { // do not request in MC
218  SG::ReadHandle<LUCID_RawDataContainer> LUCID_rawDataContainerReadHandle(
219  m_LUCID_rawDataContainerKey);
220 
221  if (!LUCID_rawDataContainerReadHandle.isValid())
222  ATH_MSG_WARNING("Invalid ReadHandle to LUCID_RawDataContainer with name: "
223  << m_LUCID_rawDataContainerKey.key());
224  else {
225  int LUCIDcounter(0);
226  for (auto LUCID_rawData : *LUCID_rawDataContainerReadHandle) {
227  LUCIDcounter += LUCID_rawData->getNhitsPMTsideA();
228  LUCIDcounter += LUCID_rawData->getNhitsPMTsideC();
229  }
230  if (LUCIDcounter > m_LUCIDBeamVeto_Cut) {
231  if (eventInfoReadHandle->updateEventFlagBit(
232  EventInfo::Background, EventInfo::LUCIDBeamVeto) == false)
233  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
234  << m_bitnamevec[EventInfo::LUCIDBeamVeto]);
235  else
236  m_bitcntvec[EventInfo::LUCIDBeamVeto]++;
237  }
238  }
239  }
240 
242  // BCM: BCMTimeDiffHalo, BCMTimeDiffCol, BCMBeamVeto
244 
245  SG::ReadHandle<BcmCollisionTime> bcmCollisionTimeReadHandle(
246  m_bcmCollisionTimeKey);
247 
248  if (!bcmCollisionTimeReadHandle.isValid())
249  ATH_MSG_WARNING("Invalid ReadHandle to BcmCollisionTime with name: "
250  << m_bcmCollisionTimeKey.key());
251  else {
252  std::vector<float> bcmTDs = bcmCollisionTimeReadHandle->getDeltaT();
253  ATH_MSG_DEBUG(" got BCMCollisionTime object getMultiLG "
254  << bcmCollisionTimeReadHandle->getMultiLG() << " getMultiHG "
255  << bcmCollisionTimeReadHandle->getMultiHG() << " TDs size "
256  << bcmTDs.size());
257  float minTD = 999;
258  float maxTD = 0;
259 
260  for (unsigned int i = 0; i < bcmTDs.size(); i++) {
261  float td = bcmTDs.at(i);
262  ATH_MSG_DEBUG(" BCMCollisionTime td " << i << " " << td);
263  if (fabs(td) > fabs(maxTD))
264  maxTD = td;
265  if (fabs(td) < fabs(minTD))
266  minTD = td;
267  }
268 
269  ATH_MSG_DEBUG(" BCMCollisionTime minDT " << minTD << " maxDT " << maxTD);
270 
271  if (fabs(minTD) < m_BCMTimeDiffCol_Cut) {
272  if (eventInfoReadHandle->updateEventFlagBit(
273  EventInfo::Background, EventInfo::BCMTimeDiffCol) == false)
274  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
275  << m_bitnamevec[EventInfo::BCMTimeDiffCol]);
276  else
277  m_bitcntvec[EventInfo::BCMTimeDiffCol]++;
278  }
279  if (fabs(maxTD) > m_BCMTimeDiffHalo_CutLo) {
280  if (eventInfoReadHandle->updateEventFlagBit(
281  EventInfo::Background, EventInfo::BCMTimeDiffHalo) == false)
282  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
283  << m_bitnamevec[EventInfo::BCMTimeDiffHalo]);
284  else
285  m_bitcntvec[EventInfo::BCMTimeDiffHalo]++;
286  }
287  if (bcmCollisionTimeReadHandle->getMultiLG() > m_BCMLowGainCut ||
288  bcmCollisionTimeReadHandle->getMultiHG() > m_BCMHiGainCut) {
289  if (eventInfoReadHandle->updateEventFlagBit(
290  EventInfo::Background, EventInfo::BCMBeamVeto) == false)
291  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
292  << m_bitnamevec[EventInfo::BCMBeamVeto]);
293  else
294  m_bitcntvec[EventInfo::BCMBeamVeto]++;
295  }
296  }
297 
299  // ID SP multiplicities from Raw for filling: IDMultiplicityHuge,
300  // IDSPNonEmpty
302  if (!m_isMC) { // do not request in MC
303  SG::ReadHandle<SpacePointContainer> sctSP{m_sctSpacePointKey};
304  SG::ReadHandle<SpacePointContainer> pixSP{m_pixSpacePointKey};
305 
306  if (!sctSP.isValid() or !pixSP.isValid()) {
307  ATH_MSG_WARNING("Invalid ReadHandle to SCT/Pix spacepoints");
308  } else {
309  int NSCTsps = 0;
310  int NPIXsps = 0;
311  std::for_each(sctSP->begin(), sctSP->end(), [&NSCTsps](const auto coll) {
312  if (coll)
313  NSCTsps += coll->size();
314  });
315  std::for_each(pixSP->begin(), pixSP->end(), [&NPIXsps](const auto coll) {
316  if (coll)
317  NPIXsps += coll->size();
318  });
319 
320  // set IDMultiplicityHuge
321  if ((NPIXsps) > m_PixMultiplicityHuge_Cut) {
322  if (eventInfoReadHandle->updateEventFlagBit(
323  EventInfo::Background, EventInfo::PixMultiplicityHuge) == false)
324  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
325  << m_bitnamevec[EventInfo::PixMultiplicityHuge]);
326  else
327  m_bitcntvec[EventInfo::PixMultiplicityHuge]++;
328  }
329 
330  // set PixSPNonEmpty
331  if ((NPIXsps) > m_PixSPNonEmpty_Cut) {
332  if (eventInfoReadHandle->updateEventFlagBit(
333  EventInfo::Background, EventInfo::PixSPNonEmpty) == false)
334  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
335  << m_bitnamevec[EventInfo::PixSPNonEmpty]);
336  else
337  m_bitcntvec[EventInfo::PixSPNonEmpty]++;
338  }
339 
340  if ((NSCTsps) > m_SCTMultiplicityHuge_Cut) {
341  if (eventInfoReadHandle->updateEventFlagBit(
342  EventInfo::Background, EventInfo::SCTMultiplicityHuge) == false)
343  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
344  << m_bitnamevec[EventInfo::SCTMultiplicityHuge]);
345  else
346  m_bitcntvec[EventInfo::SCTMultiplicityHuge]++;
347  }
348 
349  // set SCTSPNonEmpty
350  if ((NSCTsps) > m_SCTSPNonEmpty_Cut) {
351  if (eventInfoReadHandle->updateEventFlagBit(
352  EventInfo::Background, EventInfo::SCTSPNonEmpty) == false)
353  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
354  << m_bitnamevec[EventInfo::SCTSPNonEmpty]);
355  else
356  m_bitcntvec[EventInfo::SCTSPNonEmpty]++;
357  }
358  }
359  }
360 
362  // MBTSBeamVeto
364 
365  SG::ReadHandle<TileCellContainer> tileCellContainerReadHandle(
366  m_tileCellContainerKey);
367 
368  if (!tileCellContainerReadHandle.isValid())
369  ATH_MSG_WARNING("Invalid ReadHandle to TileCellContainer: "
370  << m_tileCellContainerKey.key());
371  else {
372  int MBTScount(0);
373 
374  for (auto tileCellContainer : *tileCellContainerReadHandle) {
375  if (tileCellContainer->energy() < m_MBTSBeamVeto_ThresholdCut)
376  continue;
377  const uint8_t qbit1 = tileCellContainer->qbit1();
378 
379  if ((qbit1 & m_MBTSmask) != m_MBTSpattern) {
380  ATH_MSG_DEBUG("Rejected based on quality bits");
381  continue;
382  }
383  if (fabs(tileCellContainer->time()) < m_MBTSBeamVeto_TimeCut)
384  MBTScount++;
385  } // loop on MBTS containers
386 
387  if (MBTScount > m_MBTSBeamVeto_MultiplicityCut) {
388  if (eventInfoReadHandle->updateEventFlagBit(
389  EventInfo::Background, EventInfo::MBTSBeamVeto) == false)
390  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
391  << m_bitnamevec[EventInfo::MBTSBeamVeto]);
392  else
393  m_bitcntvec[EventInfo::MBTSBeamVeto]++;
394  }
395  }
396 
398  // LAr EC collision timing stuff (from Guillaume...) - for filling:
399  // LArECTimeDiffHalo, LArECTimeDiffCol
401 
402  if (!m_isMC) { // do not request in MC
403  SG::ReadHandle<LArCollisionTime> lArCollisionTimeReadHandle(
404  m_lArCollisionTimeKey);
405 
406  if (!lArCollisionTimeReadHandle.isValid())
407  ATH_MSG_WARNING("Invalid ReadHandle to LArCollisionTime: "
408  << m_lArCollisionTimeKey.key());
409  else {
410  if (lArCollisionTimeReadHandle->ncellA() > m_LArEC_SideCut &&
411  lArCollisionTimeReadHandle->ncellC() > m_LArEC_SideCut) {
412  float LArECtimeDiff = lArCollisionTimeReadHandle->timeA() -
413  lArCollisionTimeReadHandle->timeC();
414  if (fabs(LArECtimeDiff) < m_LArECTimeDiffCol_Cut) {
415  if (eventInfoReadHandle->updateEventFlagBit(
416  EventInfo::Background, EventInfo::LArECTimeDiffCol) == false)
417  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
418  << m_bitnamevec[EventInfo::LArECTimeDiffCol]);
419  else
420  m_bitcntvec[EventInfo::LArECTimeDiffCol]++;
421  }
422  if (fabs(LArECtimeDiff) > m_LArECTimeDiffHalo_CutLo &&
423  fabs(LArECtimeDiff) < m_LArECTimeDiffHalo_CutHi) {
424  if (eventInfoReadHandle->updateEventFlagBit(
425  EventInfo::Background, EventInfo::LArECTimeDiffHalo) == false)
426  ATH_MSG_WARNING("Failed to set EventInfo Background word bit "
427  << m_bitnamevec[EventInfo::LArECTimeDiffHalo]);
428  else
429  m_bitcntvec[EventInfo::LArECTimeDiffHalo]++;
430  } // halo timing
431  } // enough hits per side
432  }
433  }
434 
436  // printout the final background word
438  ATH_MSG_DEBUG("Summary of background word contents:");
439  ATH_MSG_DEBUG("MBTSTimeDiffHalo: " << eventInfoReadHandle->isEventFlagBitSet(
440  EventInfo::Background, EventInfo::MBTSTimeDiffHalo));
441  ATH_MSG_DEBUG("MBTSTimeDiffCol: " << eventInfoReadHandle->isEventFlagBitSet(
442  EventInfo::Background, EventInfo::MBTSTimeDiffCol));
443  ATH_MSG_DEBUG("MBTSBeamVeto: " << eventInfoReadHandle->isEventFlagBitSet(
444  EventInfo::Background, EventInfo::MBTSBeamVeto));
445  ATH_MSG_DEBUG("LArECTimeDiffHalo: " << eventInfoReadHandle->isEventFlagBitSet(
446  EventInfo::Background, EventInfo::LArECTimeDiffHalo));
447  ATH_MSG_DEBUG("LArECTimeDiffCol: " << eventInfoReadHandle->isEventFlagBitSet(
448  EventInfo::Background, EventInfo::LArECTimeDiffCol));
449  ATH_MSG_DEBUG(
450  "PixMultiplicityHuge: " << eventInfoReadHandle->isEventFlagBitSet(
451  EventInfo::Background, EventInfo::PixMultiplicityHuge));
452  ATH_MSG_DEBUG("PixSPNonEmpty: " << eventInfoReadHandle->isEventFlagBitSet(
453  EventInfo::Background, EventInfo::PixSPNonEmpty));
454  ATH_MSG_DEBUG(
455  "SCTMultiplicityHuge: " << eventInfoReadHandle->isEventFlagBitSet(
456  EventInfo::Background, EventInfo::SCTMultiplicityHuge));
457  ATH_MSG_DEBUG("SCTSPNonEmpty: " << eventInfoReadHandle->isEventFlagBitSet(
458  EventInfo::Background, EventInfo::SCTSPNonEmpty));
459  ATH_MSG_DEBUG("CSCTimeDiffHalo: " << eventInfoReadHandle->isEventFlagBitSet(
460  EventInfo::Background, EventInfo::CSCTimeDiffHalo));
461  ATH_MSG_DEBUG("CSCTimeDiffCol: " << eventInfoReadHandle->isEventFlagBitSet(
462  EventInfo::Background, EventInfo::CSCTimeDiffCol));
463  ATH_MSG_DEBUG("BCMTimeDiffHalo: " << eventInfoReadHandle->isEventFlagBitSet(
464  EventInfo::Background, EventInfo::BCMTimeDiffHalo));
465  ATH_MSG_DEBUG("BCMTimeDiffCol: " << eventInfoReadHandle->isEventFlagBitSet(
466  EventInfo::Background, EventInfo::BCMTimeDiffCol));
467  ATH_MSG_DEBUG("BCMBeamVeto: " << eventInfoReadHandle->isEventFlagBitSet(
468  EventInfo::Background, EventInfo::BCMBeamVeto));
469  ATH_MSG_DEBUG("MuonTimingCol: " << eventInfoReadHandle->isEventFlagBitSet(
470  EventInfo::Background, EventInfo::MuonTimingCol));
471  ATH_MSG_DEBUG("MuonTimingCosmic: " << eventInfoReadHandle->isEventFlagBitSet(
472  EventInfo::Background, EventInfo::MuonTimingCosmic));
473  ATH_MSG_DEBUG("LUCIDBeamVeto: " << eventInfoReadHandle->isEventFlagBitSet(
474  EventInfo::Background, EventInfo::LUCIDBeamVeto));
475 
476  return StatusCode::SUCCESS;
477 }
478 
479 //----------------------------------------------------------------
480 
481 StatusCode BackgroundWordFiller::finalize() {
482 
483  ATH_MSG_INFO("In finalize()");
484 
485  ATH_MSG_INFO(
486  "Job Summary for Background Word (NB. MBTS time bits not counted by this "
487  "alg)");
488  for (int ibit = 0; ibit < EventInfo::NBackgroundWords; ++ibit)
489  ATH_MSG_INFO(" " << m_bitnamevec[ibit] << ": " << m_bitcntvec[ibit] << "/"
490  << m_totalcnt << " events");
491 
492  return StatusCode::SUCCESS;
493 }
494 
TileCell
Definition: TileCell.h:57
BackgroundWordFiller::m_eventInfoDecorKey
SG::WriteDecorHandleKey< xAOD::EventInfo > m_eventInfoDecorKey
WriteDecorHandleKey: needed for scheduling downstream clients.
Definition: BackgroundWordFiller.h:72
EventInfo::BCMBeamVeto
@ BCMBeamVeto
Definition: EventInfo/EventInfo/EventInfo.h:85
EventInfo::MBTSBeamVeto
@ MBTSBeamVeto
Definition: EventInfo/EventInfo/EventInfo.h:84
BeamBackgroundData::GetNumSegment
int GetNumSegment() const
Definition: BeamBackgroundData.h:74
BackgroundWordFiller::m_bitnamevec
std::array< const char *, xAOD::EventInfo::NBackgroundWords > m_bitnamevec
Definition: BackgroundWordFiller.h:103
xAOD::EventInfo
EventInfo_v1 EventInfo
Definition of the latest event info version.
Definition: IEventInfoCnvTool.h:17
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::uint8_t
uint8_t
Definition: Muon_v1.cxx:557
BackgroundWordFiller::m_BCMTimeDiffHalo_CutLo
float m_BCMTimeDiffHalo_CutLo
Definition: BackgroundWordFiller.h:89
BackgroundWordFiller::m_HaloNumTwoSided_Cut
int m_HaloNumTwoSided_Cut
Definition: BackgroundWordFiller.h:82
BackgroundWordFiller::finalize
StatusCode finalize()
Definition: BackgroundWordFiller.cxx:481
EventInfo::PixSPNonEmpty
@ PixSPNonEmpty
Definition: EventInfo/EventInfo/EventInfo.h:79
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
EventInfo::CSCTimeDiffHalo
@ CSCTimeDiffHalo
Definition: EventInfo/EventInfo/EventInfo.h:81
BackgroundWordFiller::m_LArEC_SideCut
int m_LArEC_SideCut
Definition: BackgroundWordFiller.h:97
EventInfo::MBTSTimeDiffCol
@ MBTSTimeDiffCol
Definition: EventInfo/EventInfo/EventInfo.h:77
BcmCollisionTime::getMultiHG
int getMultiHG() const
get HG multiplicity
Definition: BcmCollisionTime.h:46
BackgroundWordFiller::m_LArECTimeDiffHalo_CutHi
float m_LArECTimeDiffHalo_CutHi
Definition: BackgroundWordFiller.h:99
xAOD::EventInfo_v1::updateEventFlagBit
bool updateEventFlagBit(const EventFlagSubDet subDet, const size_t bit) const
Change detector flags with update semantics.
Definition: EventInfo_v1.cxx:746
EventInfo::SCTSPNonEmpty
@ SCTSPNonEmpty
Definition: EventInfo/EventInfo/EventInfo.h:80
BcmCollisionTime::getMultiLG
int getMultiLG() const
destructor; initialize all data members in constructor and include vector
Definition: BcmCollisionTime.h:43
BeamBackgroundData::GetNumNoTimeLoose
int GetNumNoTimeLoose() const
Definition: BeamBackgroundData.h:79
SG::VarHandleKey::key
const std::string & key() const
Return the StoreGate ID for the referenced object.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:141
BackgroundWordFiller::m_lArCollisionTimeKey
SG::ReadHandleKey< LArCollisionTime > m_lArCollisionTimeKey
ReadHandleKey for LArCollisionTime.
Definition: BackgroundWordFiller.h:67
BackgroundWordFiller::m_LUCID_rawDataContainerKey
SG::ReadHandleKey< LUCID_RawDataContainer > m_LUCID_rawDataContainerKey
ReadHandleKey for LUCID_RawDataContainer.
Definition: BackgroundWordFiller.h:46
EventInfo::NBackgroundWords
@ NBackgroundWords
Definition: EventInfo/EventInfo/EventInfo.h:96
EventInfo::PixMultiplicityHuge
@ PixMultiplicityHuge
Definition: EventInfo/EventInfo/EventInfo.h:79
BackgroundWordFiller::m_sctSpacePointKey
SG::ReadHandleKey< SpacePointContainer > m_sctSpacePointKey
ReadHandleKey for SpacePointContainers.
Definition: BackgroundWordFiller.h:56
BackgroundWordFiller::m_HaloNumSegment_Cut
int m_HaloNumSegment_Cut
Definition: BackgroundWordFiller.h:79
MBTSCollisionTime.h
LArCollisionTime::ncellC
int ncellC() const
get number of cells for time C side
Definition: LArCollisionTime.h:33
BackgroundWordFiller::execute
StatusCode execute()
Definition: BackgroundWordFiller.cxx:149
EventInfo::HaloMuonOneSided
@ HaloMuonOneSided
Definition: EventInfo/EventInfo/EventInfo.h:88
BcmCollisionTime::getDeltaT
const std::vector< float > & getDeltaT() const
get if event is col like
Definition: BcmCollisionTime.h:55
BackgroundWordFiller::m_MBTSpattern
const uint8_t m_MBTSpattern
Definition: BackgroundWordFiller.h:95
lumiFormat.i
int i
Definition: lumiFormat.py:85
EventInfo::LUCIDBeamVeto
@ LUCIDBeamVeto
Definition: EventInfo/EventInfo/EventInfo.h:86
BackgroundWordFiller::m_PixMultiplicityHuge_Cut
int m_PixMultiplicityHuge_Cut
Definition: BackgroundWordFiller.h:83
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
BackgroundWordFiller::m_isMC
Gaudi::Property< bool > m_isMC
Definition: BackgroundWordFiller.h:76
BackgroundWordFiller::m_MBTSmask
const uint8_t m_MBTSmask
Definition: BackgroundWordFiller.h:95
EventInfo::SCTMultiplicityHuge
@ SCTMultiplicityHuge
Definition: EventInfo/EventInfo/EventInfo.h:80
BeamBackgroundData::GetNumClusterShape
int GetNumClusterShape() const
Definition: BeamBackgroundData.h:87
EventInfo::BCMTimeDiffHalo
@ BCMTimeDiffHalo
Definition: EventInfo/EventInfo/EventInfo.h:82
BackgroundWordFiller::m_SCTMultiplicityHuge_Cut
int m_SCTMultiplicityHuge_Cut
Definition: BackgroundWordFiller.h:85
LArCollisionTime::timeC
double timeC() const
time C side
Definition: LArCollisionTime.h:45
BackgroundWordFiller::m_tileCellContainerKey
SG::ReadHandleKey< TileCellContainer > m_tileCellContainerKey
ReadHandleKey for TileCellContainer.
Definition: BackgroundWordFiller.h:62
BackgroundWordFiller::initialize
StatusCode initialize()
Definition: BackgroundWordFiller.cxx:131
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
BackgroundWordFiller::m_eventInfoKey
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
ReadHandleKey for EventInfo object.
Definition: BackgroundWordFiller.h:37
EventInfo::HaloClusterShape
@ HaloClusterShape
Definition: EventInfo/EventInfo/EventInfo.h:87
SG::VarHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
Definition: AthToolSupport/AsgDataHandles/Root/VarHandleKey.cxx:103
BackgroundWordFiller::m_LUCIDBeamVeto_Cut
int m_LUCIDBeamVeto_Cut
Definition: BackgroundWordFiller.h:87
BackgroundWordFiller::BackgroundWordFiller
BackgroundWordFiller(const std::string &name, ISvcLocator *pSvcLocator)
Definition: BackgroundWordFiller.cxx:45
AthAlgorithm
Definition: AthAlgorithm.h:47
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
BackgroundWordFiller::m_LArECTimeDiffHalo_CutLo
float m_LArECTimeDiffHalo_CutLo
Definition: BackgroundWordFiller.h:99
BackgroundWordFiller::m_PixSPNonEmpty_Cut
int m_PixSPNonEmpty_Cut
Definition: BackgroundWordFiller.h:84
EventInfo::CSCTimeDiffCol
@ CSCTimeDiffCol
Definition: EventInfo/EventInfo/EventInfo.h:81
BackgroundWordFiller::m_pixSpacePointKey
SG::ReadHandleKey< SpacePointContainer > m_pixSpacePointKey
Definition: BackgroundWordFiller.h:58
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
BackgroundWordFiller::~BackgroundWordFiller
~BackgroundWordFiller()
Definition: BackgroundWordFiller.cxx:127
BackgroundWordFiller::m_BCMLowGainCut
int m_BCMLowGainCut
Definition: BackgroundWordFiller.h:91
BackgroundWordFiller::m_bcmCollisionTimeKey
SG::ReadHandleKey< BcmCollisionTime > m_bcmCollisionTimeKey
ReadHandleKey for BcmCollisionTime.
Definition: BackgroundWordFiller.h:51
BackgroundWordFiller::m_beamBackgroundDataKey
SG::ReadHandleKey< BeamBackgroundData > m_beamBackgroundDataKey
ReadHandleKey for BeamBackgroundData.
Definition: BackgroundWordFiller.h:41
BackgroundWordFiller::m_HaloNumClusterShape_Cut
int m_HaloNumClusterShape_Cut
Definition: BackgroundWordFiller.h:80
BackgroundWordFiller::m_totalcnt
unsigned int m_totalcnt
Definition: BackgroundWordFiller.h:101
EventInfo::HaloMuonTwoSided
@ HaloMuonTwoSided
Definition: EventInfo/EventInfo/EventInfo.h:88
LArCollisionTime::ncellA
int ncellA() const
get number of cells for time A side
Definition: LArCollisionTime.h:30
EventInfo::MuonTimingCosmic
@ MuonTimingCosmic
Definition: EventInfo/EventInfo/EventInfo.h:83
BackgroundWordFiller::m_HaloNumOneSidedLoose_Cut
int m_HaloNumOneSidedLoose_Cut
Definition: BackgroundWordFiller.h:81
SG::WriteDecorHandleKey::initialize
StatusCode initialize(bool used=true)
If this object is used as a property, then this should be called during the initialize phase.
BackgroundWordFiller::m_SCTSPNonEmpty_Cut
int m_SCTSPNonEmpty_Cut
Definition: BackgroundWordFiller.h:86
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
BackgroundWordFiller::m_MBTSBeamVeto_TimeCut
int m_MBTSBeamVeto_TimeCut
Definition: BackgroundWordFiller.h:93
BackgroundWordFiller::m_LArECTimeDiffCol_Cut
float m_LArECTimeDiffCol_Cut
Definition: BackgroundWordFiller.h:98
BackgroundWordFiller::m_bitcntvec
std::array< unsigned int, xAOD::EventInfo::NBackgroundWords > m_bitcntvec
Definition: BackgroundWordFiller.h:102
EventInfo::LArECTimeDiffHalo
@ LArECTimeDiffHalo
Definition: EventInfo/EventInfo/EventInfo.h:78
BackgroundWordFiller::m_BCMTimeDiffCol_Cut
float m_BCMTimeDiffCol_Cut
Definition: BackgroundWordFiller.h:88
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
LArCollisionTime::timeA
double timeA() const
time A side
Definition: LArCollisionTime.h:42
BackgroundWordFiller::m_BCMHiGainCut
int m_BCMHiGainCut
Definition: BackgroundWordFiller.h:90
EventInfo::MuonTimingCol
@ MuonTimingCol
Definition: EventInfo/EventInfo/EventInfo.h:83
BackgroundWordFiller::m_MBTSBeamVeto_MultiplicityCut
int m_MBTSBeamVeto_MultiplicityCut
Definition: BackgroundWordFiller.h:92
BackgroundWordFiller.h
EventInfo::HaloMuonSegment
@ HaloMuonSegment
Definition: EventInfo/EventInfo/EventInfo.h:87
EventInfo::BCMTimeDiffCol
@ BCMTimeDiffCol
Definition: EventInfo/EventInfo/EventInfo.h:82
EventInfo::LArECTimeDiffCol
@ LArECTimeDiffCol
Definition: EventInfo/EventInfo/EventInfo.h:78
BeamBackgroundData::GetNumTwoSidedNoTime
int GetNumTwoSidedNoTime() const
Definition: BeamBackgroundData.h:85
EventInfo::MBTSTimeDiffHalo
@ MBTSTimeDiffHalo
Definition: EventInfo/EventInfo/EventInfo.h:77
BackgroundWordFiller::m_MBTSBeamVeto_ThresholdCut
float m_MBTSBeamVeto_ThresholdCut
Definition: BackgroundWordFiller.h:94
EventInfo::Background
@ Background
Definition: EventInfo/EventInfo/EventInfo.h:61
Generated on Sun Dec 22 2024 21:07:21 for ATLAS Offline Software by   doxygen 1.8.18