ATLAS Offline Software
TrackStatePrinterTool.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
3 */
4 
5 #include "src/TrackStatePrinterTool.h"
6 
7 // Athena
8 #include "TrkParameters/TrackParameters.h"
9 #include "InDetReadoutGeometry/SiDetectorElement.h"
10 #include "HGTD_ReadoutGeometry/HGTD_DetectorElement.h"
11 #include "xAODMeasurementBase/UncalibratedMeasurementContainer.h"
12 
13 // ACTS
14 #include "Acts/Definitions/Units.hpp"
15 #include "Acts/Definitions/Common.hpp"
16 #include "Acts/Definitions/Algebra.hpp"
17 #include "Acts/Surfaces/Surface.hpp"
18 #include "Acts/Surfaces/AnnulusBounds.hpp"
19 #include "Acts/Surfaces/SurfaceBounds.hpp"
20 #include "Acts/Surfaces/DiscSurface.hpp"
21 #include "Acts/EventData/TransformationHelpers.hpp"
22 
23 // PACKAGE
24 #include "ActsGeometry/ActsDetectorElement.h"
25 #include "ActsEvent/TrackContainer.h"
26 #include "ActsInterop/Logger.h"
27 
28 #include "ActsGeometry/SurfaceOfMeasurementUtil.h"
29 
30 // Other
31 #include <vector>
32 #include <iostream>
33 #include <sstream>
34 
35 namespace ActsTrk
36 {
41 
42  std::string TrackStatePrinterTool::trackStateName(Acts::ConstTrackStateType trackStateType)
43  {
44  static constexpr std::array<std::tuple<bool, Acts::TrackStateFlag, char>, 6> trackStateNames{{
45  {false, Acts::TrackStateFlag::ParameterFlag, '-'},
46  {true, Acts::TrackStateFlag::MeasurementFlag, 'M'},
47  {true, Acts::TrackStateFlag::OutlierFlag, 'O'},
48  {true, Acts::TrackStateFlag::HoleFlag, 'H'},
49  {true, Acts::TrackStateFlag::MaterialFlag, 'm'},
50  {true, Acts::TrackStateFlag::SharedHitFlag, 'S'},
51  }};
52  std::string s;
53  for (const auto &[b, f, c] : trackStateNames)
54  {
55  if (trackStateType.test(f) == b)
56  s += c;
57  }
58  return s;
59  }
60 
61  // compact surface/boundary name
62  std::string TrackStatePrinterTool::actsSurfaceName(const Acts::Surface &surface)
63  {
64  std::string name = surface.name();
65  if (name.compare(0, 6, "Acts::") == 0)
66  {
67  name.erase(0, 6);
68  }
69  if (name.size() > 7 && name.compare(name.size() - 7, 7, "Surface") == 0)
70  {
71  name.erase(name.size() - 7, 7);
72  }
73  static const std::map<Acts::SurfaceBounds::BoundsType, const char *> boundsNames{{
74  {Acts::SurfaceBounds::BoundsType::eCone, "Cone"},
75  {Acts::SurfaceBounds::BoundsType::eCylinder, "Cylinder"},
76  {Acts::SurfaceBounds::BoundsType::eDiamond, "Diamond"},
77  {Acts::SurfaceBounds::BoundsType::eDisc, "Disc"},
78  {Acts::SurfaceBounds::BoundsType::eEllipse, "Ellipse"},
79  {Acts::SurfaceBounds::BoundsType::eLine, "Line"},
80  {Acts::SurfaceBounds::BoundsType::eRectangle, "Rectangle"},
81  {Acts::SurfaceBounds::BoundsType::eTrapezoid, "Trapezoid"},
82  {Acts::SurfaceBounds::BoundsType::eTriangle, "Triangle"},
83  {Acts::SurfaceBounds::BoundsType::eDiscTrapezoid, "DiscTrapezoid"},
84  {Acts::SurfaceBounds::BoundsType::eConvexPolygon, "ConvexPolygon"},
85  {Acts::SurfaceBounds::BoundsType::eAnnulus, "Annulus"},
86  {Acts::SurfaceBounds::BoundsType::eBoundless, "Boundless"},
87  {Acts::SurfaceBounds::BoundsType::eOther, "Other"},
88  }};
89  if (auto it = boundsNames.find(surface.bounds().type());
90  it != boundsNames.end() && it->second != name)
91  {
92  name += ' ';
93  name += it->second;
94  }
95  return name;
96  }
97 
98  static std::string
99  atlasSurfaceName(const Acts::Surface *measurement_surface)
100  {
101  if (measurement_surface) {
102  const ActsDetectorElement *
103  acts_detector_element = dynamic_cast<const ActsDetectorElement *>(measurement_surface->associatedDetectorElement());
104  if (acts_detector_element) {
105  const InDetDD::SiDetectorElement *detElem = dynamic_cast< const InDetDD::SiDetectorElement *>(acts_detector_element->upstreamDetectorElement());
106  if (detElem) {
107  if (auto idHelper = detElem->getIdHelper())
108  {
109  auto name = idHelper->show_to_string(detElem->identify());
110  if (name.size() >= 2 && name[0] == '[' && name[name.size() - 1] == ']')
111  {
112  return name.substr(1, name.size() - 2);
113  }
114  else
115  {
116  return name;
117  }
118  }
119  }
120  }
121  }
122  return {};
123  }
124 
125  static void printHeader(int type, bool extra = false)
126  {
127  std::cout << std::left
128  << std::setw(5) << "Index" << ' '
129  << std::setw(4) << "Type" << ' '
130  << std::setw(21) << "SurfaceBounds" << ' ';
131  if (type == 0)
132  {
133  std::cout << std::setw(22) << "GeometryId" << ' '
134  << std::setw(20) << "ATLAS ID" << ' '
135  << std::right
136  << std::setw(10) << "loc0" << ' '
137  << std::setw(10) << "loc1"
138  << " "
139  << std::setw(9) << "R" << ' '
140  << std::setw(9) << "Pos Z" << ' '
141  << std::setw(9) << "phid" << ' '
142  << std::setw(9) << "eta";
143  if (extra)
144  {
145  std::cout << ' '
146  << std::setw(10) << "Trk loc0" << ' '
147  << std::setw(10) << "loc1"
148  << " "
149  << std::setw(9) << "Trk R" << ' '
150  << std::setw(9) << "phid" << ' '
151  << std::setw(9) << "eta" << ' '
152  << std::setw(10) << "g2l loc0" << ' '
153  << std::setw(10) << "loc1";
154  }
155  std::cout << '\n';
156  static std::atomic<int> kilroy = 0;
157  if (!(kilroy++))
158  {
159  std::cout << "R (mm) and phi (degrees). Estimated local coordinate indicated by \"*\" (from SP), \"o\" (from module center), or \"#\" (globalToLocal(center) failure).";
160  if (extra)
161  std::cout << " Athena/ACTS comparison only shown if different.";
162  std::cout << '\n';
163  }
164  }
165  if (type == 1)
166  {
167  std::cout << std::setw(22) << "GeometryId/meas/stats" << ' '
168  << std::right
169  << std::setw(10) << "loc0" << ' '
170  << std::setw(10) << "loc1" << ' '
171  << std::setw(9) << "Pos R" << ' '
172  << std::setw(9) << "Pos Z" << ' '
173  << std::setw(9) << "phid" << ' '
174  << std::setw(9) << "eta" << ' '
175  << std::setw(9) << "q*pT" << ' '
176  << std::setw(9) << "phid" << ' '
177  << std::setw(9) << "eta" << ' '
178  << std::setw(6) << "TrkLen" << ' '
179  << std::setw(7) << "chi2" << ' '
180  << std::setw(6) << "Flags" << '\n';
181  }
182  }
183 
184  static void
185  printVec3(const Acts::Vector3 &p)
186  {
187  std::cout << std::fixed << ' '
188  << std::setw(9) << std::setprecision(3) << p.head<2>().norm() << ' '
189  << std::setw(9) << std::setprecision(3) << p[2] << ' '
190  << std::setw(9) << std::setprecision(3) << std::atan2(p[1], p[0]) / Acts::UnitConstants::degree << ' '
191  << std::setw(9) << std::setprecision(5) << std::atanh(p[2] / p.norm())
192  << std::defaultfloat << std::setprecision(-1);
193  }
194 
195  static void
196  printVec3(const Acts::Vector3 &p, const Acts::Vector3 &cmp, int precision = 3)
197  {
198  if (((p - cmp).array().abs() >= 0.5 * std::pow(10.0, -precision)).any())
199  {
200  printVec3(p);
201  }
202  else
203  {
204  std::cout << std::setw(30) << "";
205  }
206  }
207 
208  static void
209  printVec2(const Acts::Vector2 &p, const char *estimated = nullptr)
210  {
211  const char e0 = estimated ? estimated[0] : ' ';
212  const char *e1 = estimated ? estimated + 1 : "";
213  std::cout << std::fixed << ' '
214  << std::setw(10) << std::setprecision(4) << p[0] << e0
215  << std::setw(10) << std::setprecision(4) << p[1] << e1
216  << std::defaultfloat << std::setprecision(-1);
217  }
218 
219  static void
220  printVec2(const Acts::Vector2 &p, const Acts::Vector2 &cmp, const char *estimated = nullptr, int precision = 4)
221  {
222  if (((p - cmp).array().abs() >= 0.5 * std::pow(10.0, -precision)).any())
223  {
224  printVec2(p, estimated);
225  }
226  else
227  {
228  std::cout << std::setw(22 + (estimated ? 1 : 0)) << "";
229  }
230  }
231 
232  static void
233  printMeasurement(const Acts::GeometryContext &tgContext,
234  const Acts::Surface *surface,
235  const std::tuple<Acts::Vector2, Amg::Vector2D, int, int> &locData,
236  bool compareMeasurementTransforms = false)
237  {
238  auto &[loc, locTrk, measInd, est] = locData;
239  int flag = est < 0 ? est : 2 * est + measInd;
240  int flagTrk = est < 0 ? est : 2 * est;
241  // indicates coordinate that is estimated: *=from SP, o=from module center, #=globalToLocal(center) failure
242  static const std::map<int, const char *> estimated_flags{{-1, " "},
243  {0, " *"},
244  {1, "* "},
245  {2, " o"},
246  {3, "o "},
247  {4, " #"},
248  {5, "# "}};
249  printVec2(loc, estimated_flags.at(flag));
250 
251  if (surface)
252  {
253  // momentum direction doesn't seem to be needed for measurement surfaces (only LineSurface?)
254  auto glob = surface->localToGlobal(tgContext, loc, Acts::Vector3::Zero());
255  printVec3(glob);
256 
257  if (compareMeasurementTransforms)
258  {
259  const ActsDetectorElement *
260  acts_detector_element = dynamic_cast<const ActsDetectorElement *>(surface->associatedDetectorElement());
261  if (acts_detector_element) {
262  const InDetDD::SiDetectorElement *detElem = dynamic_cast< const InDetDD::SiDetectorElement *>(acts_detector_element->upstreamDetectorElement());
263 
264  // if measInd=1: won't match because comparing x,y and R,phi, but at least not phi,R.
265  // This is still useful for debugging because the next test also fails.
266  printVec2(locTrk, (measInd == 1 ? loc.reverse() : loc), estimated_flags.at(flagTrk));
267 
268  if (detElem)
269  {
270  auto globTrk = detElem->surface().localToGlobal(locTrk);
271  printVec3(globTrk, glob);
272 
273  auto res = surface->globalToLocal(tgContext, globTrk, Acts::Vector3::Zero());
274  if (!res.ok())
275  {
276  std::cout << " ** " << res.error() << " **";
277  }
278  else
279  {
280  printVec2(res.value(), loc);
281  }
282  }
283  }
284  }
285 
286  }
287  std::cout << std::defaultfloat << std::setprecision(-1);
288  }
289 
290  static std::tuple<Acts::Vector2, Amg::Vector2D, int, int>
291  localPositionStrip2D(const Acts::GeometryContext &tgContext,
292  const xAOD::UncalibratedMeasurement &measurement,
293  const Acts::Surface *surface,
294  const xAOD::SpacePoint *sp)
295  {
296  auto *disc = dynamic_cast<const Acts::DiscSurface *>(surface);
297  Acts::Vector2 loc{Acts::Vector2::Zero()};
298  int est = 2; // est = 0 (estimated from SP), 1 (from module center), 2 (globalToLocal(center) failure), -1 (pixel)
299  if (surface)
300  {
301  if (sp)
302  {
303  auto res = surface->globalToLocal(tgContext, sp->globalPosition().cast<double>(), Acts::Vector3::Zero());
304  if (res.ok())
305  {
306  loc = res.value();
307  est = 0;
308  }
309  }
310 
311  if (est != 0)
312  {
313  if (auto *annulus = dynamic_cast<const Acts::AnnulusBounds *>(&surface->bounds()))
314  {
315  loc[0] = 0.5 * (annulus->rMin() + annulus->rMax());
316  est = 1;
317  }
318  else
319  {
320  auto res = surface->globalToLocal(tgContext, surface->center(tgContext), Acts::Vector3::Zero());
321  if (res.ok())
322  {
323  loc = res.value();
324  est = 1;
325  }
326  }
327  }
328  }
329 
330  const int measInd = disc ? 1 : 0;
331  loc[measInd] = measurement.localPosition<1>()[0];
332  if (disc)
333  {
334  Amg::Vector2D locTrk{disc->localPolarToCartesian(loc).reverse()};
335  locTrk[0] = -locTrk[0];
336  return {loc, locTrk, measInd, est};
337  }
338  else
339  {
340  return {loc, loc, measInd, est};
341  }
342  }
343 
344  void
345  TrackStatePrinterTool::printMeasurementAssociatedSpacePoint(const Acts::GeometryContext &tgContext,
346  const xAOD::UncalibratedMeasurement *measurement,
347  const std::vector<small_vector<const xAOD::SpacePoint *>> &measToSp,
348  size_t offset) const {
349  if (!measurement)
350  return;
351 
352  std::cout << std::setw(5) << (measurement->index() + offset) << ' '
353  << std::setw(3) << measurement->numDimensions() << "D ";
354 
355  const Acts::Surface *surface_ptr = m_surfAcc.get(measurement);
356  if (!surface_ptr)
357  {
358  std::cout << std::setw(20 + 22 + 20 + 2) << "** no surface for measurement **";
359  }
360  else
361  {
362  std::cout << std::left;
363  std::cout << std::setw(21) << actsSurfaceName(*surface_ptr) << ' '
364  << std::setw(22) << to_string(surface_ptr->geometryId()) << ' ';
365  std::cout << std::setw(20) << atlasSurfaceName(surface_ptr);
366  std::cout << std::right;
367  }
368 
369  if (measurement->type() == xAOD::UncalibMeasType::PixelClusterType)
370  {
371  const auto loc = measurement->localPosition<2>().cast<double>();
372  printMeasurement(tgContext, surface_ptr, {loc, loc, -1, -1}, m_compareMeasurementTransforms);
373  }
374  else if (measurement->type() == xAOD::UncalibMeasType::StripClusterType)
375  {
376  const small_vector<const xAOD::SpacePoint *> &spvec = measToSp.at(measurement->index());
377  if (spvec.empty())
378  {
379  printMeasurement(tgContext, surface_ptr,
380  localPositionStrip2D(tgContext, *measurement, surface_ptr, nullptr),
381  m_compareMeasurementTransforms);
382  }
383  else
384  {
385  size_t isp = 0;
386  for (auto *sp : spvec)
387  {
388  if (isp++)
389  {
390  std::cout << '\n'
391  << std::left
392  << std::setw(76) << to_string("** Spacepoint ", isp, " **")
393  << std::right;
394  }
395  printMeasurement(tgContext, surface_ptr,
396  localPositionStrip2D(tgContext, *measurement, surface_ptr, sp),
397  m_compareMeasurementTransforms);
398  }
399  }
400  }
401  else if (measurement->type() == xAOD::UncalibMeasType::HGTDClusterType) {
402  const auto loc3D = measurement->localPosition<3>().cast<double>();
403  const std::tuple<Acts::Vector2, Amg::Vector2D, int, int> locTup = {Acts::Vector2{loc3D.head<2>()}, Amg::Vector2D{loc3D.head<2>()}, -1, -1};
404  printMeasurement(tgContext, surface_ptr, locTup, m_compareMeasurementTransforms);
405  }
406  std::cout << '\n';
407  }
408 
409  void TrackStatePrinterTool::printParameters(const Acts::Surface &surface,
410  const Acts::GeometryContext &tgContext,
411  const Acts::BoundVector &bound)
412  {
413  auto p = Acts::transformBoundToFreeParameters(surface, tgContext, bound);
414  std::cout << std::fixed
415  << std::setw(10) << std::setprecision(4) << bound[Acts::eBoundLoc0] << ' '
416  << std::setw(10) << std::setprecision(4) << bound[Acts::eBoundLoc1] << ' '
417  << std::setw(9) << std::setprecision(3) << p.segment<2>(Acts::eFreePos0).norm() << ' '
418  << std::setw(9) << std::setprecision(3) << p[Acts::eFreePos2] << ' '
419  << std::setw(9) << std::setprecision(3) << std::atan2(p[Acts::eFreePos1], p[Acts::eFreePos0]) / Acts::UnitConstants::degree << ' '
420  << std::setw(9) << std::setprecision(5) << std::atanh(p[Acts::eFreePos2] / p.segment<3>(Acts::eFreePos0).norm()) << ' '
421  << std::setw(9) << std::setprecision(3) << p.segment<2>(Acts::eFreeDir0).norm() / p[Acts::eFreeQOverP] << ' '
422  << std::setw(9) << std::setprecision(3) << std::atan2(p[Acts::eFreeDir1], p[Acts::eFreeDir0]) / Acts::UnitConstants::degree << ' '
423  << std::setw(9) << std::setprecision(5) << std::atanh(p[Acts::eFreeDir2])
424  << std::defaultfloat << std::setprecision(-1);
425  }
426 
430  StatusCode TrackStatePrinterTool::initialize()
431  {
432  ATH_MSG_DEBUG("Initializing " << name() << "...");
433  ATH_MSG_DEBUG("Properties Summary:");
434  ATH_MSG_DEBUG(" " << m_compareMeasurementTransforms);
435  ATH_MSG_DEBUG(" " << m_printFilteredStates);
436 
437  ATH_CHECK(m_trackingGeometryTool.retrieve());
438  m_surfAcc = detail::xAODUncalibMeasSurfAcc{m_trackingGeometryTool.get()};
439  ATH_CHECK(m_spacePointKey.initialize());
440 
441  return StatusCode::SUCCESS;
442  }
443 
444  void
445  TrackStatePrinterTool::printSeed(const Acts::GeometryContext &tgContext,
446  const ActsTrk::Seed &seed,
447  const Acts::BoundTrackParameters &initialParameters,
448  const detail::MeasurementIndex &measurementIndexer,
449  unsigned int iseed,
450  bool isKF) const
451  {
452  if (!isKF)
453  printHeader(1);
454 
455  std::ostringstream os;
456  size_t nos = 0;
457  for (const auto *sp : seed.sp())
458  {
459  size_t nom = 0;
460  for (const auto *el : sp->measurements())
461  {
462  if (nom > 0)
463  os << '+';
464  else if (nos > 0)
465  os << ',';
466  ++nos;
467  ++nom;
468  os << measurementIndexer.index(*el);
469  }
470  }
471 
472  std::cout << std::setw(5) << iseed << ' '
473  << std::left
474  << std::setw(4) << (!isKF ? "seed" : "KF") << ' '
475  << std::setw(21) << actsSurfaceName(initialParameters.referenceSurface()) << ' '
476  << std::setw(22) << to_string(os.str()) << ' '
477  << std::right;
478  printParameters(initialParameters.referenceSurface(), tgContext, initialParameters.parameters());
479  std::cout << '\n'
480  << std::flush;
481  }
482 
483  void
484  TrackStatePrinterTool::printMeasurements(const EventContext &ctx,
485  const std::vector<const xAOD::UncalibratedMeasurementContainer *> &clusterContainers,
486  const std::vector<size_t> &offsets) const {
487 
488  Acts::GeometryContext tgContext = m_trackingGeometryTool->getGeometryContext(ctx).context();
489 
490  auto measToSp = addSpacePoints(ctx, clusterContainers, offsets);
491 
492  ATH_MSG_INFO("CKF input measurements:");
493  printHeader(0, m_compareMeasurementTransforms);
494 
495  for (std::size_t icontainer = 0; icontainer < clusterContainers.size(); ++icontainer)
496  {
497  for (const auto *measurement : *clusterContainers[icontainer])
498  {
499  printMeasurementAssociatedSpacePoint(tgContext, measurement,
500  measToSp[icontainer], offsets[icontainer]);
501  }
502  }
503  std::cout << std::flush;
504  }
505 
506  std::vector<std::vector<TrackStatePrinterTool::small_vector<const xAOD::SpacePoint *>>>
507  TrackStatePrinterTool::addSpacePoints(const EventContext &ctx,
508  const std::vector<const xAOD::UncalibratedMeasurementContainer *> &clusterContainers,
509  const std::vector<size_t> &offsets) const
510  {
511  std::vector<std::vector<TrackStatePrinterTool::small_vector<const xAOD::SpacePoint *>>> measToSp{clusterContainers.size()};
512  for (std::size_t icontainer = 0; icontainer < clusterContainers.size(); ++icontainer)
513  {
514  measToSp[icontainer].resize(clusterContainers[icontainer]->size());
515  }
516 
517  for (auto &spacePointKey : m_spacePointKey)
518  {
519  ATH_MSG_DEBUG("Retrieving from input SpacePoint collection '" << spacePointKey.key() << "' ...");
520  SG::ReadHandle<xAOD::SpacePointContainer> handle = SG::makeHandle(spacePointKey, ctx);
521  if (!handle.isValid())
522  {
523  ATH_MSG_ERROR("Error retrieving from input SpacePoint collection '" << spacePointKey.key() << "'");
524  continue;
525  }
526  ATH_MSG_DEBUG(" \\__ " << handle->size() << " elements!");
527  for (const auto *sp : *handle)
528  {
529  for (const xAOD::UncalibratedMeasurement *meas : sp->measurements())
530  {
531  if (!meas)
532  continue;
533  for (std::size_t icontainer = 0; icontainer < clusterContainers.size(); ++icontainer)
534  {
535  // This measurement may well be in a different clusterContainer. Skip all but the one we are interested in.
536  if (!(meas && meas->index() < clusterContainers[icontainer]->size() && meas == clusterContainers[icontainer]->at(meas->index())))
537  continue;
538  small_vector<const xAOD::SpacePoint *> &measSp = measToSp[icontainer].at(meas->index());
539  if (!measSp.empty())
540  {
541  ATH_MSG_INFO("Cluster "
542  << (meas->index() + offsets[icontainer])
543  << " used by SpacePoints at ("
544  << sp->globalPosition()[0] << ',' << sp->globalPosition()[1] << ',' << sp->globalPosition()[2]
545  << ") and ("
546  << measSp[0]->globalPosition()[0] << ',' << measSp[0]->globalPosition()[1] << ',' << measSp[0]->globalPosition()[2]
547  << ')');
548  }
549  measSp.push_back(sp);
550  }
551  }
552  }
553  }
554  return measToSp;
555  }
556 
557 } // namespace ActsTrk
python.EI_Lib.cmp
def cmp(x, y)
Definition: EI_Lib.py:6
ActsTrk::detail::xAODUncalibMeasSurfAcc::get
const Acts::Surface * get(const xAOD::UncalibratedMeasurement *meas) const
Operator.
Definition: xAODUncalibMeasSurfAcc.cxx:19
ActsTrk::TrackStatePrinterTool::addSpacePoints
std::vector< std::vector< small_vector< const xAOD::SpacePoint * > > > addSpacePoints(const EventContext &ctx, const std::vector< const xAOD::UncalibratedMeasurementContainer * > &clusterContainers, const std::vector< size_t > &offset) const
Definition: TrackStatePrinterTool.cxx:507
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
xAOD::UncalibMeasType::HGTDClusterType
@ HGTDClusterType
TrackParameters.h
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
FullCPAlgorithmsTest_eljob.flush
flush
Definition: FullCPAlgorithmsTest_eljob.py:194
perfmonmt-printer.printHeader
def printHeader()
Definition: perfmonmt-printer.py:10
egammaEnergyPositionAllSamples::e1
double e1(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 1st sampling
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
SG::ReadHandle
Definition: StoreGate/StoreGate/ReadHandle.h:67
xAOD::UncalibMeasType::StripClusterType
@ StripClusterType
ActsTrk::TrackStatePrinterTool::printMeasurements
void printMeasurements(const EventContext &ctx, const std::vector< const xAOD::UncalibratedMeasurementContainer * > &clusterContainers, const std::vector< size_t > &offsets) const
Definition: TrackStatePrinterTool.cxx:484
skel.it
it
Definition: skel.GENtoEVGEN.py:407
xAOD::SpacePoint_v1::globalPosition
ConstVectorMap globalPosition() const
Returns the global position of the pixel cluster.
Definition: SpacePoint_v1.cxx:25
ActsDetectorElement::upstreamDetectorElement
const GeoVDetectorElement * upstreamDetectorElement() const
Returns the underllying GeoModel detectorelement that this one is based on.
Definition: ActsDetectorElement.cxx:286
InDetDD::SolidStateDetectorElementBase::surface
Trk::Surface & surface()
Element Surface.
xAOD::SpacePoint_v1
Definition: SpacePoint_v1.h:29
ActsTrk::TrackStatePrinterTool::m_compareMeasurementTransforms
Gaudi::Property< bool > m_compareMeasurementTransforms
Definition: TrackStatePrinterTool.h:98
ActsTrk::detail::MeasurementIndex
Definition: MeasurementIndex.h:16
ActsTrk::TrackStatePrinterTool::printSeed
void printSeed(const Acts::GeometryContext &tgContext, const ActsTrk::Seed &seed, const Acts::BoundTrackParameters &initialParameters, const detail::MeasurementIndex &measurementIndexer, unsigned int iseed, bool isKF) const
Definition: TrackStatePrinterTool.cxx:445
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
InDetDD::SolidStateDetectorElementBase::getIdHelper
const AtlasDetectorID * getIdHelper() const
Returns the id helper (inline)
SG::makeHandle
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
Definition: ReadCondHandle.h:270
ActsTrk::TrackStatePrinterTool::printParameters
static void printParameters(const Acts::Surface &surface, const Acts::GeometryContext &tgContext, const Acts::BoundVector &bound)
Definition: TrackStatePrinterTool.cxx:409
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
xAOD::UncalibratedMeasurement_v1
Definition: UncalibratedMeasurement_v1.h:13
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
xAOD::UncalibratedMeasurement_v1::type
virtual xAOD::UncalibMeasType type() const =0
Returns the type of the measurement type as a simple enumeration.
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
HGTD_DetectorElement.h
master.flag
bool flag
Definition: master.py:29
UncalibratedMeasurementContainer.h
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:11
TrackStatePrinterTool.h
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
python.getProblemFolderFromLogs.el
dictionary el
Definition: getProblemFolderFromLogs.py:48
hist_file_dump.f
f
Definition: hist_file_dump.py:140
ActsTrk::TrackStatePrinterTool::printMeasurementAssociatedSpacePoint
void printMeasurementAssociatedSpacePoint(const Acts::GeometryContext &tgContext, const xAOD::UncalibratedMeasurement *measurement, const std::vector< small_vector< const xAOD::SpacePoint * >> &measToSp, size_t offset) const
Definition: TrackStatePrinterTool.cxx:345
ActsTrk::TrackStatePrinterTool::m_spacePointKey
SG::ReadHandleKeyArray< xAOD::SpacePointContainer > m_spacePointKey
Definition: TrackStatePrinterTool.h:90
ActsDetectorElement
Definition: ActsDetectorElement.h:44
xAOD::SpacePoint_v1::measurements
const std::vector< const xAOD::UncalibratedMeasurement * > & measurements() const
Returns the index of the measurements.
ActsDetectorElement.h
SG::AuxElement::index
size_t index() const
Return the index of this element within its container.
xAOD::UncalibratedMeasurement_v1::localPosition
ConstVectorMap< N > localPosition() const
Returns the local position of the measurement.
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
SG::ReadHandle::isValid
virtual bool isValid() override final
Can the handle be successfully dereferenced?
xAOD::UncalibratedMeasurement_v1::numDimensions
virtual unsigned int numDimensions() const =0
Returns the number of dimensions of the measurement.
lumiFormat.array
array
Definition: lumiFormat.py:91
python.handimod.extra
int extra
Definition: handimod.py:521
ActsTrk::TrackStatePrinterTool::m_trackingGeometryTool
PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool
Definition: TrackStatePrinterTool.h:93
ActsTrk::TrackStatePrinterTool::m_printFilteredStates
Gaudi::Property< bool > m_printFilteredStates
Definition: TrackStatePrinterTool.h:99
PlotSFuncertainty.nom
nom
Definition: PlotSFuncertainty.py:141
ActsTrk::TrackStatePrinterTool::initialize
virtual StatusCode initialize() override
=========================================================================
Definition: TrackStatePrinterTool.cxx:430
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
plotBeamSpotMon.b
b
Definition: plotBeamSpotMon.py:76
InDetDD::SiDetectorElement
Definition: SiDetectorElement.h:109
SurfaceOfMeasurementUtil.h
SiDetectorElement.h
ActsTrk::TrackStatePrinterTool::m_surfAcc
detail::xAODUncalibMeasSurfAcc m_surfAcc
Definition: TrackStatePrinterTool.h:95
ActsTrk::Seed
Definition: SeedContainer.h:75
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
ActsTrk
The AlignStoreProviderAlg loads the rigid alignment corrections and pipes them through the readout ge...
Definition: MdtCalibInput.h:31
ActsTrk::detail::MeasurementIndex::index
std::size_t index(const xAOD::UncalibratedMeasurement &hit) const
ActsTrk::detail::xAODUncalibMeasSurfAcc
Helper class to access the Acts::surface associated with an Uncalibrated xAOD measurement.
Definition: xAODUncalibMeasSurfAcc.h:22
egammaEnergyPositionAllSamples::e0
double e0(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in pre-sampler
Logger.h
pow
constexpr int pow(int base, int exp) noexcept
Definition: ap_fixedTest.cxx:15
ActsTrk::TrackStatePrinterTool::small_vector
boost::container::small_vector< T, N_SP_PER_MEAS > small_vector
Definition: TrackStatePrinterTool.h:104
ActsTrk::TrackStatePrinterTool::trackStateName
static std::string trackStateName(Acts::ConstTrackStateType trackStateType)
========================================================================= file-local static functions...
Definition: TrackStatePrinterTool.cxx:42
python.compressB64.c
def c
Definition: compressB64.py:93
DataVector::size
size_type size() const noexcept
Returns the number of elements in the collection.
TrackContainer.h
InDetDD::SolidStateDetectorElementBase::identify
virtual Identifier identify() const override final
identifier of this detector element (inline)
python.SystemOfUnits.degree
tuple degree
Definition: SystemOfUnits.py:121
Trk::Surface::localToGlobal
virtual void localToGlobal(const Amg::Vector2D &locp, const Amg::Vector3D &mom, Amg::Vector3D &glob) const =0
Specified by each surface type: LocalToGlobal method without dynamic memory allocation.
xAOD::UncalibMeasType::PixelClusterType
@ PixelClusterType
generate::Zero
void Zero(TH1D *hin)
Definition: generate.cxx:32
ActsTrk::TrackStatePrinterTool::actsSurfaceName
static std::string actsSurfaceName(const Acts::Surface &surface)
Definition: TrackStatePrinterTool.cxx:62
Generated on Mon Nov 3 2025 21:21:17 for ATLAS Offline Software by   doxygen 1.8.18