ATLAS Offline Software
AFPSiLayerAlgorithm.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 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 planeHitsAllMU = Monitored::Scalar<int>("planeHitsAllMU", 0);
132  auto weightAllPlanes = Monitored::Scalar<float>("weightAllPlanes", 1.0);
133 
134  auto numberOfHitsPerStation = Monitored::Scalar<int>("numberOfHitsPerStation", 0);
135 
136  auto lbEvents = Monitored::Scalar<int>("lbEvents", 0);
137  auto lbHits = Monitored::Scalar<int>("lbHits", 0);
138  auto lbEventsStations = Monitored::Scalar<int>("lbEventsStations", 0);
139  auto lbEventsStationsAll = Monitored::Scalar<int>("lbEventsStationsAll", 0);
140 
141  auto planes = Monitored::Scalar<int>("planes", 0);
142 
143  auto eventsPerStation = Monitored::Scalar<int>("eventsPerStation", 0);
144 
145  auto clusterToT = Monitored::Scalar<int>("clusterToT", 0);
146 
147  lb = eventInfo->lumiBlock();
148  lbEvents = eventInfo->lumiBlock();
149  //muPerBX = lbAverageInteractionsPerCrossing(ctx);
150  muPerBX = lbInteractionsPerCrossing(ctx);
151  if (muPerBX == 0.0) {
152  ATH_MSG_DEBUG("AverageInteractionsPerCrossing is 0, forcing to 1.0");
153  muPerBX=1.0;
154  }
155  fill("AFPSiLayerTool", lb, muPerBX);
156  fill("AFPSiLayerTool", lbEvents);
157 
158 
159  SG::ReadHandle<xAOD::AFPSiHitContainer> afpHitContainer(m_afpHitContainerKey, ctx);
160  if(! afpHitContainer.isValid())
161  {
162  ATH_MSG_WARNING("evtStore() does not contain hits collection with name " << m_afpHitContainerKey);
163  return StatusCode::SUCCESS;
164  }
165 
166  ATH_CHECK( afpHitContainer.initialize() );
167 
168  nSiHits = afpHitContainer->size();
169  fill("AFPSiLayerTool", lb, nSiHits);
170 
171  int eventsInStations[4] = {};
172  int numberOfHitsPerPlane[4][4] = {};
173 
174  for(const xAOD::AFPSiHit *hitsItr: *afpHitContainer)
175  {
176  lb = eventInfo->lumiBlock();
177  lbHits = eventInfo->lumiBlock();
178  lbEventsStations = eventInfo->lumiBlock();
179  lbEventsStationsAll = eventInfo->lumiBlock();
180  pixelRowIDChip = hitsItr->pixelRowIDChip();
181  pixelColIDChip = hitsItr->pixelColIDChip();
182  timeOverThreshold = hitsItr->timeOverThreshold();
183 
184 
185  if (hitsItr->stationID()<4 && hitsItr->stationID()>=0 && hitsItr->pixelLayerID()<4 && hitsItr->pixelLayerID()>=0)
186  {
187  ++eventsInStations[hitsItr->stationID()];
188 
189  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], pixelRowIDChip, pixelColIDChip);
190  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], pixelRowIDChip);
191  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], pixelColIDChip);
192  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(hitsItr->stationID())).at(m_pixlayers.at(hitsItr->pixelLayerID()))], timeOverThreshold);
193 
194  planeHits = hitsItr->pixelLayerID();
195  fill(m_tools[m_StationGroup.at(m_stationnames.at(hitsItr->stationID()))], planeHits);
196 
197  ++numberOfHitsPerPlane[hitsItr->stationID()][hitsItr->pixelLayerID()];
198  planeHitsAllMU = reorganizePlanes(hitsItr->stationID(), hitsItr->pixelLayerID());
199  weightAllPlanes = 1 / muPerBX;
200  fill("AFPSiLayerTool", planeHitsAllMU, weightAllPlanes);
201  weightAllPlanes = 1.0;
202 
203  numberOfHitsPerStation = hitsItr->stationID();
204  fill("AFPSiLayerTool", numberOfHitsPerStation);
205 
206  fill("AFPSiLayerTool", lbHits);
207  }
208  else ATH_MSG_WARNING("Unrecognised station index: " << hitsItr->stationID());
209  }
210 
211  auto hitsPerPlaneProfile = Monitored::Scalar<float>("hitsPerPlaneProfile", 0.0);
212  auto lbhitsPerPlaneProfile = Monitored::Scalar<int>("lbhitsPerPlaneProfile", 0);
213 
214  lbhitsPerPlaneProfile = eventInfo->lumiBlock();
215  for(int i_station = 0; i_station < 4; i_station++)
216  for(int j_layer = 0; j_layer < 4; j_layer++)
217  {
218  hitsPerPlaneProfile = numberOfHitsPerPlane[i_station][j_layer]/muPerBX;
219  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(i_station)).at(m_pixlayers.at(j_layer))], lbhitsPerPlaneProfile, hitsPerPlaneProfile);
220  }
221 
222 
223  bool noEventsInStations = true;
224  for(int i=0; i<4; i++)
225  {
226  if(eventsInStations[i]>0) {
227  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbEventsStations);
228 
229  eventsPerStation = i * 4;
230  fill("AFPSiLayerTool", eventsPerStation);
231  ++eventsPerStation;
232  fill("AFPSiLayerTool", eventsPerStation);
233  ++eventsPerStation;
234  fill("AFPSiLayerTool", eventsPerStation);
235  ++eventsPerStation;
236  fill("AFPSiLayerTool", eventsPerStation);
237 
238  noEventsInStations = false;
239  }
240  }
241  if(!noEventsInStations)
242  {
243  fill("AFPSiLayerTool", lbEventsStationsAll);
244  }
245 
246  // Filling of cluster and track 2D histograms
247  AFPMon::AFPFastReco fast(afpHitContainer.get());
248  fast.reco();
249 
250  // Track histograms:
251  unsigned int totalTracksAll[4] = {};
252  unsigned int totalTracksFront[4] = {};
253  unsigned int totalTracksMiddle[4] = {};
254  unsigned int totalTracksEnd[4] = {};
255 
256  for (const auto& track : fast.tracks())
257  {
258  trackX = track.x * 1.0;
259  trackY = track.y * 1.0;
260  fill(m_tools[m_StationGroup.at(m_stationnames.at(track.station))], trackY, trackX);
261 
262  if (position == FRONT)
263  {
264  ++totalTracksFront[track.station];
265  ++totalTracksAll[track.station];
266  }
267  else if (position == MIDDLE)
268  {
269  ++totalTracksMiddle[track.station];
270  ++totalTracksAll[track.station];
271  }
272  else if (position == END)
273  {
274  ++totalTracksEnd[track.station];
275  ++totalTracksAll[track.station];
276  }
277  }
278 
279  auto lbTracksAll = Monitored::Scalar<int>("lbTracksAll", 0);
280  auto lbTracksFront = Monitored::Scalar<int>("lbTracksFront", 0);
281  auto lbTracksMiddle = Monitored::Scalar<int>("lbTracksMiddle", 0);
282  auto lbTracksEnd = Monitored::Scalar<int>("lbTracksEnd", 0);
283 
284  auto Total_tracks_All_profile = Monitored::Scalar<float>("Total_tracks_All_profile", 0.0);
285  auto Total_tracks_Front_profile = Monitored::Scalar<float>("Total_tracks_Front_profile", 0.0);
286  auto Total_tracks_Middle_profile = Monitored::Scalar<float>("Total_tracks_Middle_profile", 0.0);
287  auto Total_tracks_End_profile = Monitored::Scalar<float>("Total_tracks_End_profile", 0.0);
288 
289  lbTracksAll = eventInfo->lumiBlock();
290  lbTracksFront = eventInfo->lumiBlock();
291  lbTracksMiddle = eventInfo->lumiBlock();
292  lbTracksEnd = eventInfo->lumiBlock();
293 
294  for(int i = 0; i < 4; i++)
295  {
296  Total_tracks_All_profile = totalTracksAll[i] / muPerBX;
297  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksAll, Total_tracks_All_profile);
298  totalTracksAll[i] = 0;
299 
300  Total_tracks_Front_profile = totalTracksFront[i] / muPerBX;
301  if (position == FRONT)
302  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksFront, Total_tracks_Front_profile);
303  totalTracksFront[i] = 0;
304 
305  Total_tracks_Middle_profile = totalTracksMiddle[i] / muPerBX;
306  if (position == MIDDLE)
307  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksMiddle, Total_tracks_Middle_profile);
308  totalTracksMiddle[i] = 0;
309 
310  Total_tracks_End_profile = totalTracksEnd[i] / muPerBX;
311  if (position == END)
312  fill(m_tools[m_StationGroup.at(m_stationnames.at(i))], lbTracksEnd, Total_tracks_End_profile);
313  totalTracksEnd[i] = 0;
314  }
315 
316  // Cluster histograms
317  unsigned int totalClustersAll[4][4] = {};
318  unsigned int totalClustersFront[4][4] = {};
319  unsigned int totalClustersMiddle[4][4] = {};
320  unsigned int totalClustersEnd[4][4] = {};
321 
322  auto clustersPerPlaneAllPP = Monitored::Scalar<float>("clustersPerPlaneAllPP", 0.0);
323  auto clustersPerPlaneFrontPP = Monitored::Scalar<float>("clustersPerPlaneFrontPP", 0.0);
324  auto clustersPerPlaneMiddlePP = Monitored::Scalar<float>("clustersPerPlaneMiddlePP", 0.0);
325  auto clustersPerPlaneEndPP = Monitored::Scalar<float>("clustersPerPlaneEndPP", 0.0);
326 
327  auto lbClustersPerPlanesAll = Monitored::Scalar<int>("lbClustersPerPlanesAll", 0);
328  auto lbClustersPerPlanesFront = Monitored::Scalar<int>("lbClustersPerPlanesFront", 0);
329  auto lbClustersPerPlanesMiddle = Monitored::Scalar<int>("lbClustersPerPlanesMiddle", 0);
330  auto lbClustersPerPlanesEnd = Monitored::Scalar<int>("lbClustersPerPlanesEnd", 0);
331 
332  lbClustersPerPlanesAll = eventInfo->lumiBlock();
333  lbClustersPerPlanesFront = eventInfo->lumiBlock();
334  lbClustersPerPlanesMiddle = eventInfo->lumiBlock();
335  lbClustersPerPlanesEnd = eventInfo->lumiBlock();
336 
337  for(const auto& cluster : fast.clusters())
338  {
339  clusterX = cluster.x * 1.0;
340  clusterY = cluster.y * 1.0;
341  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(cluster.station)).at(m_pixlayers.at(cluster.layer))], clusterY, clusterX);
342  if (cluster.station == 0 || cluster.station == 1)
343  {
344  clustersInPlanes = reorganizePlanes(cluster.station, cluster.layer);
345  }
346  else
347  {
348  clustersInPlanes = (cluster.station*4)+cluster.layer;
349  }
350  fill("AFPSiLayerTool", clustersInPlanes);
351 
352  clusterToT = cluster.sumToT;
353  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(cluster.station)).at(m_pixlayers.at(cluster.layer))], clusterToT);
354 
355  if (position == FRONT)
356  {
357  ++totalClustersFront[cluster.station][cluster.layer];
358  ++totalClustersAll[cluster.station][cluster.layer];
359  }
360  else if (position == MIDDLE)
361  {
362  ++totalClustersMiddle[cluster.station][cluster.layer];
363  ++totalClustersAll[cluster.station][cluster.layer];
364  }
365  else if (position == END)
366  {
367  ++totalClustersEnd[cluster.station][cluster.layer];
368  ++totalClustersAll[cluster.station][cluster.layer];
369  }
370  }
371 
372  for(int i_station = 0; i_station < 4; i_station++)
373  for(int j_layer = 0; j_layer < 4; j_layer++)
374  {
375  clustersPerPlaneAllPP = totalClustersAll[i_station][j_layer] / muPerBX;
376  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(i_station)).at(m_pixlayers.at(j_layer))], lbClustersPerPlanesAll, clustersPerPlaneAllPP);
377  totalClustersAll[i_station][j_layer] = 0;
378 
379  clustersPerPlaneFrontPP = totalClustersFront[i_station][j_layer] / muPerBX;
380  if (position == FRONT)
381  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(i_station)).at(m_pixlayers.at(j_layer))], lbClustersPerPlanesFront, clustersPerPlaneFrontPP);
382  totalClustersFront[i_station][j_layer] = 0;
383 
384  clustersPerPlaneMiddlePP = totalClustersMiddle[i_station][j_layer] / muPerBX;
385  if (position == MIDDLE)
386  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(i_station)).at(m_pixlayers.at(j_layer))], lbClustersPerPlanesMiddle, clustersPerPlaneMiddlePP);
387  totalClustersMiddle[i_station][j_layer] = 0;
388 
389  clustersPerPlaneEndPP = totalClustersEnd[i_station][j_layer] / muPerBX;
390  if (position == END)
391  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(i_station)).at(m_pixlayers.at(j_layer))], lbClustersPerPlanesEnd, clustersPerPlaneEndPP);
392  totalClustersEnd[i_station][j_layer] = 0;
393  }
394 
395  return(fillHistogramsPlaneEff(*afpHitContainer));
396 } // end of fillHistograms
397 
398 StatusCode AFPSiLayerAlgorithm::fillHistogramsPlaneEff(const xAOD::AFPSiHitContainer& afpHitContainer) const {
399  using namespace Monitored;
400 
401  // Define 2D histograms for tries and successes
402  Monitored::Scalar<bool> sit_plane_eff_passed("sit_plane_eff_passed", false);
403  Monitored::Scalar<float> sit_plane_eff_triedX("sit_plane_eff_triedX", 0.0);
404  Monitored::Scalar<float> sit_plane_eff_triedY("sit_plane_eff_triedY", 0.0);
405 
406  auto triesX = Monitored::Scalar<float>("triesX", 0.0);
407  auto triesY = Monitored::Scalar<float>("triesY", 0.0);
408 
409  auto successX = Monitored::Scalar<float>("successX", 0.0);
410  auto successY = Monitored::Scalar<float>("successY", 0.0);
411 
412 
413  auto clusterXLocal = Monitored::Scalar<float>("clusterXLocal", 0.0);
414  auto clusterYLocal = Monitored::Scalar<float>("clusterYLocal", 0.0);
415 
416  auto clusterXTag = Monitored::Scalar<float>("clusterXTag", 0.0);
417  auto clusterYTag = Monitored::Scalar<float>("clusterYTag", 0.0);
418 
419  AFPMon::AFPFastReco fast(&afpHitContainer);
420  fast.reco();
421 
422  int min_hits[4] = {3, 3, 3, 3};
423  int numStations = 4;
424  int numPlanes = 4;
425 
426  // Count clusters per station and plane
427  std::vector<std::vector<int>> nclusters_planes(numStations, std::vector<int>(numPlanes, 0));
428  for (const auto& cluster : fast.clusters()) {
429  ++nclusters_planes[cluster.station][cluster.layer];
430  }
431 
432  // Count planes with clusters at each station
433  std::vector<std::vector<int>> nclusters_other_planes(numStations, std::vector<int>(numPlanes, 0));
434  for (int iStation = 0; iStation < numStations; ++iStation) {
435  for (int iPlane = 0; iPlane < numPlanes; ++iPlane) {
436  for (int ip = 0; ip < numPlanes; ++ip) {
437  if (iPlane != ip && nclusters_planes[iStation][ip] > 0) {
438  ++nclusters_other_planes[iStation][iPlane];
439  }
440  }
441  }
442  }
443 
444  // Precomputed tag planes
445  std::array<std::set<int>, 4> precomputed_tag_planes = {
446  std::set<int>{0, 1, 2, 3},
447  std::set<int>{0, 1, 2, 3},
448  std::set<int>{0, 1, 2, 3},
449  std::set<int>{0, 1, 2, 3}
450  };
451 
452  // Precomputed clusters by Stations and Planes
453  using ClusterType = std::decay_t<decltype(*fast.clusters().begin())>;
454  std::vector<std::vector<std::vector<ClusterType>>> clusters_by_station_layer(numStations,
455  std::vector<std::vector<ClusterType>>(numPlanes));
456 
457  for (const auto& cluster : fast.clusters()) {
458  clusters_by_station_layer[cluster.station][cluster.layer].push_back(cluster);
459  }
460 
461  for (int iStation = 0; iStation < numStations; ++iStation) {
462  for (int iPlane = 0; iPlane < numPlanes; ++iPlane) {
463  // Skip if no enough hits in other planes
464  if (nclusters_other_planes[iStation][iPlane] < min_hits[iStation]) {continue;}
465 
466  std::set<int> tag_planes = precomputed_tag_planes[iStation];
467  tag_planes.erase(iPlane);
468 
469  std::vector<int> v_tag_planes(tag_planes.begin(), tag_planes.end());
470  int seed = v_tag_planes[0]; // Take first plane as a seed
471 
472  // Iterate only stations coresponding to the given Station and Layer
473  for (const auto& cluster : clusters_by_station_layer[iStation][seed]) {
474  int found_in_other_tag_planes = 0;
475 
476  // Check other tag planes using lookup
477  for (size_t i = 1; i < v_tag_planes.size(); ++i) {
478  int tag_plane = v_tag_planes[i];
479  bool found = false;
480 
481  for (const auto& clusterTag : clusters_by_station_layer[iStation][tag_plane]) {
482  if (std::fabs(cluster.x - clusterTag.x) < 2.0 && std::fabs(cluster.y - clusterTag.y) < 2.0) {
483  found = true;
484  ++found_in_other_tag_planes;
485  break;
486  }
487  }
488  // if not found in current tag plane
489  if (!found) {break;}
490  }
491 
492  // Check if valid tag
493  if (found_in_other_tag_planes == static_cast<int>(v_tag_planes.size()) - 1) {
494  sit_plane_eff_triedX = cluster.x;
495  sit_plane_eff_triedY = cluster.y;
496 
497  // Check probe plane
498  for (const auto& clusterTag : clusters_by_station_layer[iStation][iPlane]) {
499  if (std::fabs(cluster.x - clusterTag.x) < 2.0 && std::fabs(cluster.y - clusterTag.y) < 2.0) {
500  sit_plane_eff_passed = true;
501  break;
502  }
503  }
504 
505  fill(m_tools[m_StationPlaneGroup.at(m_stationnames.at(iStation)).at(m_pixlayers.at(iPlane))],
506  sit_plane_eff_passed, sit_plane_eff_triedY, sit_plane_eff_triedX);
507  sit_plane_eff_passed = false;
508  }
509  }
510  }
511  }
512  return StatusCode::SUCCESS;
513 }
514 
515 
ReadHandleKey.h
Property holding a SG store/key/clid from which a ReadHandle is made.
AthMonitorAlgorithm::lbInteractionsPerCrossing
virtual float lbInteractionsPerCrossing(const EventContext &ctx=Gaudi::Hive::currentContext()) const
Calculate instantaneous number of interactions, i.e.
Definition: AthMonitorAlgorithm.cxx:239
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:67
AFPSiLayerAlgorithm::m_stationnames
std::vector< std::string > m_stationnames
Definition: AFPSiLayerAlgorithm.h:37
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:210
SG::ReadHandleKey
Property holding a SG store/key/clid from which a ReadHandle is made.
Definition: StoreGate/StoreGate/ReadHandleKey.h:39
AFPSiLayerAlgorithm::fillHistogramsPlaneEff
virtual StatusCode fillHistogramsPlaneEff(const xAOD::AFPSiHitContainer &) const
Definition: AFPSiLayerAlgorithm.cxx:398
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:36
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
AFPSiLayerAlgorithm::m_bunchCrossingKey
SG::ReadCondHandleKey< BunchCrossingCondData > m_bunchCrossingKey
Definition: AFPSiLayerAlgorithm.h:32
python.BunchSpacingUtils.lb
lb
Definition: BunchSpacingUtils.py:86
lumiFormat.i
int i
Definition: lumiFormat.py:85
Monitored
Generic monitoring tool for athena components.
Definition: GenericMonitoringTool.h:28
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
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T, V, H > &t)
Definition: AthCommonDataStore.h:145
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.
find_tgc_unfilled_channelids.ip
ip
Definition: find_tgc_unfilled_channelids.py:3
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AFPSiLayerAlgorithm::m_afpHitContainerKey
SG::ReadHandleKey< xAOD::AFPSiHitContainer > m_afpHitContainerKey
Definition: AFPSiLayerAlgorithm.h:31
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
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
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:240
SG::CondHandleKey::initialize
StatusCode initialize(bool used=true)
checkTriggerxAOD.found
found
Definition: checkTriggerxAOD.py:328
xAOD::bcid
setEventNumber setTimeStamp bcid
Definition: EventInfo_v1.cxx:133
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:29
AFPSiLayerAlgorithm::m_StationGroup
std::map< std::string, int > m_StationGroup
Definition: AFPSiLayerAlgorithm.h:30
SG::VarHandleBase::initialize
StatusCode initialize(bool used=true)
Verify that the handle has been configured properly.
Definition: StoreGate/src/VarHandleBase.cxx:458
timeOverThreshold
double timeOverThreshold(unsigned int m_word)
Definition: driftCircle.h:116
xAOD::track
@ track
Definition: TrackingPrimitives.h:513
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.
IDTPM::nSiHits
float nSiHits(const U &p)
Definition: TrackParametersHelper.h:427
Generated on Mon Sep 29 2025 21:06:16 for ATLAS Offline Software by   doxygen 1.8.18