ATLAS Offline Software
Loading...
Searching...
No Matches
ActsClusterComparisonAlg.cxx
Go to the documentation of this file.
1
2/*
3 Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
4*/
5
6#include <cstdint>
7#include <fstream>
8#include <stdexcept>
9
10#include "ActsClusterComparisonAlg.h"
11
12#include "AthAllocators/DataPool.h"
13#include "AthenaBaseComps/AthMsgStreamMacros.h"
14#include "InDetReadoutGeometry/SiDetectorDesign.h"
15#include "InDetReadoutGeometry/SiDetectorElement.h"
16#include "PixelReadoutGeometry/PixelModuleDesign.h"
17#include "ReadoutGeometryBase/SiCellId.h"
18#include "SCT_ReadoutGeometry/SCT_BarrelModuleSideDesign.h"
19#include "SCT_ReadoutGeometry/SCT_ForwardModuleSideDesign.h"
20#include "SCT_ReadoutGeometry/SCT_ModuleSideDesign.h"
21#include "SCT_ReadoutGeometry/StripStereoAnnulusDesign.h"
22#include "StoreGate/ReadHandle.h"
23#include "xAODInDetMeasurement/PixelClusterAuxContainer.h"
24#include "xAODInDetMeasurement/SpacePoint.h"
25#include "xAODInDetMeasurement/SpacePointAuxContainer.h"
26#include "xAODInDetMeasurement/StripClusterAuxContainer.h"
27#include "xAODMeasurementBase/MeasurementDefs.h"
28#include "xAODMeasurementBase/UncalibratedMeasurementContainer.h"
29
30
31namespace ActsTrk {
32
33StatusCode ActsClusterComparisonAlg::initialize()
34{
35 ATH_MSG_INFO("ActsClusterComparisonAlg::initialize");
36
37 ATH_CHECK(detStore()->retrieve(m_pixelManager, m_pixelManagerKey));
38 ATH_CHECK(detStore()->retrieve(m_stripManager, m_stripManagerKey));
39
40 ATH_CHECK(detStore()->retrieve(m_stripID, "SCT_ID"));
41
42 ATH_CHECK(m_lorentzAngleTool.retrieve());
43 ATH_CHECK(m_pixelLorentzAngleTool.retrieve());
44
45 ATH_CHECK(m_monitoredPixelClustersKey.initialize());
46 ATH_CHECK(m_monitoredStripClustersKey.initialize());
47
48 ATH_CHECK(m_referencePixelClustersKey.initialize());
49 ATH_CHECK(m_referenceStripClustersKey.initialize());
50
51 ATH_CHECK(m_referenceSpacepointsKey.initialize(m_checkSpacepoints));
52 ATH_CHECK(m_monitoredSpacepointsKey.initialize(m_checkSpacepoints));
53
54 ATH_MSG_INFO("ActsClusterComparisonAlg::initialize complete");
55 return StatusCode::SUCCESS;
56}
57
58StatusCode ActsClusterComparisonAlg::execute(const EventContext& ctx) const
59{
60
61
62 // Create per-event data structures
63 std::unordered_map<const xAOD::PixelCluster*, const xAOD::PixelCluster*>
64 pixel_cluster_matches;
65
66 std::unordered_map<const xAOD::StripCluster*, const xAOD::StripCluster*>
67 strip_cluster_matches;
68
69
70 ATH_CHECK(validateClusters(ctx, pixel_cluster_matches, strip_cluster_matches));
71
72 if (m_checkSpacepoints)
73 ATH_CHECK(validatePixelSpacepoints(ctx, pixel_cluster_matches));
74
75 return StatusCode::SUCCESS;
76}
77
78// Match pixel clusters
79void matchPixelClusters(
80 std::vector<const xAOD::PixelCluster*>& monitored_list,
81 std::vector<const xAOD::PixelCluster*>& reference_list,
82 const std::string& module_id,
83 std::vector<
84 std::pair<const xAOD::PixelCluster*, const xAOD::PixelCluster*>>& pairs)
85{
86
87 // Extract RDO sets
88 std::vector<std::set<Identifier>> monitored_rdo_sets;
89 std::vector<std::set<Identifier>> reference_rdo_sets;
90
91 for (const auto* c : monitored_list) {
92 const auto& rdoListRange = c->rdoList();
93 std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
94 monitored_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
95 }
96
97 for (const auto* c : reference_list) {
98 const auto& rdoListRange = c->rdoList();
99 std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
100 reference_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
101 }
102
103 // Match clusters
104 std::vector<std::pair<int, int>> matched_pairs;
105 std::vector<int> unmatched_monitored;
106 std::set<int> unmatched_reference;
107
108 for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
109 unmatched_reference.insert(j);
110 }
111
112 for (size_t i = 0; i < monitored_rdo_sets.size(); ++i) {
113
114 bool found_match = false;
115 for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
116 if (monitored_rdo_sets[i] == reference_rdo_sets[j]) {
117 matched_pairs.emplace_back(i, j);
118 pairs.emplace_back(monitored_list.at(i), reference_list.at(j));
119 found_match = true;
120 unmatched_reference.erase(j);
121 break;
122 }
123 }
124 if (!found_match) {
125 unmatched_monitored.push_back(i);
126 }
127 }
128
129 // Report mismatches
130 if (!unmatched_monitored.empty() || !unmatched_reference.empty()) {
131 std::cout << "\n[ERROR] Module " << module_id
132 << ": cluster mismatch detected!" << std::endl;
133 if (!unmatched_monitored.empty()) {
134 std::cout << " Unmatched monitored clusters ("
135 << unmatched_monitored.size() << "):" << std::endl;
136 for (int i : unmatched_monitored) {
137 std::cout << " - #" << i << std::endl;
138 }
139 }
140 if (!unmatched_reference.empty()) {
141 std::cout << " Unmatched reference clusters (" << unmatched_reference.size()
142 << "):" << std::endl;
143 for (int j : unmatched_reference) {
144 std::cout << " - #" << j << std::endl;
145 }
146 }
147 std::cout
148 << "------------------------------------------------------------"
149 << std::endl;
150 }
151}
152
153// Match strip clusters
154void matchStripClusters(
155 std::vector<const xAOD::StripCluster*>& monitored_list,
156 std::vector<const xAOD::StripCluster*>& reference_list,
157 const std::string& module_id,
158 std::vector<
159 std::pair<const xAOD::StripCluster*, const xAOD::StripCluster*>>& pairs)
160{
161
162 // Extract RDO sets
163 std::vector<std::set<Identifier>> monitored_rdo_sets;
164 std::vector<std::set<Identifier>> reference_rdo_sets;
165
166 for (const auto* c : monitored_list) {
167 const auto& rdoListRange = c->rdoList();
168 std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
169 monitored_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
170 }
171
172 for (const auto* c : reference_list) {
173 const auto& rdoListRange = c->rdoList();
174 std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
175 reference_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
176 }
177
178 // Match clusters
179 std::vector<std::pair<int, int>> matched_pairs;
180 std::vector<int> unmatched_monitored;
181 std::set<int> unmatched_reference;
182
183 for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
184 unmatched_reference.insert(j);
185 }
186
187 for (size_t i = 0; i < monitored_rdo_sets.size(); ++i) {
188 bool found_match = false;
189 for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
190 if (monitored_rdo_sets[i] == reference_rdo_sets[j]) {
191 matched_pairs.emplace_back(i, j);
192 pairs.emplace_back(monitored_list.at(i), reference_list.at(j));
193 found_match = true;
194 unmatched_reference.erase(j);
195 break;
196 }
197 }
198 if (!found_match) {
199 unmatched_monitored.push_back(i);
200 }
201 }
202
203 // Report mismatches
204 if (!unmatched_monitored.empty() || !unmatched_reference.empty()) {
205 std::cout << "\n[ERROR] Module " << module_id
206 << ": cluster mismatch detected!" << std::endl;
207 if (!unmatched_monitored.empty()) {
208 std::cout << " Unmatched monitored clusters ("
209 << unmatched_monitored.size() << "):" << std::endl;
210 for (int i : unmatched_monitored) {
211 std::cout << " - #" << i << std::endl;
212 }
213 }
214 if (!unmatched_reference.empty()) {
215 std::cout << " Unmatched reference clusters (" << unmatched_reference.size()
216 << "):" << std::endl;
217 for (int j : unmatched_reference) {
218 std::cout << " - #" << j << std::endl;
219 }
220 }
221 std::cout
222 << "------------------------------------------------------------"
223 << std::endl;
224 }
225}
226
227StatusCode ActsClusterComparisonAlg::validateClusters(
228 const EventContext& eventContext, std::unordered_map<const xAOD::PixelCluster*, const xAOD::PixelCluster*>& pixel_cluster_matches, std::unordered_map<const xAOD::StripCluster*, const xAOD::StripCluster*>& strip_cluster_matches) const
229{
230
231 ATH_MSG_DEBUG(
232 "============================================================");
233 // retrieve the clusters in form of xAOD containers
234 ATH_MSG_INFO("Reading monitored clusters: " << m_monitoredPixelClustersKey.key()
235 << " and "
236 << m_monitoredStripClustersKey.key());
237 ATH_MSG_INFO("Reading reference clusters: " << m_referencePixelClustersKey.key()
238 << " and "
239 << m_referenceStripClustersKey.key());
240 ATH_MSG_DEBUG(
241 "============================================================");
242
243 SG::ReadHandle<xAOD::PixelClusterContainer> monitoredPixelClustersHandle =
244 SG::makeHandle(m_monitoredPixelClustersKey, eventContext);
245 ATH_CHECK(monitoredPixelClustersHandle.isValid());
246 const xAOD::PixelClusterContainer* monitoredPixelClusters =
247 monitoredPixelClustersHandle.cptr();
248
249 SG::ReadHandle<xAOD::StripClusterContainer> monitoredStripClustersHandle =
250 SG::makeHandle(m_monitoredStripClustersKey, eventContext);
251 ATH_CHECK(monitoredStripClustersHandle.isValid());
252 const xAOD::StripClusterContainer* monitoredStripClusters =
253 monitoredStripClustersHandle.cptr();
254
255 SG::ReadHandle<xAOD::PixelClusterContainer> referencePixelClustersHandle =
256 SG::makeHandle(m_referencePixelClustersKey, eventContext);
257 ATH_CHECK(referencePixelClustersHandle.isValid());
258 const xAOD::PixelClusterContainer* referencePixelClusters =
259 referencePixelClustersHandle.cptr();
260
261 SG::ReadHandle<xAOD::StripClusterContainer> referenceStripClustersHandle =
262 SG::makeHandle(m_referenceStripClustersKey, eventContext);
263 ATH_CHECK(referenceStripClustersHandle.isValid());
264 const xAOD::StripClusterContainer* referenceStripClusters =
265 referenceStripClustersHandle.cptr();
266
267 size_t t_n_pixel = monitoredPixelClusters->size();
268 size_t t_n_strip = monitoredStripClusters->size();
269 size_t a_n_pixel = referencePixelClusters->size();
270 size_t a_n_strip = referenceStripClusters->size();
271
272 ATH_MSG_DEBUG(" Monitored/reference pixel clusters " << t_n_pixel << " / "
273 << a_n_pixel);
274 ATH_MSG_DEBUG(" Monitored/reference strip clusters " << t_n_strip << " / "
275 << a_n_strip);
276
277 if (t_n_pixel != a_n_pixel) {
278 ATH_MSG_DEBUG("[ERROR] mismatched pixel cluster numbers found!");
279 ATH_MSG_DEBUG(" Monitored/reference clusters " << t_n_pixel << " / "
280 << a_n_pixel);
281 }
282 if (t_n_strip != a_n_strip) {
283 ATH_MSG_DEBUG("[ERROR] mismatched strip cluster numbers found!");
284 ATH_MSG_DEBUG(" Monitored/reference clusters " << t_n_strip << " / "
285 << a_n_strip);
286 }
287
288 // Group by module
289 std::map<std::string, std::vector<const xAOD::PixelCluster*>>
290 monitored_pixel_map, reference_pixel_map;
291 std::map<std::string, std::vector<const xAOD::StripCluster*>>
292 monitored_strip_map, reference_strip_map;
293
294 for (const auto* c : *monitoredPixelClusters) {
295 monitored_pixel_map[std::to_string(c->identifierHash())].push_back(c);
296 }
297 for (const auto* c : *monitoredStripClusters) {
298 monitored_strip_map[std::to_string(c->identifierHash())].push_back(c);
299 }
300 for (const auto* c : *referencePixelClusters) {
301 reference_pixel_map[std::to_string(c->identifierHash())].push_back(c);
302 }
303 for (const auto* c : *referenceStripClusters) {
304 reference_strip_map[std::to_string(c->identifierHash())].push_back(c);
305 }
306
307 // Collect all module IDs
308 std::set<std::string> pixel_modules, strip_modules;
309 for (const auto& [key, _] : monitored_pixel_map)
310 pixel_modules.insert(key);
311 for (const auto& [key, _] : reference_pixel_map)
312 pixel_modules.insert(key);
313 for (const auto& [key, _] : monitored_strip_map)
314 strip_modules.insert(key);
315 for (const auto& [key, _] : reference_strip_map)
316 strip_modules.insert(key);
317
318 int pixel_unequal = 0, strip_unequal = 0;
319 int matched_pixel = 0, matched_strip = 0;
320 int pixel_pos_diff_0p5sig = 0;
321 int pixel_pos_diff_0p25sig = 0;
322 int pixel_pos_diff_1sig = 0;
323 int strip_pos_diff_0p5sig = 0;
324 int strip_pos_diff_0p25sig = 0;
325 int strip_pos_diff_1sig = 0;
326
327 ATH_MSG_DEBUG("Pixel/Strip modules " << pixel_modules.size() << " / "
328 << strip_modules.size());
329 ATH_MSG_DEBUG("Pixel cluster validation: ");
330 ATH_MSG_DEBUG(
331 "============================================================");
332
333 // Process pixel modules
334 for (const auto& hid : pixel_modules) {
335 auto& tpixel = monitored_pixel_map[hid];
336 auto& apixel = reference_pixel_map[hid];
337
338 if (tpixel.empty() && apixel.empty())
339 continue;
340
341 if (tpixel.size() != apixel.size()) {
342 std::cout << "\n[ERROR] Pixel Module " << hid
343 << ": mismatched clusters found!" << std::endl;
344 std::cout << " Reference found " << apixel.size()
345 << " and monitored found " << tpixel.size() << " clusters!"
346 << std::endl;
347 pixel_unequal++;
348 continue;
349 }
350
351 std::vector<
352 std::pair<const xAOD::PixelCluster*, const xAOD::PixelCluster*>>
353 pixel_pairs;
354 matchPixelClusters(tpixel, apixel, hid, pixel_pairs);
355
356 matched_pixel += pixel_pairs.size();
357
358 // Add matched pairs and check position differences
359 for (const auto& pair : pixel_pairs) {
360 const xAOD::PixelCluster* monitored_cluster = pair.first;
361 const xAOD::PixelCluster* reference_cluster = pair.second;
362
363 (pixel_cluster_matches)[pair.first] = pair.second;
364
365 // Calculate local position difference
366 double l_dx = monitored_cluster->localPosition<2>()[Trk::locX] -
367 reference_cluster->localPosition<2>()[Trk::locX];
368 double l_dy = monitored_cluster->localPosition<2>()[Trk::locY] -
369 reference_cluster->localPosition<2>()[Trk::locY];
370 double l_pos_diff = std::sqrt(l_dx * l_dx + l_dy * l_dy);
371
372 // Calculate global position difference
373 float g_dx = (monitored_cluster->globalPosition()).x() -
374 (reference_cluster->globalPosition()).x();
375 float g_dy = (monitored_cluster->globalPosition()).y() -
376 (reference_cluster->globalPosition()).y();
377 float g_dz = (monitored_cluster->globalPosition()).z() -
378 (reference_cluster->globalPosition()).z();
379 float g_pos_diff =
380 std::sqrt(g_dx * g_dx + g_dy * g_dy + g_dz * g_dz);
381
382 // Calculate error difference
383 Eigen::Matrix<float, 2, 2> monitored_cov =
384 monitored_cluster->localCovariance<2>();
385 Eigen::Matrix<float, 2, 2> reference_cov =
386 reference_cluster->localCovariance<2>();
387
388 const InDetDD::SiDetectorElement* monitored_element =
389 m_pixelManager->getDetectorElement(
390 monitored_cluster->identifierHash());
391 const InDetDD::PixelModuleDesign& design =
392 static_cast<const InDetDD::PixelModuleDesign&>(
393 monitored_element->design());
394
395 if (std::abs(l_dx / (std::sqrt(monitored_cov(0, 0)))) > 0.25 ||
396 std::abs(l_dy / (std::sqrt(monitored_cov(1, 1)))) > 0.25) {
397 pixel_pos_diff_0p25sig++;
398
399 const Identifier monitored_Pixel_ModuleID =
400 monitored_element->identify();
401 double monitored_lorentz_shift =
402 m_pixelLorentzAngleTool->getLorentzShift(
403 monitored_element->identifyHash(), eventContext);
404
405
406
407 ATH_MSG_DEBUG("Detailed print of cluster discrepancy: ");
408 ATH_MSG_DEBUG("On module: " << monitored_Pixel_ModuleID);
409 ATH_MSG_DEBUG("Lorentz shift: " << std::fixed << std::setprecision(9) << monitored_lorentz_shift);
410
411 ATH_MSG_DEBUG("Local position: ");
412 ATH_MSG_DEBUG(
413 " Monitored: ("
414 << monitored_cluster->localPosition<2>()[Trk::locX] << ", "
415 << monitored_cluster->localPosition<2>()[Trk::locY] << ")");
416 ATH_MSG_DEBUG(" Reference: ("
417 << reference_cluster->localPosition<2>()[Trk::locX] << ", "
418 << reference_cluster->localPosition<2>()[Trk::locY]
419 << ")");
420 ATH_MSG_DEBUG(" Δx = " << l_dx << ", Δy = " << l_dy
421 << ", Δr = " << l_pos_diff);
422 ATH_MSG_DEBUG("Cluster cov: ");
423 ATH_MSG_DEBUG(" Monitored: (" << monitored_cov(0, 0) << ", "
424 << monitored_cov(1, 1) << ")");
425 ATH_MSG_DEBUG(" Reference: (" << reference_cov(0, 0) << ", "
426 << reference_cov(1, 1) << ")");
427 ATH_MSG_DEBUG(" Δx = " << monitored_cov(0, 0) - reference_cov(0, 0)
428 << ", Δy = "
429 << monitored_cov(1, 1) - reference_cov(1, 1));
430
431
432 const auto& rdoListRange = monitored_cluster->rdoList();
433 std::vector<Identifier> monitored_rdoList(
434 rdoListRange.begin(), rdoListRange.end());
435 for (auto rdoIter : monitored_rdoList) {
436 const InDetDD::SiCellId& chargeCellId =
437 monitored_element->cellIdFromIdentifier(rdoIter);
438 std::array<InDetDD::PixelDiodeTree::CellIndexType, 2>
439 diode_idx = InDetDD::PixelDiodeTree::makeCellIndex(
440 chargeCellId.phiIndex(), chargeCellId.etaIndex());
441
442 InDetDD::PixelDiodeTree::DiodeProxyWithPosition si_param(
443 design.diodeProxyFromIdxCachePosition(diode_idx));
444 ATH_MSG_DEBUG("hit id for this cell: "
445 << chargeCellId
446 << ", position: " << si_param.position()[0]
447 << ", " << si_param.position()[1]);
448 }
449
450 // Calculate width difference
451 ATH_MSG_DEBUG("Cluster width: ");
452 ATH_MSG_DEBUG(" Monitored phi/eta channels, eta width: ("
453 << monitored_cluster->channelsInPhi() << ", "
454 << monitored_cluster->channelsInEta() << ", "
455 << monitored_cluster->widthInEta() << ")");
456 ATH_MSG_DEBUG(" Reference phi/eta channels, eta width: ("
457 << reference_cluster->channelsInPhi() << ", "
458 << reference_cluster->channelsInEta() << ", "
459 << reference_cluster->widthInEta() << ")");
460
461 ATH_MSG_DEBUG(" Δphi = " << monitored_cluster->channelsInPhi() -
462 reference_cluster->channelsInPhi()
463 << ", Δeta = "
464 << monitored_cluster->channelsInEta() -
465 reference_cluster->channelsInEta()
466 << ", Δwidth = "
467 << monitored_cluster->widthInEta() -
468 reference_cluster->widthInEta());
469 }
470 if (std::abs(l_dx / (std::sqrt(monitored_cov(0, 0)))) > 0.5 ||
471 std::abs(l_dy / (std::sqrt(monitored_cov(1, 1)))) > 0.5) {
472 pixel_pos_diff_0p5sig++;
473 }
474 if (std::abs(l_dx / (std::sqrt(monitored_cov(0, 0)))) > 1 ||
475 std::abs(l_dy / (std::sqrt(monitored_cov(1, 1)))) > 1) {
476 pixel_pos_diff_1sig++;
477 }
478
479
480 ATH_MSG_VERBOSE("Global position: ");
481 ATH_MSG_VERBOSE(" Monitored: ("
482 << (monitored_cluster->globalPosition()).x() << ", "
483 << (monitored_cluster->globalPosition()).y() << ", "
484 << (monitored_cluster->globalPosition()).z() << ")");
485 ATH_MSG_VERBOSE(" Reference: ("
486 << (reference_cluster->globalPosition()).x() << ", "
487 << (reference_cluster->globalPosition()).y() << ", "
488 << (reference_cluster->globalPosition()).z() << ")");
489 ATH_MSG_VERBOSE(" Δx = " << g_dx << ", Δy = " << g_dy << ", Δz = "
490 << g_dz << ", Δr = " << g_pos_diff);
491
492 }
493 }
494
495 ATH_MSG_DEBUG(
496 "============================================================");
497 ATH_MSG_DEBUG("Strip cluster validation: ");
498 ATH_MSG_DEBUG(
499 "============================================================");
500 // Process strip modules
501 for (const auto& hid : strip_modules) {
502 auto& tstrip = monitored_strip_map[hid];
503 auto& astrip = reference_strip_map[hid];
504
505 if (tstrip.empty() && astrip.empty())
506 continue;
507
508 if (tstrip.size() != astrip.size()) {
509 ATH_MSG_DEBUG("\n[ERROR] Strip Module "
510 << hid << ": mismatched clusters found!");
511 ATH_MSG_DEBUG(" Reference found " << astrip.size()
512 << " and monitored found "
513 << tstrip.size() << " clusters!");
514 strip_unequal++;
515 continue;
516 }
517
518 std::vector<
519 std::pair<const xAOD::StripCluster*, const xAOD::StripCluster*>>
520 strip_pairs;
521 matchStripClusters(tstrip, astrip, hid, strip_pairs);
522
523 matched_strip += strip_pairs.size();
524
525 // Add matched pairs and check position differences
526 for (const auto& pair : strip_pairs) {
527 const xAOD::StripCluster* monitored_cluster = pair.first;
528 const xAOD::StripCluster* reference_cluster = pair.second;
529
530 (strip_cluster_matches)[pair.first] = pair.second;
531
532 // Calculate position difference
533 double pos_diff = monitored_cluster->localPosition<1>()[Trk::locX] -
534 reference_cluster->localPosition<1>()[Trk::locX];
535
536
537 // Calculate error difference
538 Eigen::Matrix<float, 1, 1> monitored_cov =
539 monitored_cluster->localCovariance<1>();
540 Eigen::Matrix<float, 1, 1> reference_cov =
541 reference_cluster->localCovariance<1>();
542
543 const InDetDD::SiDetectorElement* monitored_element =
544 m_stripManager->getDetectorElement(monitored_cluster->identifierHash());
545
546
547 if (std::abs(pos_diff / (std::sqrt(monitored_cov(0, 0)))) > 0.25) {
548 strip_pos_diff_0p25sig++;
549
550 int side = m_stripID->side(monitored_element->identify());
551 const Identifier strip_moduleID = m_stripID->module_id(monitored_element->identify());
552 const IdentifierHash Strip_ModuleHash = m_stripID->wafer_hash(strip_moduleID);
553 double monitored_lorentz_shift =
554 m_lorentzAngleTool->getLorentzShift(Strip_ModuleHash + side, eventContext);
555
556 ATH_MSG_DEBUG("Detailed print of cluster discrepancy: ");
557 ATH_MSG_DEBUG("On module: " << strip_moduleID << ", side: " << m_stripID->side(monitored_element->identify()));
558 ATH_MSG_DEBUG("Lorentz shift: " << std::fixed << std::setprecision(9) << monitored_lorentz_shift);
559
560 ATH_MSG_DEBUG("Local position: ");
561 ATH_MSG_DEBUG(
562 " Monitored: ("
563 << monitored_cluster->localPosition<1>()[Trk::locX] << ")");
564 ATH_MSG_DEBUG(" Reference: ("
565 << reference_cluster->localPosition<1>()[Trk::locX] << ")");
566 ATH_MSG_DEBUG(" Δx = " << pos_diff );
567 ATH_MSG_DEBUG("Cluster cov: ");
568 ATH_MSG_DEBUG(" Monitored: (" << monitored_cov(0, 0) << ")");
569 ATH_MSG_DEBUG(" Reference: (" << reference_cov(0, 0) << ")");
570 ATH_MSG_DEBUG(" Δx = " << monitored_cov(0, 0) - reference_cov(0, 0));
571
572 const auto& rdoListRange = monitored_cluster->rdoList();
573 std::vector<Identifier> monitored_rdoList(
574 rdoListRange.begin(), rdoListRange.end());
575
576 if (monitored_element->isBarrel()) {
577 const InDetDD::SCT_BarrelModuleSideDesign* s_design = (static_cast<const InDetDD::SCT_BarrelModuleSideDesign*>(&monitored_element->design()));
578
579 for (auto rdoIter : monitored_rdoList) {
580 const InDetDD::SiCellId& chargeCellId =
581 monitored_element->cellIdFromIdentifier(rdoIter);
582 InDetDD::SiLocalPosition si_pos =
583 s_design->localPositionOfCell(chargeCellId);
584 Amg::Vector2D loc_pos(si_pos.xPhi(), si_pos.xEta());
585 ATH_MSG_DEBUG("hit id for this cell: "
586 << chargeCellId
587 << ", position: " << loc_pos[0]
588 << ", " << loc_pos[1]);
589 }
590
591 }else{
592
593 const InDetDD::StripStereoAnnulusDesign* annulus_design = (static_cast<const InDetDD::StripStereoAnnulusDesign*>(&monitored_element->design()));
594
595 for (auto rdoIter : monitored_rdoList) {
596 const InDetDD::SiCellId& chargeCellId =
597 monitored_element->cellIdFromIdentifier(rdoIter);
598
599 InDetDD::SiLocalPosition si_pos =
600 annulus_design->localPositionOfCell(chargeCellId);
601 Amg::Vector2D loc_pos(si_pos.xPhi(), si_pos.xEta());
602 ATH_MSG_DEBUG("hit id for this cell: "
603 << chargeCellId
604 << ", posiiton: " << loc_pos[0]
605 << ", " << loc_pos[1]);
606 }
607
608 }
609
610 // Calculate width difference
611 ATH_MSG_DEBUG("Cluster width: ");
612 ATH_MSG_DEBUG(" Monitored phi channels: ("
613 << monitored_cluster->channelsInPhi() << ")");
614 ATH_MSG_DEBUG(" Reference phi channels: ("
615 << reference_cluster->channelsInPhi() << ")");
616
617 ATH_MSG_DEBUG(" Δphi = " << monitored_cluster->channelsInPhi() -
618 reference_cluster->channelsInPhi());
619
620 }
621 if (std::abs(pos_diff / (std::sqrt(monitored_cov(0, 0)))) > 0.5) {
622 strip_pos_diff_0p5sig++;
623 }
624 if (std::abs(pos_diff / (std::sqrt(monitored_cov(0, 0)))) > 1) {
625 strip_pos_diff_1sig++;
626 }
627
628 }
629 }
630
631 ATH_MSG_DEBUG(
632 "============================================================");
633
634 // Print statistics
635 ATH_MSG_DEBUG(
636 "============================================================");
637 ATH_MSG_DEBUG("PIXEL CLUSTER MATCHING STATISTICS: ");
638 ATH_MSG_DEBUG(" Total matched clusters: " << matched_pixel);
639 ATH_MSG_DEBUG(" Clusters with pos diff > 1 sigma: "
640 << pixel_pos_diff_1sig << " ("
641 << (matched_pixel > 0
642 ? 100.0 * pixel_pos_diff_1sig / matched_pixel
643 : 0.0)
644 << "%)");
645 ATH_MSG_DEBUG(" Clusters with pos diff > 0.5 sigma: "
646 << pixel_pos_diff_0p5sig << " ("
647 << (matched_pixel > 0
648 ? 100.0 * pixel_pos_diff_0p5sig / matched_pixel
649 : 0.0)
650 << "%)");
651 ATH_MSG_DEBUG(" Clusters with pos diff > 0.25 sigma: "
652 << pixel_pos_diff_0p25sig << " ("
653 << (matched_pixel > 0
654 ? 100.0 * pixel_pos_diff_0p25sig / matched_pixel
655 : 0.0)
656 << "%)");
657 ATH_MSG_DEBUG(
658 "============================================================");
659 ATH_MSG_DEBUG(
660 "============================================================");
661 ATH_MSG_DEBUG("STRIP CLUSTER MATCHING STATISTICS:");
662 ATH_MSG_DEBUG(" Total matched clusters: " << matched_strip);
663 ATH_MSG_DEBUG(" Clusters with pos diff > 1 sigma: "
664 << strip_pos_diff_1sig << " ("
665 << (matched_strip > 0
666 ? 100.0 * strip_pos_diff_1sig / matched_strip
667 : 0.0)
668 << "%)");
669 ATH_MSG_DEBUG(" Clusters with pos diff > 0.5 sigma: "
670 << strip_pos_diff_0p5sig << " ("
671 << (matched_strip > 0
672 ? 100.0 * strip_pos_diff_0p5sig / matched_strip
673 : 0.0)
674 << "%)");
675 ATH_MSG_DEBUG(" Clusters with pos diff > 0.25 sigma: "
676 << strip_pos_diff_0p25sig << " ("
677 << (matched_strip > 0
678 ? 100.0 * strip_pos_diff_0p25sig / matched_strip
679 : 0.0)
680 << "%)");
681 ATH_MSG_DEBUG(
682 "============================================================");
683
684 m_pixel_unequal += pixel_unequal;
685 m_strip_unequal += strip_unequal;
686 m_matched_pixel += matched_pixel;
687 m_matched_strip += matched_strip;
688 m_pixel_pos_diff_1sig += pixel_pos_diff_1sig;
689 m_pixel_pos_diff_0p5sig += pixel_pos_diff_0p5sig;
690 m_pixel_pos_diff_0p25sig += pixel_pos_diff_0p25sig;
691 m_strip_pos_diff_1sig += strip_pos_diff_1sig;
692 m_strip_pos_diff_0p5sig += strip_pos_diff_0p5sig;
693 m_strip_pos_diff_0p25sig += strip_pos_diff_0p25sig;
694
695 return StatusCode::SUCCESS;
696}
697
698StatusCode ActsClusterComparisonAlg::validatePixelSpacepoints(
699 const EventContext& eventContext, std::unordered_map<const xAOD::PixelCluster*, const xAOD::PixelCluster*>& pixel_cluster_matches) const
700{
701
702 // retrieve the spacepoints in form of xAOD containers
703 ATH_MSG_INFO(
704 "Reading monitored spacepoints: " << m_monitoredSpacepointsKey.key());
705 ATH_MSG_INFO("Reading reference spacepoints: " << m_referenceSpacepointsKey.key());
706
707 SG::ReadHandle<xAOD::SpacePointContainer> monitoredSpacepointsHandle =
708 SG::makeHandle(m_monitoredSpacepointsKey, eventContext);
709 ATH_CHECK(monitoredSpacepointsHandle.isValid());
710 const xAOD::SpacePointContainer* monitoredSpacepoints =
711 monitoredSpacepointsHandle.cptr();
712
713 SG::ReadHandle<xAOD::SpacePointContainer> referenceSpacepointsHandle =
714 SG::makeHandle(m_referenceSpacepointsKey, eventContext);
715 ATH_CHECK(referenceSpacepointsHandle.isValid());
716 const xAOD::SpacePointContainer* referenceSpacepoints =
717 referenceSpacepointsHandle.cptr();
718
719 size_t t_n_sp = monitoredSpacepoints->size();
720 size_t a_n_sp = referenceSpacepoints->size();
721
722 ATH_MSG_DEBUG(" Monitored/reference spacepoints " << t_n_sp << " / " << a_n_sp);
723
724 if (t_n_sp != a_n_sp) {
725 ATH_MSG_DEBUG("[ERROR] mismatched spacepoint numbers found!");
726 ATH_MSG_DEBUG(" Monitored/reference spacepoints " << t_n_sp << " / "
727 << a_n_sp);
728 }
729
730 // Now match spacepoints based on their constituent clusters
731 int matched_sp = 0;
732 int unmatched_monitored_sp = 0;
733 int unmatched_reference_sp = 0;
734 int sp_global_pos_diff_1mm = 0;
735 int sp_global_pos_diff_5mm = 0;
736 int sp_variance_r_diff = 0;
737 int sp_variance_z_diff = 0;
738
739 std::vector<std::pair<const xAOD::SpacePoint*, const xAOD::SpacePoint*>>
740 sp_matches;
741 std::set<const xAOD::SpacePoint*> matched_reference_sp;
742
743 for (const auto* monitored_sp : *monitoredSpacepoints) {
744
745 const auto& monitored_measurements = monitored_sp->measurements();
746
747 // Find matching ACTS spacepoint by comparing cluster content
748 bool found_match = false;
749 for (const auto* reference_sp : *referenceSpacepoints) {
750
751 const auto& reference_measurements = reference_sp->measurements();
752
753 // Check if measurements sizes match
754 if (monitored_measurements.size() != reference_measurements.size())
755 continue;
756
757 // Check if all clusters match
758 bool all_clusters_match = true;
759 for (size_t i = 0; i < monitored_measurements.size(); ++i) {
760 const xAOD::UncalibratedMeasurement* monitored_meas =
761 monitored_measurements[i];
762 const xAOD::UncalibratedMeasurement* reference_meas =
763 reference_measurements[i];
764
765 // Try pixel cluster matching
766 auto monitored_pixel =
767 dynamic_cast<const xAOD::PixelCluster*>(monitored_meas);
768 auto reference_pixel =
769 dynamic_cast<const xAOD::PixelCluster*>(reference_meas);
770
771 if (monitored_pixel && reference_pixel) {
772 auto it = pixel_cluster_matches.find(monitored_pixel);
773 if (it == pixel_cluster_matches.end() ||
774 it->second != reference_pixel) {
775 all_clusters_match = false;
776 break;
777 }
778 } else {
779 // Only pixel spacepoints are supported for now
780 ATH_MSG_WARNING("Non-pixel measurement in spacepoint comparison — "
781 "strip spacepoints are not yet handled, skipping pair");
782 all_clusters_match = false;
783 break;
784 }
785 }
786
787 if (all_clusters_match) {
788
789 // Found matching spacepoint pair
790 matched_sp++;
791 sp_matches.push_back(std::make_pair(monitored_sp, reference_sp));
792 matched_reference_sp.insert(reference_sp);
793 found_match = true;
794
795 break;
796 }
797 }
798
799 if (!found_match) {
800 unmatched_monitored_sp++;
801 }
802 }
803
804 for (auto& sp_pair : sp_matches) {
805
806 const xAOD::SpacePoint* monitored_sp = sp_pair.first;
807 const xAOD::SpacePoint* reference_sp = sp_pair.second;
808
809 double dx = monitored_sp->x() - reference_sp->x();
810 double dy = monitored_sp->y() - reference_sp->y();
811 double dz = monitored_sp->z() - reference_sp->z();
812 double pos_diff = std::sqrt(dx * dx + dy * dy + dz * dz);
813
814 // Calculate global position difference
815 ATH_MSG_DEBUG("Spacepoint global position: ");
816 ATH_MSG_DEBUG(" Monitored: (" << monitored_sp->x() << ", " << monitored_sp->y()
817 << ", " << monitored_sp->z() << ")");
818 ATH_MSG_DEBUG(" Reference: (" << reference_sp->x() << ", " << reference_sp->y()
819 << ", " << reference_sp->z() << ")");
820 ATH_MSG_DEBUG(" Δx = " << dx << ", Δy = " << dy << ", Δz = " << dz
821 << ", Δr = " << pos_diff);
822
823 if (pos_diff > 1.0)
824 sp_global_pos_diff_1mm++;
825 if (pos_diff > 5.0)
826 sp_global_pos_diff_5mm++;
827
828 // Calculate covariance difference
829 ATH_MSG_DEBUG("Spacepoint cov and radius: ");
830 ATH_MSG_DEBUG(" Monitored r/z and radius: ("
831 << monitored_sp->varianceR() << ", "
832 << monitored_sp->varianceZ() << ", " << monitored_sp->radius()
833 << ")");
834 ATH_MSG_DEBUG(" Reference r/z and radius: (" << reference_sp->varianceR() << ", "
835 << reference_sp->varianceZ() << ", "
836 << reference_sp->radius() << ")");
837 ATH_MSG_DEBUG(" Δcov_r = "
838 << monitored_sp->varianceR() - reference_sp->varianceR()
839 << ", Δcov_z = "
840 << monitored_sp->varianceZ() - reference_sp->varianceZ()
841 << ", Δradius = "
842 << monitored_sp->radius() - reference_sp->radius());
843
844 if (reference_sp->varianceR() > 0 &&
845 std::abs(monitored_sp->varianceR() - reference_sp->varianceR()) /
846 reference_sp->varianceR() > 0.1)
847 sp_variance_r_diff++;
848 if (reference_sp->varianceZ() > 0 &&
849 std::abs(monitored_sp->varianceZ() - reference_sp->varianceZ()) /
850 reference_sp->varianceZ() > 0.1)
851 sp_variance_z_diff++;
852
853 }
854
855 unmatched_reference_sp = referenceSpacepoints->size() - matched_reference_sp.size();
856
857 // Print statistics
858 ATH_MSG_INFO(
859 "============================================================");
860 ATH_MSG_INFO("SPACEPOINT MATCHING STATISTICS:");
861 ATH_MSG_INFO(" Total monitored spacepoints: " << t_n_sp);
862 ATH_MSG_INFO(" Total reference spacepoints: " << a_n_sp);
863 ATH_MSG_INFO(" Matched spacepoints: " << matched_sp);
864 ATH_MSG_INFO(" Unmatched monitored spacepoints: " << unmatched_monitored_sp);
865 ATH_MSG_INFO(" Unmatched reference spacepoints: " << unmatched_reference_sp);
866 ATH_MSG_INFO(
867 "============================================================");
868 ATH_MSG_INFO("SPACEPOINT POSITION COMPARISON:");
869 ATH_MSG_INFO(
870 " Spacepoints with global pos diff > 1 mm: "
871 << sp_global_pos_diff_1mm << " ("
872 << (matched_sp > 0 ? 100.0 * sp_global_pos_diff_1mm / matched_sp : 0.0)
873 << "%)");
874 ATH_MSG_INFO(
875 " Spacepoints with global pos diff > 5 mm: "
876 << sp_global_pos_diff_5mm << " ("
877 << (matched_sp > 0 ? 100.0 * sp_global_pos_diff_5mm / matched_sp : 0.0)
878 << "%)");
879 ATH_MSG_INFO(
880 "============================================================");
881 ATH_MSG_INFO("SPACEPOINT VARIANCE COMPARISON:");
882 ATH_MSG_INFO(
883 " Spacepoints with >10% variance R difference: "
884 << sp_variance_r_diff << " ("
885 << (matched_sp > 0 ? 100.0 * sp_variance_r_diff / matched_sp : 0.0)
886 << "%)");
887 ATH_MSG_INFO(
888 " Spacepoints with >10% variance Z difference: "
889 << sp_variance_z_diff << " ("
890 << (matched_sp > 0 ? 100.0 * sp_variance_z_diff / matched_sp : 0.0)
891 << "%)");
892 ATH_MSG_INFO(
893 "============================================================");
894
895
896 m_nMonSp += t_n_sp;
897 m_nRefSp += a_n_sp;
898 m_nMatchedSp += matched_sp;
899 m_nUnmatchedMonSp += unmatched_monitored_sp;
900 m_nUnmatchedRefSp += unmatched_reference_sp;
901 m_nSpPosDiff1mm += sp_global_pos_diff_1mm;
902 m_nSpPosDiff5mm += sp_global_pos_diff_5mm;
903 m_nSpVarRDiff += sp_variance_r_diff;
904 m_nSpVarZDiff += sp_variance_z_diff;
905
906 return StatusCode::SUCCESS;
907}
908
909StatusCode ActsClusterComparisonAlg::finalize()
910{
911
912 ATH_MSG_INFO("Validation summary: ");
913
914 // Print cluster statistics
915 ATH_MSG_INFO(
916 "============================================================");
917 ATH_MSG_INFO("PIXEL CLUSTER MATCHING STATISTICS: ");
918 ATH_MSG_INFO(" Total matched clusters: " << m_matched_pixel);
919 ATH_MSG_INFO(" Clusters with pos diff > 1 sigma: "
920 << m_pixel_pos_diff_1sig << " ("
921 << (m_matched_pixel.value() > 0
922 ? 100.0 * m_pixel_pos_diff_1sig.value() / m_matched_pixel.value()
923 : 0.0)
924 << "%)");
925 ATH_MSG_INFO(" Clusters with pos diff > 0.5 sigma: "
926 << m_pixel_pos_diff_0p5sig << " ("
927 << (m_matched_pixel.value() > 0
928 ? 100.0 * m_pixel_pos_diff_0p5sig.value() / m_matched_pixel.value()
929 : 0.0)
930 << "%)");
931 ATH_MSG_INFO(" Clusters with pos diff > 0.25 sigma: "
932 << m_pixel_pos_diff_0p25sig << " ("
933 << (m_matched_pixel.value() > 0
934 ? 100.0 * m_pixel_pos_diff_0p25sig.value() / m_matched_pixel.value()
935 : 0.0)
936 << "%)");
937 ATH_MSG_INFO(
938 "============================================================");
939 ATH_MSG_INFO(
940 "============================================================");
941 ATH_MSG_INFO("STRIP CLUSTER MATCHING STATISTICS:");
942 ATH_MSG_INFO(" Total matched clusters: " << m_matched_strip);
943 ATH_MSG_INFO(" Clusters with pos diff > 1 sigma: "
944 << m_strip_pos_diff_1sig << " ("
945 << (m_matched_strip.value() > 0
946 ? 100.0 * m_strip_pos_diff_1sig.value() / m_matched_strip.value()
947 : 0.0)
948 << "%)");
949 ATH_MSG_INFO(" Clusters with pos diff > 0.5 sigma: "
950 << m_strip_pos_diff_0p5sig << " ("
951 << (m_matched_strip.value() > 0
952 ? 100.0 * m_strip_pos_diff_0p5sig.value() / m_matched_strip.value()
953 : 0.0)
954 << "%)");
955 ATH_MSG_INFO(" Clusters with pos diff > 0.25 sigma: "
956 << m_strip_pos_diff_0p25sig << " ("
957 << (m_matched_strip.value() > 0
958 ? 100.0 * m_strip_pos_diff_0p25sig.value() / m_matched_strip.value()
959 : 0.0)
960 << "%)");
961 ATH_MSG_INFO(
962 "============================================================");
963
964 if(m_checkSpacepoints){
965 ATH_MSG_INFO("============================================================");
966 ATH_MSG_INFO("PIXEL SPACEPOINT MATCHING STATISTICS:");
967 ATH_MSG_INFO(" Total monitored spacepoints: " << m_nMonSp);
968 ATH_MSG_INFO(" Total reference spacepoints: " << m_nRefSp);
969 ATH_MSG_INFO(" Matched spacepoints: " << m_nMatchedSp);
970 ATH_MSG_INFO(" Unmatched monitored spacepoints: " << m_nUnmatchedMonSp);
971 ATH_MSG_INFO(" Unmatched reference spacepoints: " << m_nUnmatchedRefSp);
972 ATH_MSG_INFO("============================================================");
973 ATH_MSG_INFO("SPACEPOINT POSITION COMPARISON:");
974 ATH_MSG_INFO(" Spacepoints with global pos diff > 1 mm: "
975 << m_nSpPosDiff1mm << " ("
976 << (m_nMatchedSp.value() > 0 ? 100.0 * m_nSpPosDiff1mm.value() / m_nMatchedSp.value() : 0.0)
977 << "%)");
978 ATH_MSG_INFO(" Spacepoints with global pos diff > 5 mm: "
979 << m_nSpPosDiff5mm << " ("
980 << (m_nMatchedSp.value() > 0 ? 100.0 * m_nSpPosDiff5mm.value() / m_nMatchedSp.value() : 0.0)
981 << "%)");
982 ATH_MSG_INFO("============================================================");
983 ATH_MSG_INFO("SPACEPOINT VARIANCE COMPARISON:");
984 ATH_MSG_INFO(" Spacepoints with >10% variance R difference: "
985 << m_nSpVarRDiff << " ("
986 << (m_nMatchedSp.value() > 0 ? 100.0 * m_nSpVarRDiff.value() / m_nMatchedSp.value() : 0.0)
987 << "%)");
988 ATH_MSG_INFO(" Spacepoints with >10% variance Z difference: "
989 << m_nSpVarZDiff << " ("
990 << (m_nMatchedSp.value() > 0 ? 100.0 * m_nSpVarZDiff.value() / m_nMatchedSp.value() : 0.0)
991 << "%)");
992 ATH_MSG_INFO("============================================================");
993 }
994
995 return StatusCode::SUCCESS;
996}
997
998} // namespace ActsTrk
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition AthMsgStreamMacros.h:28
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition AthMsgStreamMacros.h:29
SCT_BarrelModuleSideDesign.h
SCT_ForwardModuleSideDesign.h
SCT_ModuleSideDesign.h
ReadHandle.h
Handle class for reading from StoreGate.
ActsTrk::ActsClusterComparisonAlg::m_nMatchedSp
Gaudi::Accumulators::Counter m_nMatchedSp
Definition ActsClusterComparisonAlg.h:116
ActsTrk::ActsClusterComparisonAlg::validateClusters
StatusCode validateClusters(const EventContext &eventContext, std::unordered_map< const xAOD::PixelCluster *, const xAOD::PixelCluster * > &pixel_cluster_matches, std::unordered_map< const xAOD::StripCluster *, const xAOD::StripCluster * > &strip_cluster_matches) const
Definition ActsClusterComparisonAlg.cxx:227
ActsTrk::ActsClusterComparisonAlg::m_referencePixelClustersKey
SG::ReadHandleKey< xAOD::PixelClusterContainer > m_referencePixelClustersKey
Definition ActsClusterComparisonAlg.h:91
ActsTrk::ActsClusterComparisonAlg::m_pixelLorentzAngleTool
ToolHandle< ISiLorentzAngleTool > m_pixelLorentzAngleTool
Definition ActsClusterComparisonAlg.h:134
ActsTrk::ActsClusterComparisonAlg::m_pixel_unequal
Gaudi::Accumulators::Counter m_pixel_unequal
Definition ActsClusterComparisonAlg.h:102
ActsTrk::ActsClusterComparisonAlg::m_lorentzAngleTool
ToolHandle< ISiLorentzAngleTool > m_lorentzAngleTool
Definition ActsClusterComparisonAlg.h:131
ActsTrk::ActsClusterComparisonAlg::m_monitoredSpacepointsKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_monitoredSpacepointsKey
Definition ActsClusterComparisonAlg.h:75
ActsTrk::ActsClusterComparisonAlg::m_referenceStripClustersKey
SG::ReadHandleKey< xAOD::StripClusterContainer > m_referenceStripClustersKey
Definition ActsClusterComparisonAlg.h:95
ActsTrk::ActsClusterComparisonAlg::m_monitoredPixelClustersKey
SG::ReadHandleKey< xAOD::PixelClusterContainer > m_monitoredPixelClustersKey
Definition ActsClusterComparisonAlg.h:83
ActsTrk::ActsClusterComparisonAlg::m_nUnmatchedRefSp
Gaudi::Accumulators::Counter m_nUnmatchedRefSp
Definition ActsClusterComparisonAlg.h:118
ActsTrk::ActsClusterComparisonAlg::m_strip_unequal
Gaudi::Accumulators::Counter m_strip_unequal
Definition ActsClusterComparisonAlg.h:103
ActsTrk::ActsClusterComparisonAlg::m_pixel_pos_diff_0p25sig
Gaudi::Accumulators::Counter m_pixel_pos_diff_0p25sig
Definition ActsClusterComparisonAlg.h:108
ActsTrk::ActsClusterComparisonAlg::m_stripManagerKey
Gaudi::Property< std::string > m_stripManagerKey
Definition ActsClusterComparisonAlg.h:126
ActsTrk::ActsClusterComparisonAlg::m_nSpPosDiff5mm
Gaudi::Accumulators::Counter m_nSpPosDiff5mm
Definition ActsClusterComparisonAlg.h:120
ActsTrk::ActsClusterComparisonAlg::m_strip_pos_diff_0p5sig
Gaudi::Accumulators::Counter m_strip_pos_diff_0p5sig
Definition ActsClusterComparisonAlg.h:110
ActsTrk::ActsClusterComparisonAlg::m_pixelManager
const InDetDD::PixelDetectorManager * m_pixelManager
Definition ActsClusterComparisonAlg.h:128
ActsTrk::ActsClusterComparisonAlg::m_nSpVarRDiff
Gaudi::Accumulators::Counter m_nSpVarRDiff
Definition ActsClusterComparisonAlg.h:121
ActsTrk::ActsClusterComparisonAlg::m_monitoredStripClustersKey
SG::ReadHandleKey< xAOD::StripClusterContainer > m_monitoredStripClustersKey
Definition ActsClusterComparisonAlg.h:87
ActsTrk::ActsClusterComparisonAlg::m_matched_pixel
Gaudi::Accumulators::Counter m_matched_pixel
Definition ActsClusterComparisonAlg.h:104
ActsTrk::ActsClusterComparisonAlg::m_nSpVarZDiff
Gaudi::Accumulators::Counter m_nSpVarZDiff
Definition ActsClusterComparisonAlg.h:122
ActsTrk::ActsClusterComparisonAlg::execute
virtual StatusCode execute(const EventContext &ctx) const override
Execute the algorithm.
Definition ActsClusterComparisonAlg.cxx:58
ActsTrk::ActsClusterComparisonAlg::m_nSpPosDiff1mm
Gaudi::Accumulators::Counter m_nSpPosDiff1mm
Definition ActsClusterComparisonAlg.h:119
ActsTrk::ActsClusterComparisonAlg::m_strip_pos_diff_0p25sig
Gaudi::Accumulators::Counter m_strip_pos_diff_0p25sig
Definition ActsClusterComparisonAlg.h:111
ActsTrk::ActsClusterComparisonAlg::finalize
virtual StatusCode finalize() override
Finalize the algorithm.
Definition ActsClusterComparisonAlg.cxx:909
ActsTrk::ActsClusterComparisonAlg::m_nUnmatchedMonSp
Gaudi::Accumulators::Counter m_nUnmatchedMonSp
Definition ActsClusterComparisonAlg.h:117
ActsTrk::ActsClusterComparisonAlg::m_strip_pos_diff_1sig
Gaudi::Accumulators::Counter m_strip_pos_diff_1sig
Definition ActsClusterComparisonAlg.h:109
ActsTrk::ActsClusterComparisonAlg::m_stripManager
const InDetDD::SCT_DetectorManager * m_stripManager
Definition ActsClusterComparisonAlg.h:129
ActsTrk::ActsClusterComparisonAlg::m_pixel_pos_diff_1sig
Gaudi::Accumulators::Counter m_pixel_pos_diff_1sig
Definition ActsClusterComparisonAlg.h:106
ActsTrk::ActsClusterComparisonAlg::m_matched_strip
Gaudi::Accumulators::Counter m_matched_strip
Definition ActsClusterComparisonAlg.h:105
ActsTrk::ActsClusterComparisonAlg::m_referenceSpacepointsKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_referenceSpacepointsKey
Definition ActsClusterComparisonAlg.h:79
ActsTrk::ActsClusterComparisonAlg::initialize
virtual StatusCode initialize() override
Initialize the algorithm.
Definition ActsClusterComparisonAlg.cxx:33
ActsTrk::ActsClusterComparisonAlg::m_pixelManagerKey
Gaudi::Property< std::string > m_pixelManagerKey
Definition ActsClusterComparisonAlg.h:124
ActsTrk::ActsClusterComparisonAlg::m_pixel_pos_diff_0p5sig
Gaudi::Accumulators::Counter m_pixel_pos_diff_0p5sig
Definition ActsClusterComparisonAlg.h:107
ActsTrk::ActsClusterComparisonAlg::validatePixelSpacepoints
StatusCode validatePixelSpacepoints(const EventContext &eventContext, std::unordered_map< const xAOD::PixelCluster *, const xAOD::PixelCluster * > &pixel_cluster_matches) const
Definition ActsClusterComparisonAlg.cxx:698
AthCommonAlgorithm< Gaudi::Algorithm >::detStore
const ServiceHandle< StoreGateSvc > & detStore() const
Definition AthCommonDataStore.h:95
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
IdentifierHash
This is a "hash" representation of an Identifier.
Definition IdentifierHash.h:25
InDetDD::PixelDiodeTree::makeCellIndex
static constexpr std::array< PixelDiodeTree::CellIndexType, 2 > makeCellIndex(T local_x_idx, T local_y_idx)
Create a 2D cell index from the indices in local-x (phi, row) and local-y (eta, column) direction.
Definition PixelDiodeTree.h:320
InDetDD::PixelModuleDesign
Class used to describe the design of a module (diode segmentation and readout scheme).
Definition PixelModuleDesign.h:45
InDetDD::PixelModuleDesign::diodeProxyFromIdxCachePosition
PixelDiodeTree::DiodeProxyWithPosition diodeProxyFromIdxCachePosition(const std::array< PixelDiodeTree::IndexType, 2 > &idx) const
Definition PixelModuleDesign.h:251
InDetDD::SCT_BarrelModuleSideDesign
Barrel module design description for the SCT.
Definition SCT_BarrelModuleSideDesign.h:34
InDetDD::SCT_BarrelModuleSideDesign::localPositionOfCell
virtual SiLocalPosition localPositionOfCell(const SiCellId &cellId) const
id -> position
Definition SCT_BarrelModuleSideDesign.cxx:183
InDetDD::SiCellId
Identifier for the strip or pixel cell.
Definition SiCellId.h:29
InDetDD::SiCellId::phiIndex
int phiIndex() const
Get phi index. Equivalent to strip().
Definition SiCellId.h:122
InDetDD::SiCellId::etaIndex
int etaIndex() const
Get eta index.
Definition SiCellId.h:114
InDetDD::SiDetectorElement
Class to hold geometrical description of a silicon detector element.
Definition SiDetectorElement.h:109
InDetDD::SiDetectorElement::cellIdFromIdentifier
virtual SiCellId cellIdFromIdentifier(const Identifier &identifier) const override final
SiCellId from Identifier.
Definition SiDetectorElement.cxx:120
InDetDD::SiDetectorElement::design
virtual const SiDetectorDesign & design() const override final
access to the local description (inline):
InDetDD::SiLocalPosition
Class to represent a position in the natural frame of a silicon sensor, for Pixel and SCT For Pixel: ...
Definition SiLocalPosition.h:31
InDetDD::SiLocalPosition::xPhi
double xPhi() const
position along phi direction:
Definition SiLocalPosition.h:123
InDetDD::SiLocalPosition::xEta
double xEta() const
position along eta direction:
Definition SiLocalPosition.h:118
InDetDD::SolidStateDetectorElementBase::identifyHash
virtual IdentifierHash identifyHash() const override final
identifier hash (inline)
InDetDD::SolidStateDetectorElementBase::identify
virtual Identifier identify() const override final
identifier of this detector element (inline)
InDetDD::StripStereoAnnulusDesign::localPositionOfCell
virtual SiLocalPosition localPositionOfCell(const SiCellId &cellId) const override
id -> position
Definition StripStereoAnnulusDesign.cxx:362
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
SG::ReadHandle::cptr
const_pointer_type cptr()
Dereference the pointer.
pair
STL class.
xAOD::PixelCluster_v1::rdoList
SG::ConstAccessor< SG::JaggedVecElt< Identifier::value_type > >::element_type rdoList() const
Returns the list of identifiers of the channels building the cluster.
Definition PixelCluster_v1.h:145
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::PixelCluster_v1::globalPosition
ConstVectorMap< 3 > globalPosition() const
Returns the global position of the pixel cluster.
Definition PixelCluster_v1.cxx:16
xAOD::PixelCluster_v1::channelsInEta
int channelsInEta() const
xAOD::PixelCluster_v1::widthInEta
float widthInEta() const
Returns the width of the cluster in phi (x) and eta (y) directions, respectively.
xAOD::SpacePoint_v1::varianceZ
float varianceZ() const
xAOD::SpacePoint_v1::varianceR
float varianceR() const
Returns the variances.
xAOD::SpacePoint_v1::z
float z() const
xAOD::SpacePoint_v1::y
float y() const
xAOD::SpacePoint_v1::x
float x() const
xAOD::SpacePoint_v1::radius
float radius() const
xAOD::StripCluster_v1::rdoList
SG::ConstAccessor< SG::JaggedVecElt< Identifier::value_type > >::element_type rdoList() const
Returns the list of identifiers of the channels building the cluster.
Definition StripCluster_v1.h:74
xAOD::StripCluster_v1::channelsInPhi
int channelsInPhi() const
Returns the dimensions of the cluster in numbers of channels in phi (x), respectively.
xAOD::UncalibratedMeasurement_v1::localCovariance
ConstMatrixMap< N > localCovariance() const
Returns the local covariance of the measurement.
xAOD::UncalibratedMeasurement_v1::identifierHash
DetectorIDHashType identifierHash() const
Returns the IdentifierHash of the measurement (corresponds to the detector element IdentifierHash).
xAOD::UncalibratedMeasurement_v1::localPosition
ConstVectorMap< N > localPosition() const
Returns the local position of the measurement.
ActsTrk
The AlignStoreProviderAlg loads the rigid alignment corrections and pipes them through the readout ge...
Definition MdtCalibInput.h:31
ActsTrk::matchPixelClusters
void matchPixelClusters(std::vector< const xAOD::PixelCluster * > &monitored_list, std::vector< const xAOD::PixelCluster * > &reference_list, const std::string &module_id, std::vector< std::pair< const xAOD::PixelCluster *, const xAOD::PixelCluster * > > &pairs)
Definition ActsClusterComparisonAlg.cxx:79
ActsTrk::matchStripClusters
void matchStripClusters(std::vector< const xAOD::StripCluster * > &monitored_list, std::vector< const xAOD::StripCluster * > &reference_list, const std::string &module_id, std::vector< std::pair< const xAOD::StripCluster *, const xAOD::StripCluster * > > &pairs)
Definition ActsClusterComparisonAlg.cxx:154
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition GeoPrimitives.h:48
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:269
Trk::locY
@ locY
local cartesian
Definition ParamDefs.h:38
Trk::locX
@ locX
Definition ParamDefs.h:37
xAOD::PixelClusterContainer
PixelClusterContainer_v1 PixelClusterContainer
Define the version of the pixel cluster container.
Definition Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/PixelClusterContainer.h:14
xAOD::StripCluster
StripCluster_v1 StripCluster
Define the version of the strip cluster class.
Definition StripCluster.h:13
xAOD::SpacePointContainer
SpacePointContainer_v1 SpacePointContainer
Define the version of the space point container.
Definition Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/SpacePointContainer.h:14
xAOD::UncalibratedMeasurement
UncalibratedMeasurement_v1 UncalibratedMeasurement
Define the version of the uncalibrated measurement class.
Definition UncalibratedMeasurementFwd.h:13
xAOD::StripClusterContainer
StripClusterContainer_v1 StripClusterContainer
Define the version of the strip cluster container.
Definition StripClusterContainer.h:14
xAOD::PixelCluster
PixelCluster_v1 PixelCluster
Define the version of the pixel cluster class.
Definition Event/xAOD/xAODInDetMeasurement/xAODInDetMeasurement/PixelCluster.h:13
InDetDD::PixelDiodeTree::DiodeProxyWithPosition
A diode proxy which caches the position of a diode.
Definition PixelDiodeTree.h:230
InDetDD::PixelDiodeTree::DiodeProxyWithPosition::position
const Vector2D & position() const
get the cached position of this diode
Definition PixelDiodeTree.h:241
Generated on for ATLAS Offline Software by doxygen 1.16.1