ATLAS Offline Software
FPGAOutputValidationAlg.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 #include "EFTrackingFPGAOutputValidation/FPGAOutputValidationAlg.h"
6 #include "InDetMeasurementUtilities/Helpers.h"
7 
8 namespace {
9 
10  template <typename T>
11  struct ClusterPair {
12  std::pair<const T*, const T*> clusters;
13  size_t commonRDOs = 0;
14 
15  ClusterPair(const T* cluster1, const T* cluster2, size_t commonRDOsCount)
16  : clusters(cluster1, cluster2), commonRDOs(commonRDOsCount) {};
17  };
18 
26  template <typename T>
27  size_t compareClusters(const T* cluster1, const T* cluster2, size_t* nonCommonRdo1 = nullptr, size_t* nonCommonRdo2 = nullptr) {
28  const auto& rdoList1 = cluster1->rdoList();
29  const auto& rdoList2 = cluster2->rdoList();
30  std::unordered_set<Identifier> rdoSet1(rdoList1.begin(), rdoList1.end());
31  std::unordered_set<Identifier> rdoSet2(rdoList2.begin(), rdoList2.end());
32 
33  size_t nCommonRdo = 0;
34  for (const auto& rdo : rdoList1) {
35  if (rdoSet2.count(rdo)) {
36  ++nCommonRdo;
37  }
38  }
39  if (nonCommonRdo1) *nonCommonRdo1 = rdoList1.size() - nCommonRdo;
40  if (nonCommonRdo2) *nonCommonRdo2 = rdoList2.size() - nCommonRdo;
41 
42  return nCommonRdo;
43  }
44 
54  template <typename T>
55  std::vector<const T*> findMatchingCluster(const T* cluster0,
56  const std::unordered_multimap<xAOD::DetectorIdentType, const T*>& clusterMap,
57  const std::unordered_multimap<xAOD::DetectorIDHashType, const T*>& clusterMapHashIdMap,
58  bool matchByID, const size_t& allowedMisses) {
59  std::vector<const T*> matchedClusters{};
60 
61  std::unordered_set<Identifier> rdoSet0{};
62  for (const auto& rdo : cluster0->rdoList()) {
63  rdoSet0.insert(rdo);
64  }
65  const size_t rdoToMiss = (allowedMisses < rdoSet0.size()) ? allowedMisses : (rdoSet0.size()-1);
66  if (matchByID) {
67  auto range = clusterMap.equal_range(cluster0->identifier());
68  for (auto it = range.first; it != range.second; ++it) {
69  size_t nCommonRdo = compareClusters(cluster0, it->second);
70  if (nCommonRdo >= rdoSet0.size() - rdoToMiss) {
71  matchedClusters.push_back(it->second);
72  }
73  }
74  } else {
75  auto range = clusterMapHashIdMap.equal_range(cluster0->identifierHash());
76  for (auto it = range.first; it != range.second; ++it) {
77  const auto& cluster1 = it->second;
78  size_t nCommonRdo = compareClusters(cluster0, cluster1);
79  if (nCommonRdo >= rdoSet0.size() - rdoToMiss) {
80  matchedClusters.push_back(cluster1);
81  }
82  }
83  }
84  return matchedClusters;
85  }
86 
87 
99  template <typename T>
100  std::vector<ClusterPair<T>> findNonMergedClusters(const std::unordered_multimap<xAOD::DetectorIDHashType, const T*>& clusterMap) {
101  std::vector<ClusterPair<T>> clusterPairs;
102  std::unordered_set<xAOD::DetectorIDHashType> uniqueKeys;
103  for (const auto& pair : clusterMap) {
104  uniqueKeys.insert(pair.first);
105  }
106  for (const auto& key : uniqueKeys) {
107  auto range = clusterMap.equal_range(key);
108  for (auto it1 = range.first; it1 != range.second; ++it1) {
109  for (auto it2 = std::next(it1); it2 != range.second; ++it2) {
110  size_t nonCommonRdo1 = 0, nonCommonRdo2 = 0;
111  size_t nCommonRdo = compareClusters(it1->second, it2->second, &nonCommonRdo1, &nonCommonRdo2);
112  if (nCommonRdo > 0) {
113  clusterPairs.emplace_back(it1->second, it2->second, nCommonRdo);
114  }
115  }
116  }
117  }
118  return clusterPairs;
119  }
120 
121  template <typename T>
122  std::string logMultipleClusterMatches(const std::vector<const T*>& matchedClusters) {
123  std::string out;
124 
125  out += "Found " + std::to_string(matchedClusters.size()) + " FPGA ";
126  out += (matchedClusters[0]->type() == xAOD::UncalibMeasType::PixelClusterType ? "Pixel" : "Strip");
127  out += " clusters matching to the same offline cluster:\n";
128  for (const auto& cluster : matchedClusters) {
129  out += std::to_string(cluster->identifier()) + " x: " + std::to_string(cluster->globalPosition()[0]) +
130  " y: " + std::to_string(cluster->globalPosition()[1]) + " z: " + std::to_string(cluster->globalPosition()[2]) + "\n";
131  for (const auto& rdo : cluster->rdoList()) {
132  out += "\t" + std::to_string(rdo.get_compact()) + "\n";
133  }
134  out += "\n";
135  }
136  return out;
137  }
138 }
139 
140 FPGAOutputValidationAlg::FPGAOutputValidationAlg(
141  const std::string& name,
142  ISvcLocator* pSvcLocator
143 ) : AthReentrantAlgorithm(name, pSvcLocator)
144 {}
145 
146 StatusCode FPGAOutputValidationAlg::initialize() {
147  ATH_MSG_INFO("Initializing FPGAOutputValidationAlg");
148 
149  ATH_CHECK(m_pixelKeys.initialize(!m_pixelKeys.empty()));
150  ATH_CHECK(m_stripKeys.initialize(!m_stripKeys.empty()));
151 
152  ATH_CHECK(m_monitoringTool.retrieve());
153 
154  ATH_CHECK(m_chrono.retrieve());
155 
156  ATH_CHECK(detStore()->retrieve(m_pixelid, "PixelID"));
157  ATH_CHECK(detStore()->retrieve(m_stripid, "SCT_ID"));
158  ATH_CHECK(detStore()->retrieve(m_SCT_mgr, "ITkStrip"));
159  ATH_CHECK(detStore()->retrieve(m_PIX_mgr, "ITkPixel"));
160 
161  return StatusCode::SUCCESS;
162 }
163 
164 StatusCode FPGAOutputValidationAlg::execute(const EventContext& ctx) const {
165  if (m_pixelKeys.size() == 2 && m_doDiffHistograms) {
166  m_chrono->chronoStart("FPGAOutputValidationAlg::pixel diff");
167  const SG::ReadHandleKey<xAOD::PixelClusterContainer>& key0 = m_pixelKeys[0];
168  const SG::ReadHandleKey<xAOD::PixelClusterContainer>& key1 = m_pixelKeys[1];
169  SG::ReadHandle<xAOD::PixelClusterContainer> handle0{key0, ctx};
170  ATH_CHECK(handle0.isValid());
171  SG::ReadHandle<xAOD::PixelClusterContainer> handle1{key1, ctx};
172  ATH_CHECK(handle1.isValid());
173 
174  if (m_checkClusterRdos) {
175  const auto& pixelClusters0 = *handle0;
176  std::unordered_multimap<xAOD::DetectorIDHashType, const xAOD::PixelCluster*> pixelClustersHashIdMap0; // assumes that the first key is the FPGA one
177  for (const auto* cluster0 : pixelClusters0) {
178  const xAOD::DetectorIDHashType hashId0 = cluster0->identifierHash();
179  pixelClustersHashIdMap0.insert(std::make_pair(hashId0, cluster0));
180  }
181  const std::vector<ClusterPair<xAOD::PixelCluster>> pixelClusterPairsWithCommonRdos = findNonMergedClusters(pixelClustersHashIdMap0);
182  if (pixelClusterPairsWithCommonRdos.size() > 0) {
183  std::stringstream ss;
184  for (const auto& pair : pixelClusterPairsWithCommonRdos) {
185  ss << "Found " << pair.commonRDOs << " common RDOs between clusters with hash "
186  << pair.clusters.first->identifierHash() << ": "
187  << pair.clusters.first->identifier() << " and "
188  << pair.clusters.second->identifier() << "\n";
189  }
190  ATH_MSG_ERROR("Pixel cluster pairs with common RDOs:\n" << ss.str());
191  }
192  }
193 
194  const xAOD::PixelClusterContainer pixelClusters1 = *handle1;
195  std::unordered_multimap<xAOD::DetectorIdentType, const xAOD::PixelCluster*> pixelClustersMap1;
196  std::unordered_multimap<xAOD::DetectorIDHashType, const xAOD::PixelCluster*> pixelClustersHashIdMap1;
197  for (const auto* cluster1 : pixelClusters1) {
198  const xAOD::DetectorIdentType id1 = cluster1->identifier();
199  const xAOD::DetectorIDHashType hashId1 = cluster1->identifierHash();
200  pixelClustersMap1.insert(std::make_pair(id1, cluster1));
201  pixelClustersHashIdMap1.insert(std::make_pair(hashId1, cluster1));
202  }
203 
204  for (auto cluster0 : *handle0) {
205  const std::vector<const xAOD::PixelCluster*> matchedClusters = findMatchingCluster(cluster0, pixelClustersMap1, pixelClustersHashIdMap1,
206  m_matchByID,
207  m_allowedRdoMisses);
208 
209  if (matchedClusters.size() == 0) {
210  std::vector<std::string> regions {"all"};
211  if(m_pixelid->barrel_ec(cluster0->rdoList()[0]) == 0) regions.push_back("barrel");
212  else regions.push_back("endcap");
213  for (const auto& region : regions) {
214  Monitored::Group(
215  m_monitoringTool,
216  Monitored::Scalar<float>(handle0.key() + "_UNMATCHED_GLOBALPOSITION_Z_" + region, cluster0->globalPosition()[2]),
217  Monitored::Scalar<float>(handle0.key() + "_UNMATCHED_GLOBALPOSITION_R_" + region, sqrt(cluster0->globalPosition()[0]*cluster0->globalPosition()[0] +
218  cluster0->globalPosition()[1]*cluster0->globalPosition()[1])),
219  Monitored::Scalar<float>("nmatched_pixel_clusters_"+region, matchedClusters.size() - 0.5)
220  );
221  }
222  continue;
223  }
224  if (matchedClusters.size() > 1) {
225  ATH_MSG_ERROR(logMultipleClusterMatches(matchedClusters));
226  return StatusCode::FAILURE;
227  }
228 
229  const xAOD::PixelCluster *cluster1 = matchedClusters[0];
230 
231  std::vector<std::string> regions {"all"};
232  if(m_pixelid->barrel_ec(cluster0->rdoList()[0]) == 0) regions.push_back("barrel");
233  else regions.push_back("endcap");
234 
235  for(auto const& region: regions)
236  {
237  Monitored::Group(
238  m_monitoringTool,
239  Monitored::Scalar<float>("diff_pixel_locx_" +region , cluster0->localPosition<2>()[0] - cluster1->localPosition<2>()[0]),
240  Monitored::Scalar<float>("diff_pixel_locy_" +region , cluster0->localPosition<2>()[1] - cluster1->localPosition<2>()[1]),
241  Monitored::Scalar<float>("diff_pixel_covxx_" +region , cluster0->localCovariance<2>()(0, 0) - cluster1->localCovariance<2>()(0, 0)),
242  Monitored::Scalar<float>("diff_pixel_covyy_" +region , cluster0->localCovariance<2>()(1, 1) - cluster1->localCovariance<2>()(1, 1)),
243  Monitored::Scalar<float>("diff_pixel_globalx_" +region , cluster0->globalPosition()[0] - cluster1->globalPosition()[0]),
244  Monitored::Scalar<float>("diff_pixel_globaly_" +region , cluster0->globalPosition()[1] - cluster1->globalPosition()[1]),
245  Monitored::Scalar<float>("diff_pixel_globalz_" +region , cluster0->globalPosition()[2] - cluster1->globalPosition()[2]),
246  Monitored::Scalar<int>("diff_pixel_channelsphi_" +region , cluster0->channelsInPhi() - cluster1->channelsInPhi()),
247  Monitored::Scalar<int>("diff_pixel_channelseta_" +region , cluster0->channelsInEta() - cluster1->channelsInEta()),
248  Monitored::Scalar<float>("diff_pixel_widtheta_" +region , cluster0->widthInEta() - cluster1->widthInEta()),
249  Monitored::Scalar<int>("diff_pixel_tot_" +region , cluster0->totalToT() - cluster1->totalToT()),
250  Monitored::Scalar<int>("diff_pixel_rdos_" +region , cluster0->rdoList().size() - cluster1->rdoList().size()),
251  Monitored::Scalar<float>("pixel_globalR_ref_" + region, sqrt(cluster1->globalPosition()[0]*cluster1->globalPosition()[0] +
252  cluster1->globalPosition()[1]*cluster1->globalPosition()[1])),
253  Monitored::Scalar<float>("pixel_globalZ_ref_" + region, cluster1->globalPosition()[2]),
254  Monitored::Scalar<float>("nmatched_pixel_clusters_"+region, matchedClusters.size() - 0.5)
255  );
256  if(region != "all")
257  {
258  Monitored::Group(
259  m_monitoringTool,
260  Monitored::Scalar<float>("diff_pixel_locx_"+region+"Layer" + std::to_string(m_pixelid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
261  cluster0->localPosition<2>()[0] - cluster1->localPosition<2>()[0]),
262  Monitored::Scalar<float>("diff_pixel_locy_"+region+"Layer" + std::to_string(m_pixelid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
263  cluster0->localPosition<2>()[1] - cluster1->localPosition<2>()[1]),
264  Monitored::Scalar<float>("diff_pixel_covxx_"+region+"Layer" + std::to_string(m_pixelid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
265  cluster0->localCovariance<2>()(0, 0) - cluster1->localCovariance<2>()(0, 0)),
266  Monitored::Scalar<float>("diff_pixel_covyy_"+region+"Layer" + std::to_string(m_pixelid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
267  cluster0->localCovariance<2>()(1, 1) - cluster1->localCovariance<2>()(1, 1)),
268  Monitored::Scalar<float>("diff_pixel_globalX_"+region+"Layer" + std::to_string(m_pixelid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
269  cluster0->globalPosition()[0] - cluster1->globalPosition()[0]),
270  Monitored::Scalar<float>("diff_pixel_globalY_"+region+"Layer" + std::to_string(m_pixelid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
271  cluster0->globalPosition()[1] - cluster1->globalPosition()[1]),
272  Monitored::Scalar<float>("diff_pixel_globalZ_"+region+"Layer" + std::to_string(m_pixelid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
273  cluster0->globalPosition()[2] - cluster1->globalPosition()[2]),
274  Monitored::Scalar<float>("nmatched_pixel_clusters_"+region, matchedClusters.size() - 0.5)
275  );
276  }
277  }
278  }
279  m_chrono->chronoStop("FPGAOutputValidationAlg::pixel diff");
280  }
281 
282  if (m_stripKeys.size() == 2 && m_doDiffHistograms) {
283  m_chrono->chronoStart("FPGAOutputValidationAlg::strip diff");
284  const SG::ReadHandleKey<xAOD::StripClusterContainer>& key0 = m_stripKeys[0];
285  const SG::ReadHandleKey<xAOD::StripClusterContainer>& key1 = m_stripKeys[1];
286  SG::ReadHandle<xAOD::StripClusterContainer> handle0{key0, ctx};
287  ATH_CHECK(handle0.isValid());
288  SG::ReadHandle<xAOD::StripClusterContainer> handle1{key1, ctx};
289  ATH_CHECK(handle1.isValid());
290 
291  if (m_checkClusterRdos) {
292  const xAOD::StripClusterContainer stripClusters0 = *handle0;
293  std::unordered_multimap<xAOD::DetectorIDHashType, const xAOD::StripCluster*> stripClustersHashIdMap0; // assumes that the first key is the FPGA one
294  for (const auto* cluster0 : stripClusters0) {
295  const xAOD::DetectorIDHashType hashId0 = cluster0->identifierHash();
296  stripClustersHashIdMap0.insert(std::make_pair(hashId0, cluster0));
297  }
298 
299  // Find all pairs of clusters within the same detector element that share at least one RDO
300  const std::vector<ClusterPair<xAOD::StripCluster>> stripPairsWithCommonRdos = findNonMergedClusters(stripClustersHashIdMap0);
301 
302  // If any such pairs are found, log an error with details for debugging
303  if (stripPairsWithCommonRdos.size() > 0) {
304  std::stringstream ss;
305  for (const auto& pair : stripPairsWithCommonRdos) {
306  ss << "Found " << pair.commonRDOs << " common RDOs between clusters with hash "
307  << pair.clusters.first->identifierHash() << ": "
308  << pair.clusters.first->identifier() << " and "
309  << pair.clusters.second->identifier() << "\n";
310  }
311  ATH_MSG_ERROR("Strip cluster pairs with common RDOs:\n" << ss.str());
312  }
313  }
314  const xAOD::StripClusterContainer stripClusters1 = *handle1;
315  std::unordered_multimap<xAOD::DetectorIdentType, const xAOD::StripCluster*> stripClustersMap1;
316  std::unordered_multimap<xAOD::DetectorIDHashType, const xAOD::StripCluster*> stripClustersHashIdMap1;
317  for (const auto *cluster1 : stripClusters1) {
318  const xAOD::DetectorIdentType id1 = cluster1->identifier();
319  const xAOD::DetectorIDHashType hashId1 = cluster1->identifierHash();
320  stripClustersMap1.insert(std::make_pair(id1, cluster1));
321  stripClustersHashIdMap1.insert(std::make_pair(hashId1, cluster1));
322  }
323 
324 
325  for (auto cluster0 : *handle0) {
326  const std::vector<const xAOD::StripCluster*> matchedClusters = findMatchingCluster(cluster0, stripClustersMap1, stripClustersHashIdMap1,
327  m_matchByID,
328  m_allowedRdoMisses);
329 
330  if (matchedClusters.size() == 0 && handle1->size() > 0) {
331  std::vector<std::string> regions {"all"};
332  if(m_stripid->barrel_ec(cluster0->rdoList()[0]) == 0) regions.push_back("barrel");
333  else regions.push_back("endcap");
334  for (const auto& region : regions) {
335  Monitored::Group(
336  m_monitoringTool,
337  Monitored::Scalar<float>(handle0.key() + "_UNMATCHED_GLOBALPOSITION_Z_" + region, cluster0->globalPosition()[2]),
338  Monitored::Scalar<float>(handle0.key() + "_UNMATCHED_GLOBALPOSITION_R_" + region, sqrt(cluster0->globalPosition()[0]*cluster0->globalPosition()[0] +
339  cluster0->globalPosition()[1]*cluster0->globalPosition()[1])),
340  Monitored::Scalar<float>("nmatched_strip_clusters_"+region, matchedClusters.size() - 0.5)
341  );
342  }
343  continue;
344  }
345  if (matchedClusters.size() > 1) {
346  ATH_MSG_ERROR(logMultipleClusterMatches(matchedClusters));
347  return StatusCode::FAILURE;
348  }
349 
350  const xAOD::StripCluster *cluster1 = matchedClusters[0];
351 
352  std::vector<std::string> regions {"all"};
353  if(m_stripid->barrel_ec(cluster0->rdoList()[0]) == 0) regions.push_back("barrel");
354  else regions.push_back("endcap");
355 
356  for(auto const& region: regions)
357  {
358  Monitored::Group(
359  m_monitoringTool,
360  Monitored::Scalar<float>("diff_strip_locx_" + region, cluster0->localPosition<1>()[0] - cluster1->localPosition<1>()[0]),
361  Monitored::Scalar<float>("diff_strip_locxZoom_" + region, cluster0->localPosition<1>()[0] - cluster1->localPosition<1>()[0]),
362  Monitored::Scalar<float>("diff_strip_covxx_" + region, cluster0->localCovariance<1>()(0, 0) - cluster1->localCovariance<1>()(0, 0)),
363  Monitored::Scalar<float>("diff_strip_globalx_" + region, cluster0->globalPosition()[0] - cluster1->globalPosition()[0]),
364  Monitored::Scalar<float>("diff_strip_globaly_" + region, cluster0->globalPosition()[1] - cluster1->globalPosition()[1]),
365  Monitored::Scalar<float>("diff_strip_globalz_" + region, cluster0->globalPosition()[2] - cluster1->globalPosition()[2]),
366  Monitored::Scalar<float>("diff_strip_channelsphi_" + region, cluster0->channelsInPhi() - cluster1->channelsInPhi()),
367  Monitored::Scalar<int>("diff_strip_rdos_" +region , cluster0->rdoList().size() - cluster1->rdoList().size()),
368  Monitored::Scalar<float>("strip_globalR_ref_" + region, sqrt(cluster1->globalPosition()[0]*cluster1->globalPosition()[0] +
369  cluster1->globalPosition()[1]*cluster1->globalPosition()[1])),
370  Monitored::Scalar<float>("strip_globalZ_ref_" + region, cluster1->globalPosition()[2]),
371  Monitored::Scalar<float>("nmatched_strip_clusters_"+region, matchedClusters.size() - 0.5)
372  );
373  if(region != "all")
374  {
375  Monitored::Group(
376  m_monitoringTool,
377  Monitored::Scalar<float>("diff_strip_locx_"+region+"Layer" + std::to_string(m_stripid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
378  cluster0->localPosition<1>()[0] - cluster1->localPosition<1>()[0]),
379  Monitored::Scalar<float>("diff_strip_locxZoom_"+region+"Layer" + std::to_string(m_stripid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
380  cluster0->localPosition<1>()[0] - cluster1->localPosition<1>()[0]),
381  Monitored::Scalar<float>("diff_strip_covxx_"+region+"Layer" + std::to_string(m_stripid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
382  cluster0->localCovariance<1>()(0, 0) - cluster1->localCovariance<1>()(0, 0)),
383  Monitored::Scalar<float>("diff_strip_globalX_"+region+"Layer" + std::to_string(m_stripid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
384  cluster0->globalPosition()[0] - cluster1->globalPosition()[0]),
385  Monitored::Scalar<float>("diff_strip_globalY_"+region+"Layer" + std::to_string(m_stripid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
386  cluster0->globalPosition()[1] - cluster1->globalPosition()[1]),
387  Monitored::Scalar<float>("diff_strip_globalZ_"+region+"Layer" + std::to_string(m_stripid->layer_disk(m_pixelid->wafer_id(cluster0->identifierHash()))),
388  cluster0->globalPosition()[2] - cluster1->globalPosition()[2]),
389  Monitored::Scalar<float>("nmatched_strip_clusters_"+region, matchedClusters.size() - 0.5)
390  );
391  }
392  }
393  }
394  m_chrono->chronoStop("FPGAOutputValidationAlg::strip diff");
395  }
396 
397  for (std::size_t index = 0; index < m_pixelKeys.size(); index++) {
398  const SG::ReadHandleKey<xAOD::PixelClusterContainer>& key = m_pixelKeys[index];
399  SG::ReadHandle<xAOD::PixelClusterContainer> handle{key, ctx};
400  ATH_CHECK(handle.isValid());
401 
402 
403  for(auto cluster : *handle)
404  {
405  std::vector<std::string> regions {"all"};
406  if(m_pixelid->barrel_ec(cluster->rdoList()[0]) == 0) regions.push_back("barrel");
407  else regions.push_back("endcap");
408 
409  for(auto const& region: regions)
410  {
411  Monitored::Group(
412  m_monitoringTool,
413  Monitored::Scalar<float>(key.key() + "_LOCALPOSITION_X_" + region, cluster->localPosition<2>()[0]),
414  Monitored::Scalar<float>(key.key() + "_LOCALPOSITION_Y_" + region, cluster->localPosition<2>()[1]),
415  Monitored::Scalar<float>(key.key() + "_LOCALCOVARIANCE_XX_" + region, cluster->localCovariance<2>()(0, 0)),
416  Monitored::Scalar<float>(key.key() + "_LOCALCOVARIANCE_YY_" + region, cluster->localCovariance<2>()(1, 1)),
417  Monitored::Scalar<float>(key.key() + "_GLOBALPOSITION_X_" + region, cluster->globalPosition()[0]),
418  Monitored::Scalar<float>(key.key() + "_GLOBALPOSITION_Y_" + region, cluster->globalPosition()[1]),
419  Monitored::Scalar<float>(key.key() + "_GLOBALPOSITION_Z_" + region, cluster->globalPosition()[2]),
420  Monitored::Scalar<int>(key.key() + "_CHANNELS_IN_PHI_" + region, cluster->channelsInPhi()),
421  Monitored::Scalar<int>(key.key() + "_CHANNELS_IN_ETA_" + region, cluster->channelsInEta()),
422  Monitored::Scalar<float>(key.key() + "_WIDTH_IN_ETA_" + region, cluster->widthInEta()),
423  Monitored::Scalar<int>(key.key() + "_TOTAL_TOT_" + region, cluster->totalToT())
424  );
425  }
426  }
427  }
428 
429  for (std::size_t index = 0; index < m_stripKeys.size(); index++) {
430  const SG::ReadHandleKey<xAOD::StripClusterContainer>& key = m_stripKeys[index];
431  SG::ReadHandle<xAOD::StripClusterContainer> handle{key, ctx};
432  ATH_CHECK(handle.isValid());
433 
434  for(auto cluster : *handle)
435  {
436  std::vector<std::string> regions {"all"};
437  if(m_stripid->barrel_ec(cluster->rdoList()[0]) == 0) regions.push_back("barrel");
438  else regions.push_back("endcap");
439 
440  for(auto const& region: regions)
441  {
442  Monitored::Group(
443  m_monitoringTool,
444  Monitored::Scalar<float>(key.key() + "_LOCALPOSITIONZOOM_X_" + region, cluster->localPosition<1>()(0,0)),
445  Monitored::Scalar<float>(key.key() + "_LOCALPOSITION_X_" + region, cluster->localPosition<1>()(0,0)),
446  Monitored::Scalar<float>(key.key() + "_LOCALCOVARIANCE_XX_" + region, cluster->localCovariance<1>()(0, 0)),
447  Monitored::Scalar<float>(key.key() + "_GLOBALPOSITION_X_" + region, cluster->globalPosition()[0]),
448  Monitored::Scalar<float>(key.key() + "_GLOBALPOSITION_Y_" + region, cluster->globalPosition()[1]),
449  Monitored::Scalar<float>(key.key() + "_GLOBALPOSITION_Z_" + region, cluster->globalPosition()[2]),
450  Monitored::Scalar<float>(key.key() + "_CHANNELS_IN_PHI_" + region, cluster->channelsInPhi())
451  );
452  }
453  }
454  }
455 
456  return StatusCode::SUCCESS;
457 }
458 
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
FPGAOutputValidationAlg::m_pixelKeys
SG::ReadHandleKeyArray< xAOD::PixelClusterContainer > m_pixelKeys
Definition: FPGAOutputValidationAlg.h:43
xAOD::DetectorIdentType
long unsigned int DetectorIdentType
Definition: MeasurementDefs.h:44
TrigDefs::Group
Group
Properties of a chain group.
Definition: GroupProperties.h:13
xAOD::PixelCluster_v1::widthInEta
float widthInEta() const
Returns the width of the cluster in phi (x) and eta (y) directions, respectively.
PowhegControl_ttHplus_NLO.ss
ss
Definition: PowhegControl_ttHplus_NLO.py:83
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
xAOD::StripCluster_v1::channelsInPhi
int channelsInPhi() const
Returns the dimensions of the cluster in numbers of channels in phi (x), respectively.
FPGAOutputValidationAlg::m_stripid
const SCT_ID * m_stripid
Definition: FPGAOutputValidationAlg.h:52
FPGAOutputValidationAlg::initialize
virtual StatusCode initialize() override final
Definition: FPGAOutputValidationAlg.cxx:146
xAOD::PixelCluster_v1::rdoList
const std::vector< Identifier > rdoList() const
Returns the list of identifiers of the channels building the cluster.
Definition: PixelCluster_v1.cxx:42
PixelID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: PixelID.h:615
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
index
Definition: index.py:1
skel.it
it
Definition: skel.GENtoEVGEN.py:407
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:70
FPGAOutputValidationAlg.h
SCT_ID::barrel_ec
int barrel_ec(const Identifier &id) const
Values of different levels (failure returns 0)
Definition: SCT_ID.h:728
FPGAOutputValidationAlg::FPGAOutputValidationAlg
FPGAOutputValidationAlg(const std::string &name, ISvcLocator *pSvcLocator)
Definition: FPGAOutputValidationAlg.cxx:140
FPGAOutputValidationAlg::m_stripKeys
SG::ReadHandleKeyArray< xAOD::StripClusterContainer > m_stripKeys
Definition: FPGAOutputValidationAlg.h:44
Helpers.h
SG::ReadHandleKey< xAOD::PixelClusterContainer >
PixelID::wafer_id
Identifier wafer_id(int barrel_ec, int layer_disk, int phi_module, int eta_module) const
For a single crystal.
Definition: PixelID.h:360
xAOD::StripCluster_v1::rdoList
const std::vector< Identifier > rdoList() const
Returns the list of identifiers of the channels building the cluster.
Definition: StripCluster_v1.cxx:37
AthCommonDataStore< AthCommonMsg< Gaudi::Algorithm > >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
Definition: AthCommonDataStore.h:95
FPGAOutputValidationAlg::m_chrono
ServiceHandle< IChronoStatSvc > m_chrono
Definition: FPGAOutputValidationAlg.h:49
AthReentrantAlgorithm
An algorithm that can be simultaneously executed in multiple threads.
Definition: AthReentrantAlgorithm.h:74
FPGAOutputValidationAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override final
Definition: FPGAOutputValidationAlg.cxx:164
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
fillPileUpNoiseLumi.next
next
Definition: fillPileUpNoiseLumi.py:52
FPGAOutputValidationAlg::m_checkClusterRdos
Gaudi::Property< bool > m_checkClusterRdos
Definition: FPGAOutputValidationAlg.h:41
FPGAOutputValidationAlg::m_SCT_mgr
const InDetDD::SiDetectorManager * m_SCT_mgr
Definition: FPGAOutputValidationAlg.h:54
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:194
FPGAOutputValidationAlg::m_allowedRdoMisses
Gaudi::Property< size_t > m_allowedRdoMisses
Definition: FPGAOutputValidationAlg.h:40
FPGAOutputValidationAlg::m_PIX_mgr
const InDetDD::SiDetectorManager * m_PIX_mgr
Definition: FPGAOutputValidationAlg.h:53
FPGAOutputValidationAlg::m_doDiffHistograms
Gaudi::Property< bool > m_doDiffHistograms
Definition: FPGAOutputValidationAlg.h:33
xAOD::StripCluster_v1
Definition: StripCluster_v1.h:17
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::UncalibratedMeasurement_v1::localCovariance
ConstMatrixMap< N > localCovariance() const
Returns the local covariance of the measurement.
FPGAOutputValidationAlg::m_matchByID
Gaudi::Property< bool > m_matchByID
Definition: FPGAOutputValidationAlg.h:39
DataVector
Derived DataVector<T>.
Definition: DataVector.h:794
xAOD::UncalibratedMeasurement_v1::localPosition
ConstVectorMap< N > localPosition() const
Returns the local position of the measurement.
PixelID::layer_disk
int layer_disk(const Identifier &id) const
Definition: PixelID.h:622
xAOD::PixelCluster_v1::globalPosition
ConstVectorMap< 3 > globalPosition() const
Returns the global position of the pixel cluster.
Definition: PixelCluster_v1.cxx:15
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
xAOD::DetectorIDHashType
unsigned int DetectorIDHashType
@ detector ID element hash
Definition: MeasurementDefs.h:43
xAOD::PixelCluster_v1::totalToT
int totalToT() const
Returns the sum of the ToTs of the channels building the cluster.
FPGAOutputValidationAlg::m_pixelid
const PixelID * m_pixelid
Definition: FPGAOutputValidationAlg.h:51
SCT_ID::layer_disk
int layer_disk(const Identifier &id) const
Definition: SCT_ID.h:734
DeMoScan.index
string index
Definition: DeMoScan.py:362
xAOD::PixelCluster_v1
Definition: PixelCluster_v1.h:17
RunTileMonitoring.clusters
clusters
Definition: RunTileMonitoring.py:133
xAOD::StripCluster_v1::globalPosition
ConstVectorMap< 3 > globalPosition() const
Returns the global position of the strip cluster.
Definition: StripCluster_v1.cxx:15
FPGAOutputValidationAlg::m_monitoringTool
ToolHandle< GenericMonitoringTool > m_monitoringTool
Definition: FPGAOutputValidationAlg.h:46
Monitored::Scalar
Declare a monitored scalar variable.
Definition: MonitoredScalar.h:34
xAOD::PixelCluster_v1::channelsInEta
int channelsInEta() const
TSU::T
unsigned long long T
Definition: L1TopoDataTypes.h:35
xAOD::PixelCluster_v1::channelsInPhi
int channelsInPhi() const
Returns the dimensions of the cluster in numbers of channels in phi (x) and eta (y) directions,...
xAOD::UncalibMeasType::PixelClusterType
@ PixelClusterType
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
module_driven_slicing.key1
key1
Definition: module_driven_slicing.py:157
Generated on Mon Sep 29 2025 21:10:28 for ATLAS Offline Software by   doxygen 1.8.18