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_stripLorentzAngleTool.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 ActsClusterComparisonAlg::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) const
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 ATH_MSG_DEBUG("[ERROR] Module " << module_id
132 << ": cluster mismatch detected!");
133 if (!unmatched_monitored.empty()) {
134 ATH_MSG_DEBUG(" Unmatched monitored clusters ("
135 << unmatched_monitored.size() << "):");
136 for (int i : unmatched_monitored) {
137 ATH_MSG_DEBUG(" - #" << i);
138 const xAOD::PixelCluster* monitored_cluster = monitored_list.at(i);
139 const auto& monitored_cov = monitored_cluster->localCovariance<1>();
140
141 ATH_MSG_DEBUG("Detailed print of cluster: ");
142
143 ATH_MSG_DEBUG("Local position: ");
144 ATH_MSG_DEBUG(
145 " Monitored: ("
146 << monitored_cluster->localPosition<2>()[Trk::locX] << ", "
147 << monitored_cluster->localPosition<2>()[Trk::locY] << ")");
148
149 ATH_MSG_DEBUG("Cluster cov: ");
150 ATH_MSG_DEBUG(" Monitored: (" << monitored_cov(0, 0) << ", "
151 << monitored_cov(1, 1) << ")");
152 }
153 m_pix_unmatched_mon+= unmatched_monitored.size();
154 }
155 if (!unmatched_reference.empty()) {
156 ATH_MSG_DEBUG(" Unmatched reference clusters (" << unmatched_reference.size()
157 << "):");
158 for (int j : unmatched_reference) {
159 ATH_MSG_DEBUG(" - #" << j);
160 const xAOD::PixelCluster* reference_cluster = reference_list.at(j);
161 const auto& reference_cov = reference_cluster->localCovariance<1>();
162
163 ATH_MSG_DEBUG("Detailed print of cluster: ");
164
165 ATH_MSG_DEBUG("Local position: ");
166
167 ATH_MSG_DEBUG(" Reference: ("
168 << reference_cluster->localPosition<2>()[Trk::locX] << ", "
169 << reference_cluster->localPosition<2>()[Trk::locY]
170 << ")");
171
172 ATH_MSG_DEBUG("Cluster cov: ");
173
174 ATH_MSG_DEBUG(" Reference: (" << reference_cov(0, 0) << ", "
175 << reference_cov(1, 1) << ")");
176 }
177 m_pix_unmatched_ref+= unmatched_reference.size();
178 }
179 ATH_MSG_DEBUG("------------------------------------------------------------");
180 }
181}
182
183// Match strip clusters
184void ActsClusterComparisonAlg::matchStripClusters(
185 std::vector<const xAOD::StripCluster*>& monitored_list,
186 std::vector<const xAOD::StripCluster*>& reference_list,
187 const std::string& module_id,
188 std::vector<
189 std::pair<const xAOD::StripCluster*, const xAOD::StripCluster*>>& pairs) const
190{
191
192 // Extract RDO sets
193 std::vector<std::set<Identifier>> monitored_rdo_sets;
194 std::vector<std::set<Identifier>> reference_rdo_sets;
195
196 for (const auto* c : monitored_list) {
197 const auto& rdoListRange = c->rdoList();
198 std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
199 monitored_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
200 }
201
202 for (const auto* c : reference_list) {
203 const auto& rdoListRange = c->rdoList();
204 std::vector<Identifier> rdoList(rdoListRange.begin(), rdoListRange.end());
205 reference_rdo_sets.emplace_back(rdoList.begin(), rdoList.end());
206 }
207
208 // Match clusters
209 std::vector<std::pair<int, int>> matched_pairs;
210 std::vector<int> unmatched_monitored;
211 std::set<int> unmatched_reference;
212
213 for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
214 unmatched_reference.insert(j);
215 }
216
217 for (size_t i = 0; i < monitored_rdo_sets.size(); ++i) {
218 bool found_match = false;
219 for (size_t j = 0; j < reference_rdo_sets.size(); ++j) {
220 if (monitored_rdo_sets[i] == reference_rdo_sets[j]) {
221 matched_pairs.emplace_back(i, j);
222 pairs.emplace_back(monitored_list.at(i), reference_list.at(j));
223 found_match = true;
224 unmatched_reference.erase(j);
225 break;
226 }
227 }
228 if (!found_match) {
229 unmatched_monitored.push_back(i);
230 }
231 }
232
233 // Report mismatches
234 if (!unmatched_monitored.empty() || !unmatched_reference.empty()) {
235 ATH_MSG_DEBUG("[ERROR] Module " << module_id
236 << ": cluster mismatch detected!");
237 if (!unmatched_monitored.empty()) {
238 ATH_MSG_DEBUG(" Unmatched monitored clusters ("
239 << unmatched_monitored.size() << "):");
240 for (int i : unmatched_monitored) {
241 ATH_MSG_DEBUG(" - #" << i);
242 const xAOD::StripCluster* monitored_cluster = monitored_list.at(i);
243 const auto& monitored_cov = monitored_cluster->localCovariance<1>();
244
245 ATH_MSG_DEBUG("Detailed print of cluster: ");
246
247 ATH_MSG_DEBUG("Local position: ");
248 ATH_MSG_DEBUG(
249 " Monitored: ("
250 << monitored_cluster->localPosition<1>()[Trk::locX] << ")");
251
252 ATH_MSG_DEBUG("Cluster cov: ");
253 ATH_MSG_DEBUG(" Monitored: (" << monitored_cov(0, 0) << ")");
254 }
255 m_strip_unmatched_mon+= unmatched_monitored.size();
256 }
257 if (!unmatched_reference.empty()) {
258 ATH_MSG_DEBUG(" Unmatched reference clusters (" << unmatched_reference.size()
259 << "):");
260 for (int j : unmatched_reference) {
261 ATH_MSG_DEBUG(" - #" << j);
262 const xAOD::StripCluster* reference_cluster = reference_list.at(j);
263 const auto& reference_cov = reference_cluster->localCovariance<1>();
264
265 ATH_MSG_DEBUG("Detailed print of cluster: ");
266
267 ATH_MSG_DEBUG("Local position: ");
268
269 ATH_MSG_DEBUG(" Reference: ("
270 << reference_cluster->localPosition<1>()[Trk::locX] << ")");
271
272 ATH_MSG_DEBUG("Cluster cov: ");
273
274 ATH_MSG_DEBUG(" Reference: (" << reference_cov(0, 0) << ")");
275 }
276 m_strip_unmatched_ref+= unmatched_reference.size();
277 }
278 ATH_MSG_DEBUG("------------------------------------------------------------");
279 }
280}
281
282StatusCode ActsClusterComparisonAlg::validateClusters(
283 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
284{
285
286 ATH_MSG_DEBUG(
287 "============================================================");
288 // retrieve the clusters in form of xAOD containers
289 ATH_MSG_INFO("Reading monitored clusters: " << m_monitoredPixelClustersKey.key()
290 << " and "
291 << m_monitoredStripClustersKey.key());
292 ATH_MSG_INFO("Reading reference clusters: " << m_referencePixelClustersKey.key()
293 << " and "
294 << m_referenceStripClustersKey.key());
295 ATH_MSG_DEBUG(
296 "============================================================");
297
298 SG::ReadHandle<xAOD::PixelClusterContainer> monitoredPixelClustersHandle =
299 SG::makeHandle(m_monitoredPixelClustersKey, eventContext);
300 ATH_CHECK(monitoredPixelClustersHandle.isValid());
301 const xAOD::PixelClusterContainer* monitoredPixelClusters =
302 monitoredPixelClustersHandle.cptr();
303
304 SG::ReadHandle<xAOD::StripClusterContainer> monitoredStripClustersHandle =
305 SG::makeHandle(m_monitoredStripClustersKey, eventContext);
306 ATH_CHECK(monitoredStripClustersHandle.isValid());
307 const xAOD::StripClusterContainer* monitoredStripClusters =
308 monitoredStripClustersHandle.cptr();
309
310 SG::ReadHandle<xAOD::PixelClusterContainer> referencePixelClustersHandle =
311 SG::makeHandle(m_referencePixelClustersKey, eventContext);
312 ATH_CHECK(referencePixelClustersHandle.isValid());
313 const xAOD::PixelClusterContainer* referencePixelClusters =
314 referencePixelClustersHandle.cptr();
315
316 SG::ReadHandle<xAOD::StripClusterContainer> referenceStripClustersHandle =
317 SG::makeHandle(m_referenceStripClustersKey, eventContext);
318 ATH_CHECK(referenceStripClustersHandle.isValid());
319 const xAOD::StripClusterContainer* referenceStripClusters =
320 referenceStripClustersHandle.cptr();
321
322 size_t t_n_pixel = monitoredPixelClusters->size();
323 size_t t_n_strip = monitoredStripClusters->size();
324 size_t a_n_pixel = referencePixelClusters->size();
325 size_t a_n_strip = referenceStripClusters->size();
326
327 ATH_MSG_DEBUG(" Monitored/reference pixel clusters " << t_n_pixel << " / "
328 << a_n_pixel);
329 ATH_MSG_DEBUG(" Monitored/reference strip clusters " << t_n_strip << " / "
330 << a_n_strip);
331
332 if (t_n_pixel != a_n_pixel) {
333 ATH_MSG_DEBUG("[ERROR] mismatched pixel cluster numbers found!");
334 ATH_MSG_DEBUG(" Monitored/reference clusters " << t_n_pixel << " / "
335 << a_n_pixel);
336 }
337 if (t_n_strip != a_n_strip) {
338 ATH_MSG_DEBUG("[ERROR] mismatched strip cluster numbers found!");
339 ATH_MSG_DEBUG(" Monitored/reference clusters " << t_n_strip << " / "
340 << a_n_strip);
341 }
342
343 // Group by module
344 std::map<std::string, std::vector<const xAOD::PixelCluster*>>
345 monitored_pixel_map, reference_pixel_map;
346 std::map<std::string, std::vector<const xAOD::StripCluster*>>
347 monitored_strip_map, reference_strip_map;
348
349 for (const auto* c : *monitoredPixelClusters) {
350 monitored_pixel_map[std::to_string(c->identifierHash())].push_back(c);
351 }
352 for (const auto* c : *monitoredStripClusters) {
353 monitored_strip_map[std::to_string(c->identifierHash())].push_back(c);
354 }
355 for (const auto* c : *referencePixelClusters) {
356 reference_pixel_map[std::to_string(c->identifierHash())].push_back(c);
357 }
358 for (const auto* c : *referenceStripClusters) {
359 reference_strip_map[std::to_string(c->identifierHash())].push_back(c);
360 }
361
362 // Collect all module IDs
363 std::set<std::string> pixel_modules, strip_modules;
364 for (const auto& [key, _] : monitored_pixel_map)
365 pixel_modules.insert(key);
366 for (const auto& [key, _] : reference_pixel_map)
367 pixel_modules.insert(key);
368 for (const auto& [key, _] : monitored_strip_map)
369 strip_modules.insert(key);
370 for (const auto& [key, _] : reference_strip_map)
371 strip_modules.insert(key);
372
373 int pixel_unequal = 0, strip_unequal = 0;
374 int matched_pixel = 0, matched_strip = 0;
375 int pixel_pos_diff_0p5sig = 0;
376 int pixel_pos_diff_0p25sig = 0;
377 int pixel_pos_diff_1sig = 0;
378 int strip_pos_diff_0p5sig = 0;
379 int strip_pos_diff_0p25sig = 0;
380 int strip_pos_diff_1sig = 0;
381
382 ATH_MSG_DEBUG("Pixel/Strip modules " << pixel_modules.size() << " / "
383 << strip_modules.size());
384 ATH_MSG_DEBUG("Pixel cluster validation: ");
385 ATH_MSG_DEBUG(
386 "============================================================");
387
388 // Process pixel modules
389 for (const auto& hid : pixel_modules) {
390 auto& tpixel = monitored_pixel_map[hid];
391 auto& apixel = reference_pixel_map[hid];
392
393 if (tpixel.empty() && apixel.empty())
394 continue;
395
396 if (tpixel.size() != apixel.size()) {
397 ATH_MSG_DEBUG("[ERROR] Pixel Module " << hid
398 << ": mismatched clusters found!");
399 ATH_MSG_DEBUG(" Reference found " << apixel.size()
400 << " and monitored found " << tpixel.size() << " clusters!");
401 pixel_unequal++;
402 continue;
403 }
404
405 std::vector<
406 std::pair<const xAOD::PixelCluster*, const xAOD::PixelCluster*>>
407 pixel_pairs;
408 matchPixelClusters(tpixel, apixel, hid, pixel_pairs);
409
410 matched_pixel += pixel_pairs.size();
411
412 // Add matched pairs and check position differences
413 for (const auto& pair : pixel_pairs) {
414 const xAOD::PixelCluster* monitored_cluster = pair.first;
415 const xAOD::PixelCluster* reference_cluster = pair.second;
416
417 (pixel_cluster_matches)[pair.first] = pair.second;
418
419 // Calculate local position difference
420 double l_dx = monitored_cluster->localPosition<2>()[Trk::locX] -
421 reference_cluster->localPosition<2>()[Trk::locX];
422 double l_dy = monitored_cluster->localPosition<2>()[Trk::locY] -
423 reference_cluster->localPosition<2>()[Trk::locY];
424 double l_pos_diff = std::sqrt(l_dx * l_dx + l_dy * l_dy);
425
426 // Calculate global position difference
427 float g_dx = (monitored_cluster->globalPosition()).x() -
428 (reference_cluster->globalPosition()).x();
429 float g_dy = (monitored_cluster->globalPosition()).y() -
430 (reference_cluster->globalPosition()).y();
431 float g_dz = (monitored_cluster->globalPosition()).z() -
432 (reference_cluster->globalPosition()).z();
433 float g_pos_diff =
434 std::sqrt(g_dx * g_dx + g_dy * g_dy + g_dz * g_dz);
435
436 // Calculate error difference
437 Eigen::Matrix<float, 2, 2> monitored_cov =
438 monitored_cluster->localCovariance<2>();
439 Eigen::Matrix<float, 2, 2> reference_cov =
440 reference_cluster->localCovariance<2>();
441
442 const InDetDD::SiDetectorElement* monitored_element =
443 m_pixelManager->getDetectorElement(
444 monitored_cluster->identifierHash());
445 const InDetDD::PixelModuleDesign& design =
446 static_cast<const InDetDD::PixelModuleDesign&>(
447 monitored_element->design());
448
449 const Identifier monitored_Pixel_ModuleID =
450 monitored_element->identify();
451 double monitored_lorentz_shift =
452 m_pixelLorentzAngleTool->getLorentzShift(
453 monitored_element->identifyHash(), eventContext);
454
455
456 if (std::abs(l_dx / (std::sqrt(monitored_cov(0, 0)))) > 0.25 ||
457 std::abs(l_dy / (std::sqrt(monitored_cov(1, 1)))) > 0.25) {
458 pixel_pos_diff_0p25sig++;
459
460 ATH_MSG_DEBUG("Detailed print of cluster discrepancy: ");
461 ATH_MSG_DEBUG("On module: " << monitored_Pixel_ModuleID);
462 ATH_MSG_DEBUG("Lorentz shift: " << std::fixed << std::setprecision(9) << monitored_lorentz_shift);
463
464 ATH_MSG_DEBUG("Local position: ");
465 ATH_MSG_DEBUG(
466 " Monitored: ("
467 << monitored_cluster->localPosition<2>()[Trk::locX] << ", "
468 << monitored_cluster->localPosition<2>()[Trk::locY] << ")");
469 ATH_MSG_DEBUG(" Reference: ("
470 << reference_cluster->localPosition<2>()[Trk::locX] << ", "
471 << reference_cluster->localPosition<2>()[Trk::locY]
472 << ")");
473 ATH_MSG_DEBUG(" Δx = " << l_dx << ", Δy = " << l_dy
474 << ", Δr = " << l_pos_diff);
475 ATH_MSG_DEBUG("Cluster cov: ");
476 ATH_MSG_DEBUG(" Monitored: (" << monitored_cov(0, 0) << ", "
477 << monitored_cov(1, 1) << ")");
478 ATH_MSG_DEBUG(" Reference: (" << reference_cov(0, 0) << ", "
479 << reference_cov(1, 1) << ")");
480 ATH_MSG_DEBUG(" Δx = " << monitored_cov(0, 0) - reference_cov(0, 0)
481 << ", Δy = "
482 << monitored_cov(1, 1) - reference_cov(1, 1));
483
484
485 const auto& rdoListRange = monitored_cluster->rdoList();
486 std::vector<Identifier> monitored_rdoList(
487 rdoListRange.begin(), rdoListRange.end());
488 for (auto rdoIter : monitored_rdoList) {
489 const InDetDD::SiCellId& chargeCellId =
490 monitored_element->cellIdFromIdentifier(rdoIter);
491 std::array<InDetDD::PixelDiodeTree::CellIndexType, 2>
492 diode_idx = InDetDD::PixelDiodeTree::makeCellIndex(
493 chargeCellId.phiIndex(), chargeCellId.etaIndex());
494
495 InDetDD::PixelDiodeTree::DiodeProxyWithPosition si_param(
496 design.diodeProxyFromIdxCachePosition(diode_idx));
497 ATH_MSG_DEBUG("hit id for this cell: "
498 << chargeCellId
499 << ", position: " << si_param.position()[0]
500 << ", " << si_param.position()[1]);
501 }
502
503 // Calculate width difference
504 ATH_MSG_DEBUG("Cluster width: ");
505 ATH_MSG_DEBUG(" Monitored phi/eta channels, eta width: ("
506 << monitored_cluster->channelsInPhi() << ", "
507 << monitored_cluster->channelsInEta() << ", "
508 << monitored_cluster->widthInEta() << ")");
509 ATH_MSG_DEBUG(" Reference phi/eta channels, eta width: ("
510 << reference_cluster->channelsInPhi() << ", "
511 << reference_cluster->channelsInEta() << ", "
512 << reference_cluster->widthInEta() << ")");
513
514 ATH_MSG_DEBUG(" Δphi = " << monitored_cluster->channelsInPhi() -
515 reference_cluster->channelsInPhi()
516 << ", Δeta = "
517 << monitored_cluster->channelsInEta() -
518 reference_cluster->channelsInEta()
519 << ", Δwidth = "
520 << monitored_cluster->widthInEta() -
521 reference_cluster->widthInEta());
522 }
523 if (std::abs(l_dx / (std::sqrt(monitored_cov(0, 0)))) > 0.5 ||
524 std::abs(l_dy / (std::sqrt(monitored_cov(1, 1)))) > 0.5) {
525 pixel_pos_diff_0p5sig++;
526 }
527 if (std::abs(l_dx / (std::sqrt(monitored_cov(0, 0)))) > 1 ||
528 std::abs(l_dy / (std::sqrt(monitored_cov(1, 1)))) > 1) {
529 pixel_pos_diff_1sig++;
530 }
531
532
533 ATH_MSG_VERBOSE("Global position: ");
534 ATH_MSG_VERBOSE(" Monitored: ("
535 << (monitored_cluster->globalPosition()).x() << ", "
536 << (monitored_cluster->globalPosition()).y() << ", "
537 << (monitored_cluster->globalPosition()).z() << ")");
538 ATH_MSG_VERBOSE(" Reference: ("
539 << (reference_cluster->globalPosition()).x() << ", "
540 << (reference_cluster->globalPosition()).y() << ", "
541 << (reference_cluster->globalPosition()).z() << ")");
542 ATH_MSG_VERBOSE(" Δx = " << g_dx << ", Δy = " << g_dy << ", Δz = "
543 << g_dz << ", Δr = " << g_pos_diff);
544
545 }
546 }
547
548 ATH_MSG_DEBUG(
549 "============================================================");
550 ATH_MSG_DEBUG("Strip cluster validation: ");
551 ATH_MSG_DEBUG(
552 "============================================================");
553 // Process strip modules
554 for (const auto& hid : strip_modules) {
555 auto& tstrip = monitored_strip_map[hid];
556 auto& astrip = reference_strip_map[hid];
557
558 if (tstrip.empty() && astrip.empty())
559 continue;
560
561 if (tstrip.size() != astrip.size()) {
562 ATH_MSG_DEBUG("[ERROR] Strip Module "
563 << hid << ": mismatched clusters found!");
564 ATH_MSG_DEBUG(" Reference found " << astrip.size()
565 << " and monitored found "
566 << tstrip.size() << " clusters!");
567 strip_unequal++;
568 continue;
569 }
570
571 std::vector<
572 std::pair<const xAOD::StripCluster*, const xAOD::StripCluster*>>
573 strip_pairs;
574 matchStripClusters(tstrip, astrip, hid, strip_pairs);
575
576 matched_strip += strip_pairs.size();
577
578 // Add matched pairs and check position differences
579 for (const auto& pair : strip_pairs) {
580 const xAOD::StripCluster* monitored_cluster = pair.first;
581 const xAOD::StripCluster* reference_cluster = pair.second;
582
583 (strip_cluster_matches)[pair.first] = pair.second;
584
585 // Calculate position difference
586 double pos_diff = monitored_cluster->localPosition<1>()[Trk::locX] -
587 reference_cluster->localPosition<1>()[Trk::locX];
588
589
590 // Calculate error difference
591 Eigen::Matrix<float, 1, 1> monitored_cov =
592 monitored_cluster->localCovariance<1>();
593 Eigen::Matrix<float, 1, 1> reference_cov =
594 reference_cluster->localCovariance<1>();
595
596 const InDetDD::SiDetectorElement* monitored_element =
597 m_stripManager->getDetectorElement(monitored_cluster->identifierHash());
598
599
600 if (std::abs(pos_diff / (std::sqrt(monitored_cov(0, 0)))) > 0.25) {
601 strip_pos_diff_0p25sig++;
602
603 int side = m_stripID->side(monitored_element->identify());
604 const Identifier strip_moduleID = m_stripID->module_id(monitored_element->identify());
605 const IdentifierHash Strip_ModuleHash = m_stripID->wafer_hash(strip_moduleID);
606 double monitored_lorentz_shift =
607 m_stripLorentzAngleTool->getLorentzShift(Strip_ModuleHash + side, eventContext);
608
609 ATH_MSG_DEBUG("Detailed print of cluster discrepancy: ");
610 ATH_MSG_DEBUG("On module: " << strip_moduleID << ", side: " << m_stripID->side(monitored_element->identify()));
611 ATH_MSG_DEBUG("Lorentz shift: " << std::fixed << std::setprecision(9) << monitored_lorentz_shift);
612
613 ATH_MSG_DEBUG("Local position: ");
614 ATH_MSG_DEBUG(
615 " Monitored: ("
616 << monitored_cluster->localPosition<1>()[Trk::locX] << ")");
617 ATH_MSG_DEBUG(" Reference: ("
618 << reference_cluster->localPosition<1>()[Trk::locX] << ")");
619 ATH_MSG_DEBUG(" Δx = " << pos_diff );
620 ATH_MSG_DEBUG("Cluster cov: ");
621 ATH_MSG_DEBUG(" Monitored: (" << monitored_cov(0, 0) << ")");
622 ATH_MSG_DEBUG(" Reference: (" << reference_cov(0, 0) << ")");
623 ATH_MSG_DEBUG(" Δx = " << monitored_cov(0, 0) - reference_cov(0, 0));
624
625 const auto& rdoListRange = monitored_cluster->rdoList();
626 std::vector<Identifier> monitored_rdoList(
627 rdoListRange.begin(), rdoListRange.end());
628
629 if (monitored_element->isBarrel()) {
630 const InDetDD::SCT_BarrelModuleSideDesign* s_design = (static_cast<const InDetDD::SCT_BarrelModuleSideDesign*>(&monitored_element->design()));
631
632 for (auto rdoIter : monitored_rdoList) {
633 const InDetDD::SiCellId& chargeCellId =
634 monitored_element->cellIdFromIdentifier(rdoIter);
635 InDetDD::SiLocalPosition si_pos =
636 s_design->localPositionOfCell(chargeCellId);
637 Amg::Vector2D loc_pos(si_pos.xPhi(), si_pos.xEta());
638 ATH_MSG_DEBUG("hit id for this cell: "
639 << chargeCellId
640 << ", position: " << loc_pos[0]
641 << ", " << loc_pos[1]);
642 }
643
644 }else{
645
646 const InDetDD::StripStereoAnnulusDesign* annulus_design = (static_cast<const InDetDD::StripStereoAnnulusDesign*>(&monitored_element->design()));
647
648 for (auto rdoIter : monitored_rdoList) {
649 const InDetDD::SiCellId& chargeCellId =
650 monitored_element->cellIdFromIdentifier(rdoIter);
651
652 InDetDD::SiLocalPosition si_pos =
653 annulus_design->localPositionOfCell(chargeCellId);
654 Amg::Vector2D loc_pos(si_pos.xPhi(), si_pos.xEta());
655 ATH_MSG_DEBUG("hit id for this cell: "
656 << chargeCellId
657 << ", posiiton: " << loc_pos[0]
658 << ", " << loc_pos[1]);
659 }
660
661 }
662
663 // Calculate width difference
664 ATH_MSG_DEBUG("Cluster width: ");
665 ATH_MSG_DEBUG(" Monitored phi channels: ("
666 << monitored_cluster->channelsInPhi() << ")");
667 ATH_MSG_DEBUG(" Reference phi channels: ("
668 << reference_cluster->channelsInPhi() << ")");
669
670 ATH_MSG_DEBUG(" Δphi = " << monitored_cluster->channelsInPhi() -
671 reference_cluster->channelsInPhi());
672
673 }
674 if (std::abs(pos_diff / (std::sqrt(monitored_cov(0, 0)))) > 0.5) {
675 strip_pos_diff_0p5sig++;
676 }
677 if (std::abs(pos_diff / (std::sqrt(monitored_cov(0, 0)))) > 1) {
678 strip_pos_diff_1sig++;
679 }
680
681 }
682 }
683
684 ATH_MSG_DEBUG(
685 "============================================================");
686
687 // Print statistics
688 ATH_MSG_DEBUG(
689 "============================================================");
690 ATH_MSG_DEBUG("PIXEL CLUSTER MATCHING STATISTICS: ");
691 ATH_MSG_DEBUG(" Total matched clusters: " << matched_pixel);
692 ATH_MSG_DEBUG(" Clusters with pos diff > 1 sigma: "
693 << pixel_pos_diff_1sig << " ("
694 << (matched_pixel > 0
695 ? 100.0 * pixel_pos_diff_1sig / matched_pixel
696 : 0.0)
697 << "%)");
698 ATH_MSG_DEBUG(" Clusters with pos diff > 0.5 sigma: "
699 << pixel_pos_diff_0p5sig << " ("
700 << (matched_pixel > 0
701 ? 100.0 * pixel_pos_diff_0p5sig / matched_pixel
702 : 0.0)
703 << "%)");
704 ATH_MSG_DEBUG(" Clusters with pos diff > 0.25 sigma: "
705 << pixel_pos_diff_0p25sig << " ("
706 << (matched_pixel > 0
707 ? 100.0 * pixel_pos_diff_0p25sig / matched_pixel
708 : 0.0)
709 << "%)");
710 ATH_MSG_DEBUG(
711 "============================================================");
712 ATH_MSG_DEBUG(
713 "============================================================");
714 ATH_MSG_DEBUG("STRIP CLUSTER MATCHING STATISTICS:");
715 ATH_MSG_DEBUG(" Total matched clusters: " << matched_strip);
716 ATH_MSG_DEBUG(" Clusters with pos diff > 1 sigma: "
717 << strip_pos_diff_1sig << " ("
718 << (matched_strip > 0
719 ? 100.0 * strip_pos_diff_1sig / matched_strip
720 : 0.0)
721 << "%)");
722 ATH_MSG_DEBUG(" Clusters with pos diff > 0.5 sigma: "
723 << strip_pos_diff_0p5sig << " ("
724 << (matched_strip > 0
725 ? 100.0 * strip_pos_diff_0p5sig / matched_strip
726 : 0.0)
727 << "%)");
728 ATH_MSG_DEBUG(" Clusters with pos diff > 0.25 sigma: "
729 << strip_pos_diff_0p25sig << " ("
730 << (matched_strip > 0
731 ? 100.0 * strip_pos_diff_0p25sig / matched_strip
732 : 0.0)
733 << "%)");
734 ATH_MSG_DEBUG(
735 "============================================================");
736
737 m_pixel_unequal += pixel_unequal;
738 m_strip_unequal += strip_unequal;
739 m_matched_pixel += matched_pixel;
740 m_matched_strip += matched_strip;
741 m_pixel_pos_diff_1sig += pixel_pos_diff_1sig;
742 m_pixel_pos_diff_0p5sig += pixel_pos_diff_0p5sig;
743 m_pixel_pos_diff_0p25sig += pixel_pos_diff_0p25sig;
744 m_strip_pos_diff_1sig += strip_pos_diff_1sig;
745 m_strip_pos_diff_0p5sig += strip_pos_diff_0p5sig;
746 m_strip_pos_diff_0p25sig += strip_pos_diff_0p25sig;
747
748 return StatusCode::SUCCESS;
749}
750
751StatusCode ActsClusterComparisonAlg::validatePixelSpacepoints(
752 const EventContext& eventContext, std::unordered_map<const xAOD::PixelCluster*, const xAOD::PixelCluster*>& pixel_cluster_matches) const
753{
754
755 // retrieve the spacepoints in form of xAOD containers
756 ATH_MSG_INFO(
757 "Reading monitored spacepoints: " << m_monitoredSpacepointsKey.key());
758 ATH_MSG_INFO("Reading reference spacepoints: " << m_referenceSpacepointsKey.key());
759
760 SG::ReadHandle<xAOD::SpacePointContainer> monitoredSpacepointsHandle =
761 SG::makeHandle(m_monitoredSpacepointsKey, eventContext);
762 ATH_CHECK(monitoredSpacepointsHandle.isValid());
763 const xAOD::SpacePointContainer* monitoredSpacepoints =
764 monitoredSpacepointsHandle.cptr();
765
766 SG::ReadHandle<xAOD::SpacePointContainer> referenceSpacepointsHandle =
767 SG::makeHandle(m_referenceSpacepointsKey, eventContext);
768 ATH_CHECK(referenceSpacepointsHandle.isValid());
769 const xAOD::SpacePointContainer* referenceSpacepoints =
770 referenceSpacepointsHandle.cptr();
771
772 size_t t_n_sp = monitoredSpacepoints->size();
773 size_t a_n_sp = referenceSpacepoints->size();
774
775 ATH_MSG_DEBUG(" Monitored/reference spacepoints " << t_n_sp << " / " << a_n_sp);
776
777 if (t_n_sp != a_n_sp) {
778 ATH_MSG_DEBUG("[ERROR] mismatched spacepoint numbers found!");
779 ATH_MSG_DEBUG(" Monitored/reference spacepoints " << t_n_sp << " / "
780 << a_n_sp);
781 }
782
783 // Now match spacepoints based on their constituent clusters
784 int matched_sp = 0;
785 int unmatched_monitored_sp = 0;
786 int unmatched_reference_sp = 0;
787 int sp_global_pos_diff_1mm = 0;
788 int sp_global_pos_diff_5mm = 0;
789 int sp_variance_r_diff = 0;
790 int sp_variance_z_diff = 0;
791
792 std::vector<std::pair<const xAOD::SpacePoint*, const xAOD::SpacePoint*>>
793 sp_matches;
794 std::set<const xAOD::SpacePoint*> matched_reference_sp;
795
796 for (const auto* monitored_sp : *monitoredSpacepoints) {
797
798 const auto& monitored_measurements = monitored_sp->measurements();
799
800 // Find matching ACTS spacepoint by comparing cluster content
801 bool found_match = false;
802 for (const auto* reference_sp : *referenceSpacepoints) {
803
804 const auto& reference_measurements = reference_sp->measurements();
805
806 // Check if measurements sizes match
807 if (monitored_measurements.size() != reference_measurements.size())
808 continue;
809
810 // Check if all clusters match
811 bool all_clusters_match = true;
812 for (size_t i = 0; i < monitored_measurements.size(); ++i) {
813 const xAOD::UncalibratedMeasurement* monitored_meas =
814 monitored_measurements[i];
815 const xAOD::UncalibratedMeasurement* reference_meas =
816 reference_measurements[i];
817
818 // Try pixel cluster matching
819 auto monitored_pixel =
820 dynamic_cast<const xAOD::PixelCluster*>(monitored_meas);
821 auto reference_pixel =
822 dynamic_cast<const xAOD::PixelCluster*>(reference_meas);
823
824 if (monitored_pixel && reference_pixel) {
825 auto it = pixel_cluster_matches.find(monitored_pixel);
826 if (it == pixel_cluster_matches.end() ||
827 it->second != reference_pixel) {
828 all_clusters_match = false;
829 break;
830 }
831 } else {
832 // Only pixel spacepoints are supported for now
833 ATH_MSG_WARNING("Non-pixel measurement in spacepoint comparison — "
834 "strip spacepoints are not yet handled, skipping pair");
835 all_clusters_match = false;
836 break;
837 }
838 }
839
840 if (all_clusters_match) {
841
842 // Found matching spacepoint pair
843 matched_sp++;
844 sp_matches.push_back(std::make_pair(monitored_sp, reference_sp));
845 matched_reference_sp.insert(reference_sp);
846 found_match = true;
847
848 break;
849 }
850 }
851
852 if (!found_match) {
853 unmatched_monitored_sp++;
854 }
855 }
856
857 for (auto& sp_pair : sp_matches) {
858
859 const xAOD::SpacePoint* monitored_sp = sp_pair.first;
860 const xAOD::SpacePoint* reference_sp = sp_pair.second;
861
862 double dx = monitored_sp->x() - reference_sp->x();
863 double dy = monitored_sp->y() - reference_sp->y();
864 double dz = monitored_sp->z() - reference_sp->z();
865 double pos_diff = std::sqrt(dx * dx + dy * dy + dz * dz);
866
867 // Calculate global position difference
868 ATH_MSG_DEBUG("Spacepoint global position: ");
869 ATH_MSG_DEBUG(" Monitored: (" << monitored_sp->x() << ", " << monitored_sp->y()
870 << ", " << monitored_sp->z() << ")");
871 ATH_MSG_DEBUG(" Reference: (" << reference_sp->x() << ", " << reference_sp->y()
872 << ", " << reference_sp->z() << ")");
873 ATH_MSG_DEBUG(" Δx = " << dx << ", Δy = " << dy << ", Δz = " << dz
874 << ", Δr = " << pos_diff);
875
876 if (pos_diff > 1.0)
877 sp_global_pos_diff_1mm++;
878 if (pos_diff > 5.0)
879 sp_global_pos_diff_5mm++;
880
881 // Calculate covariance difference
882 ATH_MSG_DEBUG("Spacepoint cov and radius: ");
883 ATH_MSG_DEBUG(" Monitored r/z and radius: ("
884 << monitored_sp->varianceR() << ", "
885 << monitored_sp->varianceZ() << ", " << monitored_sp->radius()
886 << ")");
887 ATH_MSG_DEBUG(" Reference r/z and radius: (" << reference_sp->varianceR() << ", "
888 << reference_sp->varianceZ() << ", "
889 << reference_sp->radius() << ")");
890 ATH_MSG_DEBUG(" Δcov_r = "
891 << monitored_sp->varianceR() - reference_sp->varianceR()
892 << ", Δcov_z = "
893 << monitored_sp->varianceZ() - reference_sp->varianceZ()
894 << ", Δradius = "
895 << monitored_sp->radius() - reference_sp->radius());
896
897 if (reference_sp->varianceR() > 0 &&
898 std::abs(monitored_sp->varianceR() - reference_sp->varianceR()) /
899 reference_sp->varianceR() > 0.1)
900 sp_variance_r_diff++;
901 if (reference_sp->varianceZ() > 0 &&
902 std::abs(monitored_sp->varianceZ() - reference_sp->varianceZ()) /
903 reference_sp->varianceZ() > 0.1)
904 sp_variance_z_diff++;
905
906 }
907
908 unmatched_reference_sp = referenceSpacepoints->size() - matched_reference_sp.size();
909
910 // Print statistics
911 ATH_MSG_INFO(
912 "============================================================");
913 ATH_MSG_INFO("SPACEPOINT MATCHING STATISTICS:");
914 ATH_MSG_INFO(" Total monitored spacepoints: " << t_n_sp);
915 ATH_MSG_INFO(" Total reference spacepoints: " << a_n_sp);
916 ATH_MSG_INFO(" Matched spacepoints: " << matched_sp);
917 ATH_MSG_INFO(" Unmatched monitored spacepoints: " << unmatched_monitored_sp);
918 ATH_MSG_INFO(" Unmatched reference spacepoints: " << unmatched_reference_sp);
919 ATH_MSG_INFO(
920 "============================================================");
921 ATH_MSG_INFO("SPACEPOINT POSITION COMPARISON:");
922 ATH_MSG_INFO(
923 " Spacepoints with global pos diff > 1 mm: "
924 << sp_global_pos_diff_1mm << " ("
925 << (matched_sp > 0 ? 100.0 * sp_global_pos_diff_1mm / matched_sp : 0.0)
926 << "%)");
927 ATH_MSG_INFO(
928 " Spacepoints with global pos diff > 5 mm: "
929 << sp_global_pos_diff_5mm << " ("
930 << (matched_sp > 0 ? 100.0 * sp_global_pos_diff_5mm / matched_sp : 0.0)
931 << "%)");
932 ATH_MSG_INFO(
933 "============================================================");
934 ATH_MSG_INFO("SPACEPOINT VARIANCE COMPARISON:");
935 ATH_MSG_INFO(
936 " Spacepoints with >10% variance R difference: "
937 << sp_variance_r_diff << " ("
938 << (matched_sp > 0 ? 100.0 * sp_variance_r_diff / matched_sp : 0.0)
939 << "%)");
940 ATH_MSG_INFO(
941 " Spacepoints with >10% variance Z difference: "
942 << sp_variance_z_diff << " ("
943 << (matched_sp > 0 ? 100.0 * sp_variance_z_diff / matched_sp : 0.0)
944 << "%)");
945 ATH_MSG_INFO(
946 "============================================================");
947
948
949 m_nMonSp += t_n_sp;
950 m_nRefSp += a_n_sp;
951 m_nMatchedSp += matched_sp;
952 m_nUnmatchedMonSp += unmatched_monitored_sp;
953 m_nUnmatchedRefSp += unmatched_reference_sp;
954 m_nSpPosDiff1mm += sp_global_pos_diff_1mm;
955 m_nSpPosDiff5mm += sp_global_pos_diff_5mm;
956 m_nSpVarRDiff += sp_variance_r_diff;
957 m_nSpVarZDiff += sp_variance_z_diff;
958
959 return StatusCode::SUCCESS;
960}
961
962StatusCode ActsClusterComparisonAlg::finalize()
963{
964
965 // Print cluster statistics
966 ATH_MSG_INFO("Validation Summary");
967 ATH_MSG_INFO("ValSum ============================================================");
968 ATH_MSG_INFO("ValSum PIXEL CLUSTER MATCHING STATISTICS: ");
969 ATH_MSG_INFO("ValSum Total unmatched clusters mon/ref: " << m_pix_unmatched_mon << " / " << m_pix_unmatched_ref);
970 ATH_MSG_INFO("ValSum Total matched clusters: " << m_matched_pixel);
971 ATH_MSG_INFO("ValSum Clusters with pos diff > 1 sigma: "
972 << m_pixel_pos_diff_1sig << " ("
973 << (m_matched_pixel.value() > 0
974 ? 100.0 * m_pixel_pos_diff_1sig.value() / m_matched_pixel.value()
975 : 0.0)
976 << "%)");
977 ATH_MSG_INFO("ValSum Clusters with pos diff > 0.5 sigma: "
978 << m_pixel_pos_diff_0p5sig << " ("
979 << (m_matched_pixel.value() > 0
980 ? 100.0 * m_pixel_pos_diff_0p5sig.value() / m_matched_pixel.value()
981 : 0.0)
982 << "%)");
983 ATH_MSG_INFO("ValSum Clusters with pos diff > 0.25 sigma: "
984 << m_pixel_pos_diff_0p25sig << " ("
985 << (m_matched_pixel.value() > 0
986 ? 100.0 * m_pixel_pos_diff_0p25sig.value() / m_matched_pixel.value()
987 : 0.0)
988 << "%)");
989 ATH_MSG_INFO("ValSum ============================================================");
990 ATH_MSG_INFO("ValSum ============================================================");
991 ATH_MSG_INFO("ValSum STRIP CLUSTER MATCHING STATISTICS:");
992 ATH_MSG_INFO("ValSum Total unmatched clusters mon/ref: " << m_strip_unmatched_mon << " / " << m_strip_unmatched_ref);
993 ATH_MSG_INFO("ValSum Total matched clusters: " << m_matched_strip);
994 ATH_MSG_INFO("ValSum Clusters with pos diff > 1 sigma: "
995 << m_strip_pos_diff_1sig << " ("
996 << (m_matched_strip.value() > 0
997 ? 100.0 * m_strip_pos_diff_1sig.value() / m_matched_strip.value()
998 : 0.0)
999 << "%)");
1000 ATH_MSG_INFO("ValSum Clusters with pos diff > 0.5 sigma: "
1001 << m_strip_pos_diff_0p5sig << " ("
1002 << (m_matched_strip.value() > 0
1003 ? 100.0 * m_strip_pos_diff_0p5sig.value() / m_matched_strip.value()
1004 : 0.0)
1005 << "%)");
1006 ATH_MSG_INFO("ValSum Clusters with pos diff > 0.25 sigma: "
1007 << m_strip_pos_diff_0p25sig << " ("
1008 << (m_matched_strip.value() > 0
1009 ? 100.0 * m_strip_pos_diff_0p25sig.value() / m_matched_strip.value()
1010 : 0.0)
1011 << "%)");
1012 ATH_MSG_INFO("ValSum ============================================================");
1013
1014 if(m_checkSpacepoints){
1015 ATH_MSG_INFO("ValSum ============================================================");
1016 ATH_MSG_INFO("ValSum PIXEL SPACEPOINT MATCHING STATISTICS:");
1017 ATH_MSG_INFO("ValSum Total monitored spacepoints: " << m_nMonSp);
1018 ATH_MSG_INFO("ValSum Total reference spacepoints: " << m_nRefSp);
1019 ATH_MSG_INFO("ValSum Matched spacepoints: " << m_nMatchedSp);
1020 ATH_MSG_INFO("ValSum Unmatched monitored spacepoints: " << m_nUnmatchedMonSp);
1021 ATH_MSG_INFO("ValSum Unmatched reference spacepoints: " << m_nUnmatchedRefSp);
1022 ATH_MSG_INFO("ValSum ============================================================");
1023 ATH_MSG_INFO("ValSum SPACEPOINT POSITION COMPARISON:");
1024 ATH_MSG_INFO("ValSum Spacepoints with global pos diff > 1 mm: "
1025 << m_nSpPosDiff1mm << " ("
1026 << (m_nMatchedSp.value() > 0 ? 100.0 * m_nSpPosDiff1mm.value() / m_nMatchedSp.value() : 0.0)
1027 << "%)");
1028 ATH_MSG_INFO("ValSum Spacepoints with global pos diff > 5 mm: "
1029 << m_nSpPosDiff5mm << " ("
1030 << (m_nMatchedSp.value() > 0 ? 100.0 * m_nSpPosDiff5mm.value() / m_nMatchedSp.value() : 0.0)
1031 << "%)");
1032 ATH_MSG_INFO("ValSum ============================================================");
1033 ATH_MSG_INFO("ValSum SPACEPOINT VARIANCE COMPARISON:");
1034 ATH_MSG_INFO("ValSum Spacepoints with >10% variance R difference: "
1035 << m_nSpVarRDiff << " ("
1036 << (m_nMatchedSp.value() > 0 ? 100.0 * m_nSpVarRDiff.value() / m_nMatchedSp.value() : 0.0)
1037 << "%)");
1038 ATH_MSG_INFO("ValSum Spacepoints with >10% variance Z difference: "
1039 << m_nSpVarZDiff << " ("
1040 << (m_nMatchedSp.value() > 0 ? 100.0 * m_nSpVarZDiff.value() / m_nMatchedSp.value() : 0.0)
1041 << "%)");
1042 ATH_MSG_INFO("ValSum ============================================================");
1043 }
1044
1045 return StatusCode::SUCCESS;
1046}
1047
1048} // namespace ActsTrk
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x,...)
Definition AthMsgStreamMacros.h:43
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x,...)
Definition AthMsgStreamMacros.h:46
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x,...)
Definition AthMsgStreamMacros.h:42
ATH_MSG_INFO
#define ATH_MSG_INFO(x,...)
Definition AthMsgStreamMacros.h:45
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:132
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:282
ActsTrk::ActsClusterComparisonAlg::m_pix_unmatched_mon
Gaudi::Accumulators::Counter m_pix_unmatched_mon
Definition ActsClusterComparisonAlg.h:118
ActsTrk::ActsClusterComparisonAlg::m_referencePixelClustersKey
SG::ReadHandleKey< xAOD::PixelClusterContainer > m_referencePixelClustersKey
Definition ActsClusterComparisonAlg.h:103
ActsTrk::ActsClusterComparisonAlg::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) const
Definition ActsClusterComparisonAlg.cxx:79
ActsTrk::ActsClusterComparisonAlg::m_pixelLorentzAngleTool
ToolHandle< ISiLorentzAngleTool > m_pixelLorentzAngleTool
Definition ActsClusterComparisonAlg.h:150
ActsTrk::ActsClusterComparisonAlg::m_pixel_unequal
Gaudi::Accumulators::Counter m_pixel_unequal
Definition ActsClusterComparisonAlg.h:114
ActsTrk::ActsClusterComparisonAlg::m_strip_unmatched_ref
Gaudi::Accumulators::Counter m_strip_unmatched_ref
Definition ActsClusterComparisonAlg.h:121
ActsTrk::ActsClusterComparisonAlg::m_monitoredSpacepointsKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_monitoredSpacepointsKey
Definition ActsClusterComparisonAlg.h:87
ActsTrk::ActsClusterComparisonAlg::m_referenceStripClustersKey
SG::ReadHandleKey< xAOD::StripClusterContainer > m_referenceStripClustersKey
Definition ActsClusterComparisonAlg.h:107
ActsTrk::ActsClusterComparisonAlg::m_monitoredPixelClustersKey
SG::ReadHandleKey< xAOD::PixelClusterContainer > m_monitoredPixelClustersKey
Definition ActsClusterComparisonAlg.h:95
ActsTrk::ActsClusterComparisonAlg::m_nUnmatchedRefSp
Gaudi::Accumulators::Counter m_nUnmatchedRefSp
Definition ActsClusterComparisonAlg.h:134
ActsTrk::ActsClusterComparisonAlg::m_strip_unequal
Gaudi::Accumulators::Counter m_strip_unequal
Definition ActsClusterComparisonAlg.h:115
ActsTrk::ActsClusterComparisonAlg::m_pixel_pos_diff_0p25sig
Gaudi::Accumulators::Counter m_pixel_pos_diff_0p25sig
Definition ActsClusterComparisonAlg.h:124
ActsTrk::ActsClusterComparisonAlg::m_stripManagerKey
Gaudi::Property< std::string > m_stripManagerKey
Definition ActsClusterComparisonAlg.h:142
ActsTrk::ActsClusterComparisonAlg::m_nSpPosDiff5mm
Gaudi::Accumulators::Counter m_nSpPosDiff5mm
Definition ActsClusterComparisonAlg.h:136
ActsTrk::ActsClusterComparisonAlg::m_strip_pos_diff_0p5sig
Gaudi::Accumulators::Counter m_strip_pos_diff_0p5sig
Definition ActsClusterComparisonAlg.h:126
ActsTrk::ActsClusterComparisonAlg::m_pixelManager
const InDetDD::PixelDetectorManager * m_pixelManager
Definition ActsClusterComparisonAlg.h:144
ActsTrk::ActsClusterComparisonAlg::m_nSpVarRDiff
Gaudi::Accumulators::Counter m_nSpVarRDiff
Definition ActsClusterComparisonAlg.h:137
ActsTrk::ActsClusterComparisonAlg::m_monitoredStripClustersKey
SG::ReadHandleKey< xAOD::StripClusterContainer > m_monitoredStripClustersKey
Definition ActsClusterComparisonAlg.h:99
ActsTrk::ActsClusterComparisonAlg::m_matched_pixel
Gaudi::Accumulators::Counter m_matched_pixel
Definition ActsClusterComparisonAlg.h:116
ActsTrk::ActsClusterComparisonAlg::m_nSpVarZDiff
Gaudi::Accumulators::Counter m_nSpVarZDiff
Definition ActsClusterComparisonAlg.h:138
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:135
ActsTrk::ActsClusterComparisonAlg::m_strip_pos_diff_0p25sig
Gaudi::Accumulators::Counter m_strip_pos_diff_0p25sig
Definition ActsClusterComparisonAlg.h:127
ActsTrk::ActsClusterComparisonAlg::finalize
virtual StatusCode finalize() override
Finalize the algorithm.
Definition ActsClusterComparisonAlg.cxx:962
ActsTrk::ActsClusterComparisonAlg::m_stripLorentzAngleTool
ToolHandle< ISiLorentzAngleTool > m_stripLorentzAngleTool
Definition ActsClusterComparisonAlg.h:147
ActsTrk::ActsClusterComparisonAlg::m_nUnmatchedMonSp
Gaudi::Accumulators::Counter m_nUnmatchedMonSp
Definition ActsClusterComparisonAlg.h:133
ActsTrk::ActsClusterComparisonAlg::m_strip_pos_diff_1sig
Gaudi::Accumulators::Counter m_strip_pos_diff_1sig
Definition ActsClusterComparisonAlg.h:125
ActsTrk::ActsClusterComparisonAlg::m_stripManager
const InDetDD::SCT_DetectorManager * m_stripManager
Definition ActsClusterComparisonAlg.h:145
ActsTrk::ActsClusterComparisonAlg::m_pixel_pos_diff_1sig
Gaudi::Accumulators::Counter m_pixel_pos_diff_1sig
Definition ActsClusterComparisonAlg.h:122
ActsTrk::ActsClusterComparisonAlg::m_strip_unmatched_mon
Gaudi::Accumulators::Counter m_strip_unmatched_mon
Definition ActsClusterComparisonAlg.h:120
ActsTrk::ActsClusterComparisonAlg::m_matched_strip
Gaudi::Accumulators::Counter m_matched_strip
Definition ActsClusterComparisonAlg.h:117
ActsTrk::ActsClusterComparisonAlg::m_referenceSpacepointsKey
SG::ReadHandleKey< xAOD::SpacePointContainer > m_referenceSpacepointsKey
Definition ActsClusterComparisonAlg.h:91
ActsTrk::ActsClusterComparisonAlg::m_pix_unmatched_ref
Gaudi::Accumulators::Counter m_pix_unmatched_ref
Definition ActsClusterComparisonAlg.h:119
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:140
ActsTrk::ActsClusterComparisonAlg::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) const
Definition ActsClusterComparisonAlg.cxx:184
ActsTrk::ActsClusterComparisonAlg::m_pixel_pos_diff_0p5sig
Gaudi::Accumulators::Counter m_pixel_pos_diff_0p5sig
Definition ActsClusterComparisonAlg.h:123
ActsTrk::ActsClusterComparisonAlg::validatePixelSpacepoints
StatusCode validatePixelSpacepoints(const EventContext &eventContext, std::unordered_map< const xAOD::PixelCluster *, const xAOD::PixelCluster * > &pixel_cluster_matches) const
Definition ActsClusterComparisonAlg.cxx:751
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:150
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
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition GeoPrimitives.h:49
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition ReadCondHandle.h:268
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.17.0