ATLAS Offline Software
ResidualPullCalculator.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // ResidualPullCalculator.cxx
7 // Source file for class ResidualPullCalculator
9 // (c) ATLAS Detector software
11 // Sebastian.Fleischmann@cern.ch
13 
14 #include "ResidualPullCalculator.h"
15 
16 #include "AtlasDetDescr/AtlasDetectorID.h"
17 #include "TrkEventPrimitives/LocalParameters.h"
18 #include "TrkEventUtils/MeasurementTypeID.h"
19 #include "TrkParameters/TrackParameters.h"
20 #include "TrkRIO_OnTrack/RIO_OnTrack.h"
21 #include "TrkMeasurementBase/MeasurementBase.h"
22 #include "EventPrimitives/EventPrimitives.h"
23 #include "TrkTrack/AlignmentEffectsOnTrack.h"
24 #include <Eigen/Geometry>
25 #include <algorithm>
26 #include <cmath>
27 
31 Trk::ResidualPullCalculator::ResidualPullCalculator(const std::string& type, const std::string& name, const IInterface* parent)
32  : AthAlgTool(type,name,parent),
33 m_SCTresidualTool("InDet::SCT_ResidualPullCalculator/SCT_ResidualPullCalculator"),
34 m_RPCresidualTool("Muon::RPC_ResidualPullCalculator/RPC_ResidualPullCalculator"),
35 m_TGCresidualTool("Muon::TGC_ResidualPullCalculator/TGC_ResidualPullCalculator"),
36 m_idHelper(nullptr) {
37  declareInterface<IResidualPullCalculator>(this);
38  declareProperty("ResidualPullCalculatorForSCT", m_SCTresidualTool, "Tool to calculate residuals and pulls in the SCT (including module rotation)");
39  declareProperty("ResidualPullCalculatorForRPC", m_RPCresidualTool, "Tool to calculate residuals and pulls in the RPC (including phi/eta detection)");
40  declareProperty("ResidualPullCalculatorForTGC", m_TGCresidualTool, "Tool to calculate residuals and pulls in the SCT (including module rotation)");
41 
42 }
43 
47 StatusCode Trk::ResidualPullCalculator::initialize() {
48 
49  // ---------------------------------------
50  //Set up ATLAS ID helper to be able to identify the RIO's det-subsystem.
51  ATH_CHECK(detStore()->retrieve(m_idHelper, "AtlasID"));
52  // ----------------------------------
53  // get the SCT residual/pull calculator
54  if ( ! m_SCTresidualTool.empty() ) {
55  ATH_CHECK( m_SCTresidualTool.retrieve());
56  } else {
57  ATH_MSG_DEBUG ("No residual calculator for SCT given, will ignore SCT measurements!");
58  }
59 
60  // ----------------------------------
61  // get the RPC residual/pull calculator
62  if ( ! m_RPCresidualTool.empty() ) {
63  ATH_CHECK( m_RPCresidualTool.retrieve());
64  } else {
65  ATH_MSG_DEBUG ("No residual calculator for RPC given, will ignore RPC measurements!");
66  }
67 
68  // ----------------------------------
69  // get the TGC residual/pull calculator
70  if ( ! m_TGCresidualTool.empty() ) {
71  ATH_CHECK( m_TGCresidualTool.retrieve());
72  } else {
73  ATH_MSG_DEBUG ("No residual calculator for TGC given, will ignore TGC measurements!");
74  }
75 
76  return StatusCode::SUCCESS;
77 }
78 
79 StatusCode Trk::ResidualPullCalculator::finalize() {
80  ATH_MSG_DEBUG ("starting finalize() in " << name());
81  return StatusCode::SUCCESS;
82 }
83 
85 // calc residuals with determination of detector/MBase type
87 std::array<double,5>
88 Trk::ResidualPullCalculator::residuals(
89  const Trk::MeasurementBase* measurement,
90  const Trk::TrackParameters* trkPar,
91  const Trk::ResidualPull::ResidualType resType,
92  const Trk::TrackState::MeasurementType detType) const {
93 
94  std::array<double,5> residuals{-999.,-999.,-999.,-999.,-999};
95  Trk::TrackState::MeasurementType measType = detType;
96  if (detType == Trk::TrackState::unidentified) {
97  Trk::MeasurementTypeID helper = MeasurementTypeID(m_idHelper);
98  measType = helper.defineType(measurement);
99  }
100  switch(measType) {
101  case Trk::TrackState::Pixel:
102  ATH_MSG_VERBOSE ("Pixel dim calculation ");
103  // calc residual and pull for the second coordinate, first coord postponed to 1-dim case
104  residuals[Trk::loc1] = measurement->localParameters()[Trk::loc1] - trkPar->parameters()[Trk::loc1];
105  residuals[Trk::loc2] = measurement->localParameters()[Trk::loc2] - trkPar->parameters()[Trk::loc2];
106  break;
107  case Trk::TrackState::TRT:
108  case Trk::TrackState::MDT:
109  case Trk::TrackState::CSC:
110  case Trk::TrackState::MM:
111  ATH_MSG_VERBOSE ("One dim calculation ");
112  // 1-dim measurement
113  // calc residual and pull for the first coordinate
114  residuals[Trk::loc1] = measurement->localParameters()[Trk::loc1] - trkPar->parameters()[Trk::loc1];
115  break;
116  case Trk::TrackState::STGC:
117  ATH_MSG_VERBOSE ("One dim calculation ");
118  // 1-dim measurement
119  // calc residual and pull for the first coordinate
120  if( measurement->localParameters().contains(Trk::loc1) )
121  residuals[Trk::loc1] = measurement->localParameters()[Trk::loc1] - trkPar->parameters()[Trk::loc1];
122  else
123  residuals[Trk::loc2] = measurement->localParameters()[Trk::loc2] - trkPar->parameters()[Trk::loc2];
124  break;
125  case Trk::TrackState::SCT:
126  // special case, has to be handed down to the SCT tool
127  if ( ! m_SCTresidualTool.empty() ) {
128  ATH_MSG_VERBOSE ("Calling SCT tool ");
129  return m_SCTresidualTool->residuals(measurement, trkPar, resType, Trk::TrackState::SCT);
130  } else {
131  ATH_MSG_WARNING ("No SCT ResidualPullCalculator given, cannot calculate residual and pull for SCT measurement!");
132  }
133  break;
134  case Trk::TrackState::RPC:
135  // special case, has to be handed down to the RPC tool
136  if ( ! m_RPCresidualTool.empty() ) {
137  ATH_MSG_VERBOSE ("Calling RPC tool ");
138  return m_RPCresidualTool->residuals(measurement, trkPar, resType, Trk::TrackState::RPC);
139  } else {
140  ATH_MSG_WARNING ("No RPC ResidualPullCalculator given, cannot calculate residual and pull for RPC measurement!");
141  }
142  break;
143  case Trk::TrackState::TGC:
144  // special case, has to be handed down to the TGC tool
145  if ( ! m_TGCresidualTool.empty() ) {
146  ATH_MSG_VERBOSE ("Calling TGC tool ");
147  return m_TGCresidualTool->residuals(measurement, trkPar, resType, Trk::TrackState::TGC);
148  } else {
149  ATH_MSG_WARNING ("No TGC ResidualPullCalculator given, cannot calculate residual and pull for TGC measurement!");
150  }
151  break;
152  case Trk::TrackState::Segment:
153  case Trk::TrackState::Pseudo:
154  case Trk::TrackState::Vertex:
155  case Trk::TrackState::SpacePoint:
156  default:
157  ATH_MSG_VERBOSE ("Bit-key calculation ");
158  ParamDefsAccessor PDA;
159 
160  // PMs, Segments etc: use LocalParameters bit-key scheme
161  for (unsigned int i=0; i<5; ++i) {
162  Trk::ParamDefs iPar = PDA.pardef[i];
163  if (measurement->localParameters().contains(iPar)) {
164  residuals[i] = measurement->localParameters()[iPar]
165  - trkPar->parameters()[iPar];
166  }
167  }
168  break;
169  }
170  return residuals;
171 
172 }
173 
175 // calc residual and pull with determination of detector/MBase type
177 std::optional<Trk::ResidualPull> Trk::ResidualPullCalculator::residualPull(
178  const Trk::MeasurementBase* measurement,
179  const Trk::TrackParameters* trkPar,
180  const Trk::ResidualPull::ResidualType resType,
181  const Trk::TrackState::MeasurementType detType) const {
182 
183  if (!measurement || !trkPar) return std::nullopt;
184 
185  // if no covariance for the track parameters is given the pull calculation is not valid
186  bool pullIsValid = trkPar->covariance();
187 
188  Trk::TrackState::MeasurementType measType = detType;
189  if (detType == Trk::TrackState::unidentified) {
190  Trk::MeasurementTypeID helper = MeasurementTypeID(m_idHelper);
191  measType = helper.defineType(measurement);
192  }
193  unsigned int dimOfLocPars = (unsigned int)measurement->localParameters().dimension();
194  std::vector<double> residual(dimOfLocPars);
195  std::vector<double> pull(dimOfLocPars);
196 
197  // has to live here as it does not compile if code is switch statement
198  ParamDefsAccessor PDA;
199  unsigned int iColRow=0;
200 
201  ATH_MSG_VERBOSE ("Calculating residual for type " << measType << " dimension " << dimOfLocPars);
202 
203  // do the calculations for the different detector types
204  switch(measType) {
205  case Trk::TrackState::Pixel:
206  ATH_MSG_VERBOSE ("Pixel dim calculation ");
207  // calc residual and pull for the second coordinate, first coord postponed to 1-dim case
208  residual[Trk::loc2] = measurement->localParameters()[Trk::loc2] - trkPar->parameters()[Trk::loc2];
209  if (pullIsValid) {
210  pull[Trk::loc2] = calcPull(residual[Trk::loc2],
211  measurement->localCovariance()(Trk::loc2,Trk::loc2),
212  (*trkPar->covariance())(Trk::loc2,Trk::loc2),
213  resType);
214  } else {
215  pull[Trk::loc2] = calcPull(residual[Trk::loc2],
216  measurement->localCovariance()(Trk::loc2,Trk::loc2),
217  0,
218  resType);
219  }
220  // do not break here, but also fill the first coordinate...
221  /* FALLTHROUGH */
222  case Trk::TrackState::TRT:
223  case Trk::TrackState::MDT:
224  case Trk::TrackState::CSC:
225  case Trk::TrackState::STGC:
226  case Trk::TrackState::MM:
227  ATH_MSG_VERBOSE ("One dim calculation ");
228  // 1-dim measurement
229  // calc residual and pull for the first coordinate
230  residual[Trk::loc1] = measurement->localParameters()[Trk::loc1] - trkPar->parameters()[Trk::loc1];
231  if (pullIsValid) {
232  pull[Trk::loc1] = calcPull(residual[Trk::loc1],
233  measurement->localCovariance()(Trk::loc1,Trk::loc1),
234  (*trkPar->covariance())(Trk::loc1,Trk::loc1),
235  resType);
236  } else {
237  pull[Trk::loc1] = calcPull(residual[Trk::loc1],
238  measurement->localCovariance()(Trk::loc1,Trk::loc1),
239  0,
240  resType);
241  }
242  break;
243  case Trk::TrackState::SCT:
244  // special case, has to be handed down to the SCT tool
245  if ( ! m_SCTresidualTool.empty() ) {
246  ATH_MSG_VERBOSE ("Calling SCT tool ");
247  return m_SCTresidualTool->residualPull(measurement, trkPar, resType, Trk::TrackState::SCT);
248  } else {
249  ATH_MSG_WARNING ("No SCT ResidualPullCalculator given, cannot calculate residual and pull for SCT measurement!");
250  return std::nullopt;
251  }
252  break;
253  case Trk::TrackState::RPC:
254  // special case, has to be handed down to the RPC tool
255  if ( ! m_RPCresidualTool.empty() ) {
256  ATH_MSG_VERBOSE ("Calling RPC tool ");
257  return m_RPCresidualTool->residualPull(measurement, trkPar, resType, Trk::TrackState::RPC);
258  } else {
259  ATH_MSG_WARNING ("No RPC ResidualPullCalculator given, cannot calculate residual and pull for RPC measurement!");
260  return std::nullopt;
261  }
262  break;
263  case Trk::TrackState::TGC:
264  // special case, has to be handed down to the TGC tool
265  if ( ! m_TGCresidualTool.empty() ) {
266  ATH_MSG_VERBOSE ("Calling TGC tool ");
267  return m_TGCresidualTool->residualPull(measurement, trkPar, resType, Trk::TrackState::TGC);
268  } else {
269  ATH_MSG_WARNING ("No TGC ResidualPullCalculator given, cannot calculate residual and pull for TGC measurement!");
270  return std::nullopt;
271  }
272  break;
273  case Trk::TrackState::Segment:
274  case Trk::TrackState::Pseudo:
275  case Trk::TrackState::Vertex:
276  case Trk::TrackState::SpacePoint:
277  ATH_MSG_VERBOSE ("Bit-key calculation ");
278 
279  // PMs, Segments etc: use LocalParameters bit-key scheme
280  for (unsigned int i=0; i<5; ++i) {
281  Trk::ParamDefs iPar = PDA.pardef[i];
282  if (measurement->localParameters().contains(iPar)) {
283  residual[iColRow] = measurement->localParameters()[iPar]
284  - trkPar->parameters()[iPar];
285  if (pullIsValid)
286  pull[iColRow] = calcPull(residual[iColRow],
287  measurement->localCovariance()(PDA.pardef[iColRow],PDA.pardef[iColRow]),
288  (*trkPar->covariance())(PDA.pardef[iColRow],PDA.pardef[iColRow]),
289  resType);
290  ++iColRow;
291  }
292  }
293  break;
294  default:
295  ATH_MSG_VERBOSE ("Default calculation ");
296  // use HEPvector to calculate the residual
297  // r = m - H.p
298  Amg::VectorX HEPresidual = measurement->localParameters() - (measurement->localParameters().expansionMatrix() * trkPar->parameters());
299  residual.resize(HEPresidual.rows());
300  pull.resize(HEPresidual.rows());
301  for (int i = 0; i < HEPresidual.rows(); i++) {
302  residual[i] = HEPresidual[i];
303  }
304 
305  }
306  return std::make_optional<Trk::ResidualPull>(
307  std::move(residual), std::move(pull), pullIsValid, resType,
308  measurement->localParameters().parameterKey());
309 }
310 
312 // calc residual and pull with determination of detector/MBase type
314 std::optional<Trk::ResidualPull> Trk::ResidualPullCalculator::residualPull(
315  const Trk::MeasurementBase* measurement,
316  const Trk::TrackParameters* originalTrkPar,
317  const Trk::ResidualPull::ResidualType resType,
318  const Trk::TrackState::MeasurementType detType,
319  const std::vector<const Trk::AlignmentEffectsOnTrack*>& aeots) const {
320 
321  //bool veryVerbose = true;
322 
323  Trk::TrackState::MeasurementType measType = detType;
324  if (detType == Trk::TrackState::unidentified) {
325  Trk::MeasurementTypeID helper = MeasurementTypeID(m_idHelper);
326  measType = helper.defineType(measurement);
327  }
328 
329  // time to shift the parameter - do this rather than the measurement so we can call the original method.
330  Amg::Vector3D loc3Dframe;
331  Amg::Vector2D localPos;
332  Amg::Vector2D localPosSimple;
333  Amg::Vector3D globalPos;
334  AmgVector(5) parameters;
335 
336  std::unique_ptr<Trk::TrackParameters> trkPar = originalTrkPar->uniqueClone();
337  parameters = trkPar->parameters();
338 
339  ATH_MSG_VERBOSE( " ResidualPullCalculator aeots size " << aeots.size() << " parameters[0] " << parameters[0] );
340  double residual = measurement->localParameters()[Trk::loc1] - trkPar->parameters()[Trk::loc1];
341  ATH_MSG_VERBOSE(" parameters[0] "
342  << parameters[0] << " trkPar->parameters()[Trk::loc1] "
343  << trkPar->parameters()[Trk::loc1]
344  << " measurement->localParameters()[Trk::loc1] "
345  << measurement->localParameters()[Trk::loc1] << " resi "
346  << residual);
347 
348  localPos[0] = parameters[0];
349  localPosSimple[0] = parameters[0];
350  for ( const auto & aeot : aeots ){
351  ATH_MSG_VERBOSE( " ResidualPullCalculator aeots deltaTranslation " << aeot->deltaTranslation() << " angle " << aeot->deltaAngle());
352 
353  Trk::DistanceSolution solution = aeot->associatedSurface().straightLineDistanceEstimate(originalTrkPar->position(),originalTrkPar->momentum().unit());
354  double distance = solution.currentDistance(true);
355 // calculate sign of distance
356  Amg::Vector3D displacementVector =
357  Amg::Vector3D(originalTrkPar->position().x() -
358  aeot->associatedSurface().center().x(),
359  originalTrkPar->position().y() -
360  aeot->associatedSurface().center().y(),
361  originalTrkPar->position().z() -
362  aeot->associatedSurface().center().z());
363  if (displacementVector.dot(originalTrkPar->momentum().unit()) < 0)
364  distance = -distance;
365 
366  if(measType == Trk::TrackState::MDT) {
367 // MDT
368  double distanceX = distance*originalTrkPar->momentum().unit().x();
369  double distanceY = distance*originalTrkPar->momentum().unit().y();
370  const double originalPhi=originalTrkPar->momentum().phi();
371  double distanceR = std::cos(originalPhi)*distanceX + std::sin(originalPhi)*distanceY; //< Is this quicker than hypotenuse?
372  ATH_MSG_VERBOSE(" originalTrkPar->position() x "
373  << originalTrkPar->position().x() << " y "
374  << originalTrkPar->position().y() << " z "
375  << originalTrkPar->position().z());
376  ATH_MSG_VERBOSE(" aeot->associatedSurface().center() x "
377  << aeot->associatedSurface().center().x() << " y "
378  << aeot->associatedSurface().center().y() << " z "
379  << aeot->associatedSurface().center().z());
380 
381  // use drift (circle) derivatives as in TrkiPatFitterUtils
382 
383  Amg::Vector3D sensorDirection = Amg::Vector3D(measurement->associatedSurface().transform().rotation().col(2));
384  Amg::Vector3D driftDirection = Amg::Vector3D(sensorDirection.cross(originalTrkPar->momentum().unit()));
385  driftDirection = driftDirection.unit();
386  ATH_MSG_VERBOSE( " cos(theta) " << std::cos(originalTrkPar->momentum().theta()) << " phi " << originalPhi );
387  ATH_MSG_VERBOSE( " sensorDirection x " << sensorDirection.x() << " y " << sensorDirection.y() << " z " << sensorDirection.z() );
388  ATH_MSG_VERBOSE( " driftDirection x " << driftDirection.x() << " y " << driftDirection.y() << " z " << driftDirection.z() );
389 
390 
391 // Barrel
392  double projection = driftDirection.z();
393 // dz because of a dhteta change: factor = dz/dtheta
394  const double originalTheta=originalTrkPar->momentum().theta();
395  const double sinOriginalTheta=std::sin(originalTheta);
396  double factor = (distanceR/sinOriginalTheta)/sinOriginalTheta; //preserve calc. order
397  const Surface& surface = aeot->associatedSurface();
398  ATH_MSG_VERBOSE( " fabs(surface.normal().z()) " << std::fabs(surface.normal().z()) );
399  if(std::fabs(surface.normal().z()) > 0.5) {
400 // endcap
401  projection = (driftDirection.x()*surface.center().x() + driftDirection.y()*surface.center().y()) /
402  surface.center().perp();
403 // dr because of a dhteta change : factor = dR/dtheta
404  factor = -(distanceR/std::sin(originalTheta))/(std::cos(originalTheta)); //preserve calc. order
405  ATH_MSG_VERBOSE( " distance " << distance << " Endcap projection " << projection << " factor " << factor );
406  } else {
407  ATH_MSG_VERBOSE( " distance " << distance << " Barrel projection " << projection << " factor " << factor );
408  }
409 
410 
411  localPos[0] += projection*aeot->deltaTranslation() - projection*factor*aeot->deltaAngle(); // Shift in precision direction.
412 
413  ATH_MSG_VERBOSE( " MDT old localPos " << parameters[0] << " new localPos " << localPos[0] );
414 
415  } else {
416 
417 // CSC or MM clusters
418 
419  double projection = aeot->associatedSurface().normal().dot(originalTrkPar->momentum().unit());
420  localPos[0] += aeot->deltaTranslation()*projection + distance*aeot->deltaAngle();
421 
422  ATH_MSG_VERBOSE(" CSC old localPos "
423  << parameters[0] << " distance " << distance
424  << " proj " << projection << " new localPos "
425  << localPos[0] << " simple " << localPosSimple[0]);
426  }
427  }
428 
429  parameters[0] = localPos[0];
430  residual = measurement->localParameters()[Trk::loc1] - parameters[0];
431  ATH_MSG_VERBOSE( " new residual after end aeots loop " << residual );
432 
433  // Set parameters to the new values;
434  const AmgSymMatrix(5)* originalCov = trkPar->covariance();
435  if(originalCov) {
436  trkPar->updateParameters(parameters, AmgSymMatrix(5)( *originalCov ) );
437  } else {
438  trkPar->updateParameters(parameters);
439  }
440 
441  // Now call original method.
442  return residualPull(measurement, trkPar.get(), resType, detType );
443 }
444 
445 
449 double Trk::ResidualPullCalculator::calcPull(
450  const double residual,
451  const double locMesCov,
452  const double locTrkCov,
453  const Trk::ResidualPull::ResidualType& resType ) const {
454 
455  double CovarianceSum = 0.0;
456  if (resType == Trk::ResidualPull::Unbiased) {
457  CovarianceSum = locMesCov + locTrkCov;
458  } else if (resType == Trk::ResidualPull::Biased) {
459  CovarianceSum = locMesCov - locTrkCov;
460  } else CovarianceSum = locMesCov;
461 
462  if (CovarianceSum <= 0.0) {
463  ATH_MSG_DEBUG("instable calculation: total covariance is non-positive, MeasCov = "<<
464  locMesCov<<", TrkCov = "<<locTrkCov<<", resType = "<<resType);
465  return 0.0;
466  }
467  return residual/sqrt(CovarianceSum);
468 }
python.PyKernel.retrieve
def retrieve(aClass, aKey=None)
Definition: PyKernel.py:110
Trk::LocalParameters::expansionMatrix
const Amg::MatrixX & expansionMatrix() const
Expansion matrix from 5x5 to the [dimension()]x[dimension()].
Definition: LocalParameters.cxx:73
Trk::DistanceSolution::currentDistance
double currentDistance(bool signedDist=false) const
Current distance to surface (spatial), signed (along/opposite to surface normal) if input argument tr...
Trk::TrackState::Vertex
@ Vertex
Definition: TrackStateDefs.h:36
Trk::TrackState::RPC
@ RPC
Definition: TrackStateDefs.h:33
AlignmentEffectsOnTrack.h
Trk::TrackState::Pixel
@ Pixel
Definition: TrackStateDefs.h:28
Amg::VectorX
Eigen::Matrix< double, Eigen::Dynamic, 1 > VectorX
Dynamic Vector - dynamic allocation.
Definition: EventPrimitives.h:32
TrackParameters.h
Trk::TrackState::TRT
@ TRT
Definition: TrackStateDefs.h:30
MeasurementBase.h
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
Trk::TrackState::Segment
@ Segment
Definition: TrackStateDefs.h:37
Trk::DistanceSolution
Definition: DistanceSolution.h:25
Trk::LocalParameters::parameterKey
int parameterKey() const
Identifier key for matrix expansion/reduction.
ClusterSeg::residual
@ residual
Definition: ClusterNtuple.h:20
Trk::ResidualPullCalculator::m_TGCresidualTool
ToolHandle< IResidualPullCalculator > m_TGCresidualTool
the ResidualPullCalculator for the TGC
Definition: ResidualPullCalculator.h:102
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Amg::Vector2D
Eigen::Matrix< double, 2, 1 > Vector2D
Definition: GeoPrimitives.h:48
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
Trk::ParametersBase::uniqueClone
std::unique_ptr< ParametersBase< DIM, T > > uniqueClone() const
clone method for polymorphic deep copy returning unique_ptr; it is not overriden, but uses the existi...
Definition: ParametersBase.h:97
Trk::TrackState::MDT
@ MDT
Definition: TrackStateDefs.h:31
Trk::ParamDefs
ParamDefs
Definition: ParamDefs.h:38
Trk::ResidualPull::Unbiased
@ Unbiased
RP with track state that has measurement not included.
Definition: ResidualPull.h:57
Trk::LocalParameters::contains
bool contains(ParamDefs par) const
The simple check for the clients whether the parameter is contained.
Trk::ResidualPullCalculator::residuals
virtual std::array< double, 5 > residuals(const Trk::MeasurementBase *measurement, const Trk::TrackParameters *trkPar, const Trk::ResidualPull::ResidualType resType, const Trk::TrackState::MeasurementType) const override final
This function is a light-weight version of the function above, designed for track fitters where speed...
Definition: ResidualPullCalculator.cxx:88
Trk::loc2
@ loc2
generic first and second local coordinate
Definition: ParamDefs.h:41
Trk::TrackState::TGC
@ TGC
Definition: TrackStateDefs.h:34
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
Trk::Surface::center
const Amg::Vector3D & center() const
Returns the center position of the Surface.
Trk::ResidualPullCalculator::finalize
virtual StatusCode finalize() override final
Definition: ResidualPullCalculator.cxx:79
Trk::TrackState::unidentified
@ unidentified
Definition: TrackStateDefs.h:27
Trk::ParametersCommon::updateParameters
void updateParameters(const AmgVector(DIM) &, const AmgSymMatrix(DIM) &)
Update parameters and covariance , passing covariance by ref.
Trk::TrackState::MM
@ MM
Definition: TrackStateDefs.h:42
Trk::TrackState::SpacePoint
@ SpacePoint
Definition: TrackStateDefs.h:38
Trk::AmgSymMatrix
AmgSymMatrix(5) &GXFTrackState
Definition: GXFTrackState.h:156
ResidualPullCalculator.h
AtlasDetectorID.h
This class provides an interface to generate or decode an identifier for the upper levels of the dete...
lumiFormat.i
int i
Definition: lumiFormat.py:92
Trk::TrackState::Pseudo
@ Pseudo
Definition: TrackStateDefs.h:35
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
AmgVector
AmgVector(4) T2BSTrackFilterTool
Definition: T2BSTrackFilterTool.cxx:114
Trk::TrackState::MeasurementType
MeasurementType
enum describing the flavour of MeasurementBase
Definition: TrackStateDefs.h:26
test_pyathena.parent
parent
Definition: test_pyathena.py:15
Trk::Surface::normal
virtual const Amg::Vector3D & normal() const
Returns the normal vector of the Surface (i.e.
python.StandardJetMods.pull
pull
Definition: StandardJetMods.py:264
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::ParametersBase
Definition: ParametersBase.h:55
Trk::ResidualPullCalculator::calcPull
double calcPull(const double residual, const double locMesCov, const double locTrkCov, const Trk::ResidualPull::ResidualType &resType) const
calc pull in 1 dimension
Definition: ResidualPullCalculator.cxx:449
Trk::ResidualPullCalculator::initialize
virtual StatusCode initialize() override final
initialize
Definition: ResidualPullCalculator.cxx:47
Trk::MeasurementBase::localCovariance
const Amg::MatrixX & localCovariance() const
Interface method to get the localError.
Definition: MeasurementBase.h:138
Trk::MeasurementBase
Definition: MeasurementBase.h:58
EventPrimitives.h
python.PyKernel.detStore
detStore
Definition: PyKernel.py:41
Trk::ResidualPullCalculator::ResidualPullCalculator
ResidualPullCalculator(const std::string &type, const std::string &name, const IInterface *parent)
constructor
Definition: ResidualPullCalculator.cxx:31
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
Trk::MeasurementBase::associatedSurface
virtual const Surface & associatedSurface() const =0
Interface method to get the associated Surface.
RIO_OnTrack.h
Trk::MeasurementTypeID
classifies a MeasurementBase into one of the known inherited flavours or one of the detector types fo...
Definition: MeasurementTypeID.h:26
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
LocalParameters.h
Trk::MeasurementBase::localParameters
const LocalParameters & localParameters() const
Interface method to get the LocalParameters.
Definition: MeasurementBase.h:132
Trk::LocalParameters::dimension
int dimension() const
Dimension of this localParameters() vector.
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
MeasurementTypeID.h
Trk::ParamDefsAccessor
Definition: ParamDefs.h:98
Trk::ResidualPull::Biased
@ Biased
RP with track state including the hit.
Definition: ResidualPull.h:55
Trk::ResidualPullCalculator::residualPull
virtual std::optional< Trk::ResidualPull > residualPull(const Trk::MeasurementBase *measurement, const Trk::TrackParameters *trkPar, const Trk::ResidualPull::ResidualType resType, const Trk::TrackState::MeasurementType) const override final
This function returns (creates!) a Trk::ResidualPull object, which contains the values of residual an...
Definition: ResidualPullCalculator.cxx:177
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
Trk::TrackState::CSC
@ CSC
Definition: TrackStateDefs.h:32
physics_parameters.parameters
parameters
Definition: physics_parameters.py:144
Trk::TrackState::SCT
@ SCT
Definition: TrackStateDefs.h:29
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
AthAlgTool
Definition: AthAlgTool.h:26
Trk::ParamDefsAccessor::pardef
const std::array< ParamDefs, 6 > pardef
Constructor.
Definition: ParamDefs.h:100
Trk::loc1
@ loc1
Definition: ParamDefs.h:40
Trk::Surface
Definition: Tracking/TrkDetDescr/TrkSurfaces/TrkSurfaces/Surface.h:75
Amg::distance
float distance(const Amg::Vector3D &p1, const Amg::Vector3D &p2)
calculates the distance between two point in 3D space
Definition: GeoPrimitivesHelpers.h:54
Trk::Surface::transform
const Amg::Transform3D & transform() const
Returns HepGeom::Transform3D by reference.
Trk::TrackState::STGC
@ STGC
Definition: TrackStateDefs.h:41
Trk::ResidualPullCalculator::m_RPCresidualTool
ToolHandle< IResidualPullCalculator > m_RPCresidualTool
the ResidualPullCalculator for the RPC
Definition: ResidualPullCalculator.h:101
Trk::ResidualPull::ResidualType
ResidualType
Definition: ResidualPull.h:53
Trk::ResidualPullCalculator::m_SCTresidualTool
ToolHandle< IResidualPullCalculator > m_SCTresidualTool
the ResidualPullCalculator for the SCT
Definition: ResidualPullCalculator.h:100
Generated on Tue Jul 2 2024 21:25:22 for ATLAS Offline Software by   doxygen 1.8.18