ATLAS Offline Software
AFPSiLayerAlgorithm.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
3 *
4 *
5 * AFPSiLayerAlgorithm
6 *
7 *
8 */
9 
10 #include "Run3AFPMonitoring/AFPSiLayerAlgorithm.h"
11 #include "StoreGate/ReadHandleKey.h"
12 #include "xAODForward/AFPStationID.h"
13 
14 
15 namespace {
16  constexpr int reorganizePlanes(const int station, const int layer)
17  {
18  bool reverse = station == 0 || station == 1;
19  return station * 4 + (reverse ? 3 - layer : layer);
20  }
21 }
22 
23 
24 AFPSiLayerAlgorithm::AFPSiLayerAlgorithm( const std::string& name, ISvcLocator* pSvcLocator )
25 :AthMonitorAlgorithm(name,pSvcLocator)
26 , m_afpHitContainerKey("AFPSiHitContainer")
27 {
28  declareProperty("AFPSiHitContainer", m_afpHitContainerKey);
29 }
30 
31 
32 AFPSiLayerAlgorithm::~AFPSiLayerAlgorithm() {}
33 
34 
35 StatusCode AFPSiLayerAlgorithm::initialize() {
36 
37  using namespace Monitored;
38 
39  m_StationPlaneGroup = buildToolMap<std::map<std::string,int>>(m_tools,"AFPSiLayerTool", m_stationnames, m_pixlayers);
40  m_StationGroup = buildToolMap<int>(m_tools, "AFPSiLayerTool", m_stationnames);
41 
42 
43  // We must declare to the framework in initialize what SG objects we are going to use:
44  SG::ReadHandleKey<xAOD::AFPSiHitContainer> afpHitContainerKey("AFPSiHits");
45  ATH_CHECK(m_afpHitContainerKey.initialize());
46 
47  ATH_MSG_INFO( "BunchCrossingKey initialization (SiT)" );
48  ATH_CHECK(m_bunchCrossingKey.initialize());
49  ATH_MSG_INFO( "initialization completed (SiT)" );
50  return AthMonitorAlgorithm::initialize();
51 }
52 
53 StatusCode AFPSiLayerAlgorithm::fillHistograms( const EventContext& ctx ) const {
54  using namespace Monitored;
55 
56  auto bcidAll = Monitored::Scalar<int>("bcidAll", 0);
57  auto bcidFront = Monitored::Scalar<int>("bcidFront", 0);
58  auto bcidMiddle = Monitored::Scalar<int>("bcidMiddle", 0);
59  auto bcidEnd = Monitored::Scalar<int>("bcidEnd", 0);
60 
61  auto numberOfEventsPerLumiblockFront = Monitored::Scalar<int>("numberOfEventsPerLumiblockFront", 0);
62  auto numberOfEventsPerLumiblockMiddle = Monitored::Scalar<int>("numberOfEventsPerLumiblockMiddle", 0);
63  auto numberOfEventsPerLumiblockEnd = Monitored::Scalar<int>("numberOfEventsPerLumiblockEnd", 0);
64 
65  SG::ReadHandle<xAOD::EventInfo> eventInfo = GetEventInfo(ctx);
66  numberOfEventsPerLumiblockFront = eventInfo->lumiBlock();
67  numberOfEventsPerLumiblockMiddle = eventInfo->lumiBlock();
68  numberOfEventsPerLumiblockEnd = eventInfo->lumiBlock();
69 
70  // BCX handler
71  const unsigned int bcid = eventInfo->bcid();
72  SG::ReadCondHandle<BunchCrossingCondData> bcidHdl(m_bunchCrossingKey,ctx);
73  if (!bcidHdl.isValid()) {
74  ATH_MSG_ERROR( "Unable to retrieve BunchCrossing conditions object (SiT)" );
75  }
76  const BunchCrossingCondData* bcData{*bcidHdl};
77 
78  // Classifying bunches by position in train (Front, Middle, End)
79  enum { FRONT, MIDDLE, END, NPOS } position = NPOS;
80  if(bcData->isFilled(bcid))
81  {
82  bcidAll = bcid;
83  fill("AFPSiLayerTool", bcidAll);
84  if(!bcData->isFilled(bcid-1))
85  {
86  position = FRONT;
87  bcidFront = bcid;
88  fill("AFPSiLayerTool", bcidFront);
89  fill("AFPSiLayerTool", numberOfEventsPerLumiblockFront);
90  }
91  else
92  {
93  if(bcData->isFilled(bcid+1))
94  {
95  position = MIDDLE;
96  bcidMiddle = bcid;
97  fill("AFPSiLayerTool", bcidMiddle);
98  fill("AFPSiLayerTool", numberOfEventsPerLumiblockMiddle);
99  }
100  else
101  {
102  position = END;
103  bcidEnd = bcid;
104  fill("AFPSiLayerTool", bcidEnd);
105  fill("AFPSiLayerTool", numberOfEventsPerLumiblockEnd);
106  }
107  }
108  }
109 
110 
111  // Declare the quantities which should be monitored:
112  auto lb = Monitored::Scalar<int>("lb", 0);
113  auto muPerBX = Monitored::Scalar<float>("muPerBX", 0.0);
114  //auto run = Monitored::Scalar<int>("run",0);
115 
116  auto nSiHits = Monitored::Scalar<int>("nSiHits", 1);
117 
118  auto pixelRowIDChip = Monitored::Scalar<int>("pixelRowIDChip", 0);
119  auto pixelColIDChip = Monitored::Scalar<int>("pixelColIDChip", 0);
120 
121  auto timeOverThreshold = Monitored::Scalar<int>("timeOverThreshold", 0);
122 
123  auto clusterX = Monitored::Scalar<float>("clusterX", 0.0);
124  auto clusterY = Monitored::Scalar<float>("clusterY", 0.0);
125  auto clustersInPlanes = Monitored::Scalar<int>("clustersInPlanes", 0);
126 
127  auto trackX = Monitored::Scalar<float>("trackX", 0.0);
128  auto trackY = Monitored::Scalar<float>("trackY", 0.0);
129 
130  auto planeHits = Monitored::Scalar<int>("planeHits", 0);
131  auto planeHitsAll = Monitored::Scalar<int>("planeHitsAll", 0);
132  auto planeHitsAllMU = Monitored::Scalar<int>("planeHitsAllMU", 0);
133  auto weightAllPlanes = Monitored::Scalar<float>("weightAllPlanes", 1.0);
134 
135  auto numberOfHitsPerStation = Monitored::Scalar<int>("numberOfHitsPerStation", 0);
136 
137  auto lbEvents = Monitored::Scalar<int>("lbEvents", 0);
138  auto lbHits = Monitored::Scalar<int>("lbHits", 0);
139  auto lbEventsStations = Monitored::Scalar<int>("lbEventsStations", 0);
140  auto lbEventsStationsAll = Monitored::Scalar<int>("lbEventsStationsAll", 0);
141 
142  auto lbClustersPerPlanes = Monitored::Scalar<int>("lbClustersPerPlanes", 0);
143  auto weightClustersByMU = Monitored::Scalar<float>("weightClustersByMU", 1.0);
144 
145  auto lbClustersPerPlanes_full = Monitored::Scalar<int>("lbClustersPerPlanes_full", 0);
146 
147  auto clustersPerPlaneFrontPP = Monitored::Scalar<int>("clustersPerPlaneFrontPP", 0);
148  auto clustersPerPlaneMiddlePP = Monitored::Scalar<int>("clustersPerPlaneMiddlePP", 0);
149  auto clustersPerPlaneEndPP = Monitored::Scalar<int>("clustersPerPlaneEndPP", 0);
150  auto weightClustersPerPlaneFrontPP = Monitored::Scalar<float>("weightClustersPerPlaneFrontPP", 1.0);
151  auto weightClustersPerPlaneMiddlePP = Monitored::Scalar<float>("weightClustersPerPlaneMiddlePP", 1.0);
152  auto weightClustersPerPlaneEndPP = Monitored::Scalar<float>("weightClustersPerPlaneEndPP", 1.0);
153 
154  auto clustersPerPlaneFrontPP_full = Monitored::Scalar<int>("clustersPerPlaneFrontPP_full", 0);
155  auto clustersPerPlaneMiddlePP_full = Monitored::Scalar<int>("clustersPerPlaneMiddlePP_full", 0);
156  auto clustersPerPlaneEndPP_full = Monitored::Scalar<int>("clustersPerPlaneEndPP_full", 0);
157 
158  auto lbHitsPerPlanes = Monitored::Scalar<int>("lbHitsPerPlanes", 0);
159  auto lbHitsPerPlanes_full = Monitored::Scalar<float>("lbHitsPerPlanes_full", 0.0);
160  auto weightHitsByMU = Monitored::Scalar<float>("weightHitsByMU", 1.0);
161 
162  auto hitsCounterPlanesTProfile = Monitored::Scalar<int>("hitsCounterPlanesTProfile", 0.0);
163  auto hitsCounterStationsTProfile = Monitored::Scalar<int>("hitsCounterStationsTProfile", 0.0);
164 
165  auto planes = Monitored::Scalar<int>("planes", 0);
166 
167  auto eventsPerStation = Monitored::Scalar<int>("eventsPerStation", 0);
168 
169  auto clusterToT = Monitored::Scalar<int>("clusterToT", 0);
170 
171  lb = eventInfo->lumiBlock();
172  lbEvents = eventInfo->lumiBlock();
173  muPerBX = lbAverageInteractionsPerCrossing(ctx);
174  if (muPerBX == 0.0) {
175  ATH_MSG_DEBUG("AverageInteractionsPerCrossing is 0, forcing to 1.0");
176  muPerBX=1.0;
177  }
178  fill("AFPSiLayerTool", lb, muPerBX);
179  fill("AFPSiLayerTool", lbEvents);
180 
181 
182  SG::ReadHandle<xAOD::AFPSiHitContainer> afpHitContainer(m_afpHitContainerKey, ctx);
183  if(! afpHitContainer.isValid())
184  {
185  ATH_MSG_WARNING("evtStore() does not contain hits collection with name " << m_afpHitContainerKey);
186  return StatusCode::SUCCESS;
187  }
188 
189  ATH_CHECK( afpHitContainer.initialize() );
190 
191  nSiHits = afpHitContainer->size();
192  fill("AFPSiLayerTool", lb, nSiHits);
193 
194  int eventsInStations[4] = {};
195  int numberOfHitsPerPlane[4][4] = {};
196 
197  for(const xAOD::AFPSiHit *hitsItr: *afpHitContainer)
198  {
199  lb = eventInfo->lumiBlock();
200  lbHits = eventInfo->lumiBlock();
201  lbEventsStations = eventInfo->lumiBlock();
202  lbEventsStationsAll = eventInfo->lumiBlock();
203  pixelRowIDChip = hitsItr->pixelRowIDChip();
204  pixelColIDChip = hitsItr->pixelColIDChip();
205  timeOverThreshold = hitsItr->timeOverThreshold();
206 
207 
208  if (hitsItr->stationID()<4 && hitsItr->stationID()>=0 && hitsItr->pixelLayerID()<4 && hitsItr->pixelLayerID()>=0)
209  {
210  ++eventsInStations[hitsItr->stationID()];
211 
212  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], pixelRowIDChip, pixelColIDChip);
213  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], pixelRowIDChip);
214  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], pixelColIDChip);
215  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], timeOverThreshold);
216  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], lb, hitsCounterPlanesTProfile);
217 
218  planeHits = hitsItr->pixelLayerID();
219  fill(m_tools[m_StationGroup.at(m_stationnames.at(hitsItr->stationID()))], planeHits);
220 
221  ++numberOfHitsPerPlane[hitsItr->stationID()][hitsItr->pixelLayerID()];
222  planeHitsAll = reorganizePlanes(hitsItr->stationID(), hitsItr->pixelLayerID());
223  planeHitsAllMU = reorganizePlanes(hitsItr->stationID(), hitsItr->pixelLayerID());
224  weightAllPlanes = 1 / muPerBX;
225  fill("AFPSiLayerTool", planeHitsAll);
226  fill("AFPSiLayerTool", planeHitsAllMU, weightAllPlanes);
227  weightAllPlanes = 1.0;
228 
229  numberOfHitsPerStation = hitsItr->stationID();
230  fill("AFPSiLayerTool", numberOfHitsPerStation);
231 
232  fill("AFPSiLayerTool", lbHits);
233 
234  lbHitsPerPlanes = eventInfo->lumiBlock();
235  lbHitsPerPlanes_full = eventInfo->lumiBlock();
236  weightHitsByMU = 1 / muPerBX;
237  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], lbHitsPerPlanes, weightHitsByMU);
238  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], lbHitsPerPlanes_full);
239  weightHitsByMU = 1.0;
240  }
241  else ATH_MSG_WARNING("Unrecognised station index: " << hitsItr->stationID());
242  }
243 
244  bool noEventsInStations = true;
245  for(int i=0; i<4; i++)
246  {
247  if(eventsInStations[i]>0) {
248  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbEventsStations);
249 
250  eventsPerStation = i * 4;
251  fill("AFPSiLayerTool", eventsPerStation);
252  ++eventsPerStation;
253  fill("AFPSiLayerTool", eventsPerStation);
254  ++eventsPerStation;
255  fill("AFPSiLayerTool", eventsPerStation);
256  ++eventsPerStation;
257  fill("AFPSiLayerTool", eventsPerStation);
258 
259  noEventsInStations = false;
260  }
261  }
262  if(!noEventsInStations)
263  {
264  fill("AFPSiLayerTool", lbEventsStationsAll);
265  }
266 
267  for(int i=0; i<4; i++)
268  {
269  hitsCounterStationsTProfile = numberOfHitsPerPlane[i][0] + numberOfHitsPerPlane[i][1] + numberOfHitsPerPlane[i][2] + numberOfHitsPerPlane[i][3];
270  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lb, hitsCounterStationsTProfile);
271  for(int j=0; j<4; j++)
272  {
273  if(numberOfHitsPerPlane[i][j]>0)
274  {
275  hitsCounterPlanesTProfile = numberOfHitsPerPlane[i][j];
276  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(i)).at(m_pixlayers.at(j))], lb, hitsCounterPlanesTProfile);
277  }
278  }
279  }
280 
281  // Filling of cluster and track 2D histograms
282  AFPMon::AFPFastReco fast(afpHitContainer.get());
283  fast.reco();
284 
285  // Track histograms:
286  unsigned int totalTracksAll[4] = {};
287  unsigned int totalTracksFront[4] = {};
288  unsigned int totalTracksMiddle[4] = {};
289  unsigned int totalTracksEnd[4] = {};
290 
291  for (const auto& track : fast.tracks())
292  {
293  trackX = track.x * 1.0;
294  trackY = track.y * 1.0;
295  fill(m_tools[m_StationGroup.at(m_stationnames.at(track.station))], trackY, trackX);
296 
297  if (position == FRONT)
298  {
299  ++totalTracksFront[track.station];
300  ++totalTracksAll[track.station];
301  }
302  else if (position == MIDDLE)
303  {
304  ++totalTracksMiddle[track.station];
305  ++totalTracksAll[track.station];
306  }
307  else if (position == END)
308  {
309  ++totalTracksEnd[track.station];
310  ++totalTracksAll[track.station];
311  }
312  }
313 
314  auto weightTracksAll = Monitored::Scalar<float>("weightTracksAll", 0.0);
315  auto weightTracksFront = Monitored::Scalar<float>("weightTracksFront", 0.0);
316  auto weightTracksMiddle = Monitored::Scalar<float>("weightTracksMiddle", 0.0);
317  auto weightTracksEnd = Monitored::Scalar<float>("weightTracksEnd", 0.0);
318 
319  auto lbTracksAll = Monitored::Scalar<int>("lbTracksAll", 0);
320  auto lbTracksFront = Monitored::Scalar<int>("lbTracksFront", 0);
321  auto lbTracksMiddle = Monitored::Scalar<int>("lbTracksMiddle", 0);
322  auto lbTracksEnd = Monitored::Scalar<int>("lbTracksEnd", 0);
323 
324  auto weightTracksAll_full = Monitored::Scalar<int>("weightTracksAll_full", 0);
325  auto weightTracksFront_full = Monitored::Scalar<int>("weightTracksFront_full", 0);
326  auto weightTracksMiddle_full = Monitored::Scalar<int>("weightTracksMiddle_full", 0);
327  auto weightTracksEnd_full = Monitored::Scalar<int>("weightTracksEnd_full", 0);
328 
329  auto lbTracksAll_full = Monitored::Scalar<int>("lbTracksAll_full", 0);
330  auto lbTracksFront_full = Monitored::Scalar<int>("lbTracksFront_full", 0);
331  auto lbTracksMiddle_full = Monitored::Scalar<int>("lbTracksMiddle_full", 0);
332  auto lbTracksEnd_full = Monitored::Scalar<int>("lbTracksEnd_full", 0);
333 
334  lbTracksAll = eventInfo->lumiBlock();
335  lbTracksFront = eventInfo->lumiBlock();
336  lbTracksMiddle = eventInfo->lumiBlock();
337  lbTracksEnd = eventInfo->lumiBlock();
338 
339  lbTracksAll_full = eventInfo->lumiBlock();
340  lbTracksFront_full = eventInfo->lumiBlock();
341  lbTracksMiddle_full = eventInfo->lumiBlock();
342  lbTracksEnd_full = eventInfo->lumiBlock();
343 
344  lbTracksAll_full = eventInfo->lumiBlock();
345  lbTracksFront_full = eventInfo->lumiBlock();
346  lbTracksMiddle_full = eventInfo->lumiBlock();
347  lbTracksEnd_full = eventInfo->lumiBlock();
348 
349  for(int i = 0; i < 4; i++)
350  {
351  weightTracksAll = totalTracksAll[i] / muPerBX;
352  weightTracksAll_full = totalTracksAll[i];
353  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksAll, weightTracksAll);
354  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksAll_full, weightTracksAll_full);
355  totalTracksAll[i] = 0;
356 
357  weightTracksFront = totalTracksFront[i] / muPerBX;
358  weightTracksFront_full = totalTracksFront[i];
359  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksFront, weightTracksFront);
360  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksFront_full, weightTracksFront_full);
361  totalTracksFront[i] = 0;
362 
363  weightTracksMiddle = totalTracksMiddle[i] / muPerBX;
364  weightTracksMiddle_full = totalTracksMiddle[i];
365  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksMiddle, weightTracksMiddle);
366  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksMiddle_full, weightTracksMiddle_full);
367  totalTracksMiddle[i] = 0;
368 
369  weightTracksEnd = totalTracksEnd[i] / muPerBX;
370  weightTracksEnd_full = totalTracksEnd[i];
371  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksEnd, weightTracksEnd);
372  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksEnd_full, weightTracksEnd_full);
373  totalTracksEnd[i] = 0;
374  }
375 
376  // Cluster histograms
377  for(const auto& cluster : fast.clusters())
378  {
379  clusterX = cluster.x * 1.0;
380  clusterY = cluster.y * 1.0;
381  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(cluster.station)).at(m_pixlayers.at(cluster.layer))], clusterY, clusterX);
382  if (cluster.station == 0 || cluster.station == 1)
383  {
384  clustersInPlanes = reorganizePlanes(cluster.station, cluster.layer);
385  }
386  else
387  {
388  clustersInPlanes = (cluster.station*4)+cluster.layer;
389  }
390  fill("AFPSiLayerTool", clustersInPlanes);
391 
392  clusterToT = cluster.sumToT;
393  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(cluster.station)).at(m_pixlayers.at(cluster.layer))], clusterToT);
394 
395  lbClustersPerPlanes = eventInfo->lumiBlock();
396  lbClustersPerPlanes_full = eventInfo->lumiBlock();
397  weightClustersByMU = 1/muPerBX;
398  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(cluster.station)).at(m_pixlayers.at(cluster.layer))], lbClustersPerPlanes, weightClustersByMU);
399  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(cluster.station)).at(m_pixlayers.at(cluster.layer))], lbClustersPerPlanes_full);
400  weightClustersByMU = 1.0;
401  }
402  return StatusCode::SUCCESS;
403 } // end of fillHistograms
404 
405 
ReadHandleKey.h
Property holding a SG store/key/clid from which a ReadHandle is made.
BunchCrossingCondData
Definition: BunchCrossingCondData.h:23
SG::ReadCondHandle
Definition: ReadCondHandle.h:44
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:70
AFPSiLayerAlgorithm::m_stationnames
std::vector< std::string > m_stationnames
Definition: AFPSiLayerAlgorithm.h:36
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
AFPSiLayerAlgorithm.h
xAOD::AFPSiHit_v2
Class representing a hit in silicon detector.
Definition: AFPSiHit_v2.h:30
SG::ReadCondHandle::isValid
bool isValid()
Definition: ReadCondHandle.h:206
SG::ReadHandleKey
Property holding a SG store/key/clid from which a ReadHandle is made.
Definition: StoreGate/StoreGate/ReadHandleKey.h:39
DeMoUpdate.reverse
reverse
Definition: DeMoUpdate.py:563
AthMonitorAlgorithm
Base class for Athena Monitoring Algorithms.
Definition: AthMonitorAlgorithm.h:36
AFPSiLayerAlgorithm::m_pixlayers
std::vector< std::string > m_pixlayers
Definition: AFPSiLayerAlgorithm.h:35
TauGNNUtils::Variables::Track::nSiHits
bool nSiHits(const xAOD::TauJet &, const xAOD::TauTrack &track, double &out)
Definition: TauGNNUtils.cxx:691
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AFPSiLayerAlgorithm::m_bunchCrossingKey
SG::ReadCondHandleKey< BunchCrossingCondData > m_bunchCrossingKey
Definition: AFPSiLayerAlgorithm.h:31
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:88
lumiFormat.i
int i
Definition: lumiFormat.py:92
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:30
AFPSiLayerAlgorithm::fillHistograms
virtual StatusCode fillHistograms(const EventContext &ctx) const override
adds event to the monitoring histograms
Definition: AFPSiLayerAlgorithm.cxx:53
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
AFPSiLayerAlgorithm::AFPSiLayerAlgorithm
AFPSiLayerAlgorithm(const std::string &name, ISvcLocator *pSvcLocator)
Definition: AFPSiLayerAlgorithm.cxx:24
TRT::Hit::layer
@ layer
Definition: HitInfo.h:79
internal_poltrig::END
@ END
Definition: PolygonTriangulator.cxx:112
AFPStationID.h
Definitions of AFP stations identification numbers.
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AFPSiLayerAlgorithm::m_afpHitContainerKey
SG::ReadHandleKey< xAOD::AFPSiHitContainer > m_afpHitContainerKey
Definition: AFPSiLayerAlgorithm.h:30
AthMonitorAlgorithm::fill
void fill(const ToolHandle< GenericMonitoringTool > &groupHandle, std::vector< std::reference_wrapper< Monitored::IMonitoredVariable >> &&variables) const
Fills a vector of variables to a group by reference.
AFPSiLayerAlgorithm::~AFPSiLayerAlgorithm
virtual ~AFPSiLayerAlgorithm()
Definition: AFPSiLayerAlgorithm.cxx:32
AthMonitorAlgorithm::GetEventInfo
SG::ReadHandle< xAOD::EventInfo > GetEventInfo(const EventContext &) const
Return a ReadHandle for an EventInfo object (get run/event numbers, etc.)
Definition: AthMonitorAlgorithm.cxx:107
xAOD::EventInfo_v1::lumiBlock
uint32_t lumiBlock() const
The current event's luminosity block number.
AFPSiLayerAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AFPSiLayerAlgorithm.cxx:35
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
AthMonitorAlgorithm::m_tools
ToolHandleArray< GenericMonitoringTool > m_tools
Array of Generic Monitoring Tools.
Definition: AthMonitorAlgorithm.h:338
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition: EventInfo_v1.cxx:133
AthMonitorAlgorithm::lbAverageInteractionsPerCrossing
virtual float lbAverageInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate the average mu, i.e.
Definition: AthMonitorAlgorithm.cxx:222
AthMonitorAlgorithm::initialize
virtual StatusCode initialize() override
initialize
Definition: AthMonitorAlgorithm.cxx:18
fast
bool fast
Definition: TrigGlobEffCorrValidation.cxx:190
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AFPSiLayerAlgorithm::m_StationPlaneGroup
std::map< std::string, std::map< std::string, int > > m_StationPlaneGroup
Definition: AFPSiLayerAlgorithm.h:28
AFPSiLayerAlgorithm::m_StationGroup
std::map< std::string, int > m_StationGroup
Definition: AFPSiLayerAlgorithm.h:29
SG::VarHandleBase::initialize
StatusCode initialize(bool used=true)
Verify that the handle has been configured properly.
Definition: StoreGate/src/VarHandleBase.cxx:465
timeOverThreshold
double timeOverThreshold(unsigned int m_word)
Definition: driftCircle.h:116
xAOD::track
@ track
Definition: TrackingPrimitives.h:512
AFPMon::AFPFastReco
Definition: AFPFastReco.h:51
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
xAOD::EventInfo_v1::bcid
uint32_t bcid() const
The bunch crossing ID of the event.
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
Generated on Thu Jul 4 2024 21:09:54 for ATLAS Offline Software by   doxygen 1.8.18