Loading [MathJax]/extensions/tex2jax.js
ATLAS Offline Software
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
ExtrapolationValidation.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
6 // ExtrapolationValidation.cxx, (c) ATLAS Detector software
8 
9 // Tracking
10 #include <cmath>
11 
12 #include "TrkExAlgs/ExtrapolationValidation.h"
13 #include "TrkSurfaces/CylinderSurface.h"
14 #include "TrkSurfaces/DiscSurface.h"
15 #include "TrkSurfaces/PlaneSurface.h"
16 #include "TrkEventPrimitives/ParticleHypothesis.h"
17 #include "TrkGeometry/TrackingGeometry.h"
18 #include "TrkGeometry/TrackingVolume.h"
19 #include "TrkVolumes/CylinderVolumeBounds.h"
20 #include "TrkTrack/TrackStateOnSurface.h"
21 // Validation mode - TTree includes
22 #include "TTree.h"
23 #include "GaudiKernel/ITHistSvc.h"
24 
25 //================ Constructor =================================================
26 
27 Trk::ExtrapolationValidation::ExtrapolationValidation(const std::string& name, ISvcLocator* pSvcLocator)
28  :
29  AthAlgorithm(name,pSvcLocator) {}
30 
31 //================ Destructor =================================================
32 
33 Trk::ExtrapolationValidation::~ExtrapolationValidation()
34 {
35  // clear random number generators
36  delete m_gaussDist;
37  delete m_flatDist;
38 }
39 
40 
41 //================ Initialisation =================================================
42 
43 StatusCode Trk::ExtrapolationValidation::initialize()
44 {
45  // Code entered here will be executed once at program start.
46  ATH_MSG_INFO( " initialize()" );
47 
48  // Get Extrapolator from ToolService
49  ATH_CHECK( m_extrapolator.retrieve());
50 
51  // create the new Tree
52  m_validationTree = new TTree(m_validationTreeName.value().c_str(),
53  m_validationTreeDescription.value().c_str());
54 
55  // the branches for the parameters
56  m_validationTree->Branch("Parameters", &m_parameters, "params/I");
57  m_validationTree->Branch("ParametersLoc1", m_parameterLoc1, "paramLoc1[params]/F");
58  m_validationTree->Branch("ParametersLoc2", m_parameterLoc2, "paramLoc2[params]/F");
59  m_validationTree->Branch("ParametersPhi", m_parameterPhi, "paramPhi[params]/F");
60  m_validationTree->Branch("ParametersTheta", m_parameterTheta, "paramTheta[params]/F");
61  m_validationTree->Branch("ParametersEta", m_parameterEta, "paramEta[params]/F");
62  m_validationTree->Branch("ParametersQoverP", m_parameterQoverP, "paramQoverP[params]/F");
63  // for the covariance diagonals
64  m_validationTree->Branch("CovarianceLoc1", m_covarianceLoc1, "covLoc1[params]/F");
65  m_validationTree->Branch("CovarianceLoc2", m_covarianceLoc2, "covLoc2[params]/F");
66  m_validationTree->Branch("CovariancePhi", m_covariancePhi, "covPhi[params]/F");
67  m_validationTree->Branch("CovarianceTheta", m_covarianceTheta, "covTheta[params]/F");
68  m_validationTree->Branch("CovarianceQoverP", m_covarianceQoverP, "covQoverP[params]/F");
69  m_validationTree->Branch("CovarianceDeterminant", m_covarianceDeterminant, "covDet[params]/F");
70  // the start Momentum
71  m_validationTree->Branch("StartMomentum", &m_startP, "startP/F");
72  // for the start surface
73  m_validationTree->Branch("StartSurfaceX", &m_startX, "startX/F");
74  m_validationTree->Branch("StartSurfaceY", &m_startY, "startY/F");
75  m_validationTree->Branch("StartSurfaceR", &m_startR, "startR/F");
76  m_validationTree->Branch("StartSurfaceZ", &m_startZ, "startZ/F");
77  // the estimation of the parameters
78  m_validationTree->Branch("EstimationSurfaceX", &m_estimationX, "estimateX/F");
79  m_validationTree->Branch("EstimationSurfaceY", &m_estimationY, "estimateY/F");
80  m_validationTree->Branch("EstimationSurfaceR", &m_estimationR, "estimateR/F");
81  m_validationTree->Branch("EstimationSurfaceZ", &m_estimationZ, "estimateZ/F");
82  // for the surface type
83  m_validationTree->Branch("DestinationSurfaceType", &m_destinationSurfaceType, "surfaceType/I");
84  m_validationTree->Branch("DestinationSurfaceX", &m_destinationX, "surfaceX/F");
85  m_validationTree->Branch("DestinationSurfaceY", &m_destinationY, "surfaceY/F");
86  m_validationTree->Branch("DestinationSurfaceR", &m_destinationR, "surfaceR/F");
87  m_validationTree->Branch("DestinationSurfaceZ", &m_destinationZ, "surfaceZ/F");
88 
89  // now register the Tree
90  SmartIF<ITHistSvc> tHistSvc{service("THistSvc")};
91  if (!tHistSvc){
92  ATH_MSG_ERROR("initialize() Could not find Hist Service -> Switching ValidationMode Off !" );
93  delete m_validationTree; m_validationTree = nullptr;
94  }
95  if ((tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isFailure()) {
96  ATH_MSG_ERROR("initialize() Could not register the validation Tree -> Switching ValidationMode Off !" );
97  delete m_validationTree; m_validationTree = nullptr;
98  }
99 
100  // intialize the random number generators
101  m_gaussDist = new Rndm::Numbers(randSvc(), Rndm::Gauss(0.,1.));
102  m_flatDist = new Rndm::Numbers(randSvc(), Rndm::Flat(0.,1.));
103 
104  ATH_MSG_INFO( "initialize() successful");
105  return StatusCode::SUCCESS;
106 }
107 
108 //================ Finalisation =================================================
109 
110 StatusCode Trk::ExtrapolationValidation::finalize()
111 {
112  // Code entered here will be executed once at the end of the program run.
113  ATH_MSG_INFO("================== Output Statistics =========================");
114  ATH_MSG_INFO("= Navigation : ");
115  ATH_MSG_INFO("= - breaks fwd : " << static_cast<double>(m_breaksFront)/static_cast<double>(m_triesFront)
116  << " (" << m_breaksFront << "/" << m_triesFront << ")");
117  ATH_MSG_INFO("= - breaks bwd : " << static_cast<double>(m_breaksBack)/static_cast<double>(m_triesBack)
118  << " (" << m_breaksBack << "/" << m_triesBack << ")");
119  if (m_materialCollectionValidation){
120  ATH_MSG_INFO("= Material collection : ");
121  ATH_MSG_INFO("= - layer collected fwd : " << m_collectedLayerFront );
122  ATH_MSG_INFO("= - layer collected bwd : " << m_collectedLayerBack );
123  }
124 
125  ATH_MSG_INFO("==============================================================");
126 
127  return StatusCode::SUCCESS;
128 }
129 
130 //================ Execution ====================================================
131 
132 StatusCode Trk::ExtrapolationValidation::execute()
133 {
134  const EventContext& ctx = Gaudi::Hive::currentContext();
135  // get the overall dimensions
136  if (!m_highestVolume){
137  // get TrackingGeometry and highest volume
138  const Trk::TrackingGeometry* trackingGeometry = m_extrapolator->trackingGeometry();
139  m_highestVolume = trackingGeometry ? trackingGeometry->highestTrackingVolume() : nullptr;
140  const Trk::CylinderVolumeBounds* cylBounds = m_highestVolume ?
141  dynamic_cast<const Trk::CylinderVolumeBounds*>(&(m_highestVolume->volumeBounds())) : nullptr;
142  // bail out
143  if (!cylBounds){
144  ATH_MSG_WARNING("No highest TrackingVolume / no VolumeBounds ... pretty useless! ");
145  return StatusCode::SUCCESS;
146  }
147  // get the numbers
148  m_maximumR = cylBounds->outerRadius();
149  m_maximumZ = cylBounds->halflengthZ();
150  }
151 
152  // intialize the values
153  m_parameters = 0;
154  m_destinationSurfaceType = 0;
155  // -----------> start
156  m_startX = 0.;
157  m_startY = 0.;
158  m_startR = 0.;
159  m_startZ = 0.;
160  // -----------> estimation
161  m_estimationX = 0.;
162  m_estimationY = 0.;
163  m_estimationR = 0.;
164  m_estimationZ = 0.;
165  // -----------> destination
166  m_destinationX = 0.;
167  m_destinationY = 0.;
168  m_destinationR = 0.;
169  m_destinationZ = 0.;
170 
171  // the local start parameters
172  m_parameterLoc1[m_parameters] = m_sigmaLoc * m_gaussDist->shoot();
173  m_parameterLoc2[m_parameters] = m_sigmaLoc * m_gaussDist->shoot();
174  // are adopted for planar and straight line surfaces
175  m_parameterPhi[m_parameters] = M_PI * m_flatDist->shoot();
176  m_parameterPhi[m_parameters] *= (m_flatDist->shoot() > 0.5 ) ? -1. : 1.;
177  m_parameterEta[m_parameters] = m_minEta + m_flatDist->shoot()*(m_maxEta-m_minEta);
178  m_parameterTheta[m_parameters] = 2.*std::atan(std::exp(-m_parameterEta[m_parameters]));
179 
180  m_covarianceLoc1[m_parameters] = std::abs(m_parameterLoc1[m_parameters] * 0.1);
181  m_covarianceLoc2[m_parameters] = std::abs(m_parameterLoc2[m_parameters] * 0.1);
182  m_covariancePhi[m_parameters] = std::abs(m_parameterPhi[m_parameters] * 0.1);
183  m_covarianceTheta[m_parameters] = std::abs(m_parameterTheta[m_parameters] * 0.1);
184 
185  // this is fine
186  double p = m_minP + m_flatDist->shoot()*(m_maxP-m_minP);
187  double charge = (m_flatDist->shoot() > 0.5 ) ? -1. : 1.;
188  m_parameterQoverP[m_parameters] = charge/p;
189 
190  m_covarianceQoverP[m_parameters] = std::abs(m_parameterQoverP[m_parameters] * 0.1);
191 
192  // for the momentum logging
193  m_startP = p;
194 
195  // start
196  m_startR = std::abs(m_sigmaR * m_gaussDist->shoot());
197  double surfacePhi = M_PI * m_flatDist->shoot();
198  surfacePhi *= (m_flatDist->shoot() > 0.5 ) ? -1. : 1.;
199  m_startX = m_startR*cos(surfacePhi);
200  m_startY = m_startR*sin(surfacePhi);
201  m_startZ = m_sigmaZ * m_gaussDist->shoot();
202 
203  // rotate it around Z
204  double alphaZ = M_PI * m_flatDist->shoot();
205  alphaZ *= (m_flatDist->shoot() > 0.5 ) ? -1. : 1.;
206 
207  // create the plane surface
208  Trk::PlaneSurface startSurface(createTransform(m_startX,
209  m_startY,
210  m_startZ,
211  m_parameterPhi[m_parameters],
212  m_parameterTheta[m_parameters],
213  alphaZ),
214  10e3,10e3);
215 
216 
217 
218  AmgSymMatrix(5) covariance;
219  covariance.setZero();
220  ATH_MSG_VERBOSE(m_covarianceLoc1[m_parameters]);
221  covariance(0,0) = m_covarianceLoc1[m_parameters];
222  ATH_MSG_VERBOSE(m_covarianceLoc2[m_parameters]);
223  covariance(1,1) = m_covarianceLoc2[m_parameters];
224  ATH_MSG_VERBOSE(m_covariancePhi[m_parameters]);
225  covariance(2,2) = m_covariancePhi[m_parameters];
226  ATH_MSG_VERBOSE(m_covarianceTheta[m_parameters]);
227  covariance(3,3) = m_covarianceTheta[m_parameters];
228  ATH_MSG_VERBOSE(m_covarianceQoverP[m_parameters]);
229  covariance(4,4) = m_covarianceQoverP[m_parameters];
230  ATH_MSG_VERBOSE("Initial Setting: \n"<<covariance);
231 
232 
233  m_covarianceDeterminant[m_parameters] = covariance.determinant();
234 
235  // the initial perigee with random numbers
236  Trk::AtaPlane startParameters(m_parameterLoc1[m_parameters],
237  m_parameterLoc2[m_parameters],
238  m_parameterPhi[m_parameters],
239  m_parameterTheta[m_parameters],
240  m_parameterQoverP[m_parameters],
241  startSurface,
242  std::move(covariance));
243 
244  ATH_MSG_VERBOSE( "Start Parameters : " << startParameters );
245  if(startParameters.covariance())ATH_MSG_VERBOSE( "Start Covariance : \n" << *startParameters.covariance() );
246 
247 
248  // destination position
249  m_estimationR = m_maximumR * m_flatDist->shoot();
250 
251  // --------------- propagate to find a first intersection ---------------------
252  Amg::Transform3D CylTrf;
253  CylTrf.setIdentity();
254  Trk::CylinderSurface estimationCylinder(CylTrf, m_estimationR, 10e10);
255  const Trk::TrackParameters* estimationParameters = m_extrapolator->extrapolateDirectly(ctx,
256  startParameters,
257  estimationCylinder,
258  Trk::alongMomentum,
259  false).release();
260  if (!estimationParameters) {
261  ATH_MSG_VERBOSE( "Estimation of intersection did not work - skip event !" );
262  return StatusCode::SUCCESS;
263  }
264  else if (m_highestVolume && estimationParameters && !(m_highestVolume->inside(estimationParameters->position()))){
265  ATH_MSG_VERBOSE( "Estimation of intersection is outside the known world - skip event !" );
266  delete estimationParameters;
267  return StatusCode::SUCCESS;
268  }
269 
270  ATH_MSG_VERBOSE( "Estimation Parameters: " << *estimationParameters );
271 
272  // record the estimation parameters
273  ++m_triesFront;
274  ++m_parameters;
275  m_parameterLoc1[m_parameters] = estimationParameters->parameters()[Trk::loc1];
276  m_parameterLoc2[m_parameters] = estimationParameters->parameters()[Trk::loc2];
277  m_parameterPhi[m_parameters] = estimationParameters->parameters()[Trk::phi];
278  m_parameterEta[m_parameters] = estimationParameters->eta();
279  m_parameterTheta[m_parameters] = estimationParameters->parameters()[Trk::theta];
280  m_parameterQoverP[m_parameters] = estimationParameters->parameters()[Trk::qOverP];
281  if(estimationParameters->covariance()){
282  m_covarianceLoc1[m_parameters] = (*estimationParameters->covariance())(0,0);
283  m_covarianceLoc2[m_parameters] = (*estimationParameters->covariance())(1,1);
284  m_covariancePhi[m_parameters] = (*estimationParameters->covariance())(2,2);
285  m_covarianceTheta[m_parameters] = (*estimationParameters->covariance())(3,3);
286  m_covarianceQoverP[m_parameters] = (*estimationParameters->covariance())(4,4);
287  m_covarianceDeterminant[m_parameters] = (estimationParameters->covariance())->determinant();
288  }
289  else{
290  m_covarianceLoc1[m_parameters] = 0;
291  m_covarianceLoc2[m_parameters] = 0;
292  m_covariancePhi[m_parameters] = 0;
293  m_covarianceTheta[m_parameters] = 0;
294  m_covarianceQoverP[m_parameters] = 0;
295  m_covarianceDeterminant[m_parameters] = 0;
296  }
297  // the start Momentum
298 
299  // get the estimated position
300  const Amg::Vector3D& estimatedPosition = estimationParameters->position();
301 
302  m_estimationX = estimatedPosition.x();
303  m_estimationY = estimatedPosition.y();
304  m_estimationZ = estimatedPosition.z();
305 
306  // cleanup for memory reasons
307  delete estimationParameters; estimationParameters = nullptr;
308 
309  // create the radom surface at the destination point
310  Trk::PlaneSurface destinationSurface(createTransform(m_estimationX,
311  m_estimationY,
312  m_estimationZ,
313  m_parameterPhi[m_parameters],
314  m_parameterTheta[m_parameters]), 10e5 , 10e5);
315 
316 
317  ATH_MSG_VERBOSE( "Extrapolation to Destination Surface: " << destinationSurface );
318 
319  // the destination parameters
320  const Trk::TrackParameters* destParameters = nullptr;
321  // the standard validation ...
322  if (!m_materialCollectionValidation && !m_direct)
323  destParameters = m_extrapolator->extrapolate(ctx,
324  startParameters,
325  destinationSurface,
326  Trk::alongMomentum,
327  false,
328  static_cast<Trk::ParticleHypothesis>(m_particleType.value()),
329  Trk::addNoise).release();
330  else if(!m_direct){ // material collection validation
331  // get the vector of TrackStateOnSurfaces back
332  const std::vector<const Trk::TrackStateOnSurface*>*
333  collectedMaterial = m_extrapolator->extrapolateM(ctx,
334  startParameters,
335  destinationSurface,
336  Trk::alongMomentum,
337  false,
338  static_cast<Trk::ParticleHypothesis>(m_particleType.value()));
339 
340  // get the last one and clone it
341  if (collectedMaterial && !collectedMaterial->empty()){
342  // get the last track state on surface & clone the destination parameters
343  const Trk::TrackStateOnSurface* destinationState = collectedMaterial->back();
344  destParameters = destinationState->trackParameters() ? destinationState->trackParameters()->clone() : nullptr;
345  m_collectedLayerFront += collectedMaterial->size();
346  // delete the layers / cleanup
347  for (const auto* tsos : *collectedMaterial) {
348  delete tsos;
349  }
350  }
351  }
352 
353  else{
354  destParameters = m_extrapolator->extrapolateDirectly(ctx,
355  startParameters,
356  destinationSurface,
357  Trk::alongMomentum,
358  false,
359  static_cast<Trk::ParticleHypothesis>(m_particleType.value())).release();
360 
361  }
362  // ----------------------- check if forward call was successful and continue then
363  if (destParameters){
364  // successful tries
365  ++m_triesBack;
366  // record the destination parameters
367  ++m_parameters;
368  m_parameterLoc1[m_parameters] = destParameters->parameters()[Trk::loc1];
369  m_parameterLoc2[m_parameters] = destParameters->parameters()[Trk::loc2];
370  m_parameterPhi[m_parameters] = destParameters->parameters()[Trk::phi];
371  m_parameterEta[m_parameters] = destParameters->eta();
372  m_parameterTheta[m_parameters] = destParameters->parameters()[Trk::theta];
373  m_parameterQoverP[m_parameters] = destParameters->parameters()[Trk::qOverP];
374  if(destParameters->covariance()){
375  m_covarianceLoc1[m_parameters] = (*destParameters->covariance())(0,0);
376  m_covarianceLoc2[m_parameters] = (*destParameters->covariance())(1,1);
377  m_covariancePhi[m_parameters] = (*destParameters->covariance())(2,2);
378  m_covarianceTheta[m_parameters] = (*destParameters->covariance())(3,3);
379  m_covarianceQoverP[m_parameters] = (*destParameters->covariance())(4,4);
380  m_covarianceDeterminant[m_parameters] = (destParameters->covariance())->determinant();
381  }
382  else{
383  m_covarianceLoc1[m_parameters] = 0;
384  m_covarianceLoc2[m_parameters] = 0;
385  m_covariancePhi[m_parameters] = 0;
386  m_covarianceTheta[m_parameters] = 0;
387  m_covarianceQoverP[m_parameters] = 0;
388  m_covarianceDeterminant[m_parameters] = 0;
389  }
390  // record the destination parameters
391  const Amg::Vector3D& destinationPosition = destParameters->position();
392  m_destinationX = destinationPosition.x();
393  m_destinationY = destinationPosition.y();
394  m_destinationZ = destinationPosition.z();
395  m_destinationR = destinationPosition.perp();
396 
397  // now simply go backwards
398  const Trk::TrackParameters* backParameters = nullptr;
399  // the standard validation ...
400  if (!m_materialCollectionValidation && !m_direct)
401  backParameters = m_extrapolator->extrapolate(ctx,
402  *destParameters,
403  startSurface,
404  Trk::oppositeMomentum,
405  false,
406  static_cast<Trk::ParticleHypothesis>(m_particleType.value()),
407  Trk::removeNoise).release();
408  else if(!m_direct){ // material collection validation
409  // get the vector of TrackStateOnSurfaces back
410  const std::vector<const Trk::TrackStateOnSurface*>*
411  collectedBackMaterial = m_extrapolator->extrapolateM(ctx,
412  *destParameters,
413  startSurface,
414  Trk::oppositeMomentum,
415  false,
416  static_cast<Trk::ParticleHypothesis>(m_particleType.value()));
417  // get the last one and clone it
418  if (collectedBackMaterial && !collectedBackMaterial->empty()){
419  // get the last track state on surface & clone the destination parameters
420  const Trk::TrackStateOnSurface* startState = collectedBackMaterial->back();
421  // assign the last ones of the call
422  backParameters = startState->trackParameters() ? startState->trackParameters()->clone() : nullptr;
423  m_collectedLayerBack += collectedBackMaterial->size();
424  // delete the layers / cleanup
425  for (const auto* tsos : *collectedBackMaterial) {
426  delete tsos;
427  }
428  }
429  }
430 
431  else{
432  backParameters = m_extrapolator->extrapolateDirectly(ctx,
433  *destParameters,
434  startSurface,
435  Trk::oppositeMomentum,
436  false,
437  static_cast<Trk::ParticleHypothesis>(m_particleType.value())).release();
438 
439  }
440  // ----------------------- check if backward call was successful and continue then
441  if (backParameters){
442 
443  ATH_MSG_VERBOSE( "Back Parameters : " << *backParameters );
444 
445  // record the back extrapolated ones
446  ++m_parameters;
447  m_parameterLoc1[m_parameters] = backParameters->parameters()[Trk::loc1];
448  m_parameterLoc2[m_parameters] = backParameters->parameters()[Trk::loc2];
449  m_parameterPhi[m_parameters] = backParameters->parameters()[Trk::phi];
450  m_parameterEta[m_parameters] = backParameters->eta();
451  m_parameterTheta[m_parameters] = backParameters->parameters()[Trk::theta];
452  m_parameterQoverP[m_parameters] = backParameters->parameters()[Trk::qOverP];
453  if(backParameters->covariance()){
454  m_covarianceLoc1[m_parameters] = (*backParameters->covariance())(0,0);
455  m_covarianceLoc2[m_parameters] = (*backParameters->covariance())(1,1);
456  m_covariancePhi[m_parameters] = (*backParameters->covariance())(2,2);
457  m_covarianceTheta[m_parameters] = (*backParameters->covariance())(3,3);
458  m_covarianceQoverP[m_parameters] = (*backParameters->covariance())(4,4);
459  m_covarianceDeterminant[m_parameters] = (backParameters->covariance())->determinant();
460  }
461  else{
462  m_covarianceLoc1[m_parameters] = 0;
463  m_covarianceLoc2[m_parameters] = 0;
464  m_covariancePhi[m_parameters] = 0;
465  m_covarianceTheta[m_parameters] = 0;
466  m_covarianceQoverP[m_parameters] = 0;
467  m_covarianceDeterminant[m_parameters] = 0;
468  }
469  // memory cleanup
470  delete backParameters;
471  } else
472  ++m_breaksBack;
473  // memory cleanup
474  delete destParameters;
475  } else
476  ++m_breaksFront;
477  // increase ones more
478  ++m_parameters;
479  // memory cleanup
480 
481  if (m_validationTree)
482  m_validationTree->Fill();
483 
484 
485  //std::cout<<"Cleaning up..."<<std::endl;
486  //delete covariance;
487 
488  return StatusCode::SUCCESS;
489 }
490 
491 //============================================================================================
492 Amg::Transform3D
493 Trk::ExtrapolationValidation::createTransform(double x, double y, double z, double phi, double theta, double alphaZ)
494 {
495 
496  if (phi!=0. && theta != 0.){
497  // create the Start Surface
498  Amg::Vector3D surfacePosition(x,y,z);
499  // z direction
500  Amg::Vector3D surfaceZdirection(cos(phi)*sin(theta),
501  sin(phi)*sin(theta),
502  cos(theta));
503  // the global z axis
504  Amg::Vector3D zAxis(0.,0.,1.);
505  // the y direction
506  Amg::Vector3D surfaceYdirection(zAxis.cross(surfaceZdirection));
507  // the x direction
508  Amg::Vector3D surfaceXdirection(surfaceYdirection.cross(surfaceZdirection));
509 
510  double nx = 1./sqrt(surfaceXdirection[0]*surfaceXdirection[0]+surfaceXdirection[1]*surfaceXdirection[1]+surfaceXdirection[2]*surfaceXdirection[2]);
511  double ny = 1./sqrt(surfaceYdirection[0]*surfaceYdirection[0]+surfaceYdirection[1]*surfaceYdirection[1]+surfaceYdirection[2]*surfaceYdirection[2]);
512  surfaceXdirection[0]*=nx;
513  surfaceXdirection[1]*=nx;
514  surfaceXdirection[2]*=nx;
515 
516  surfaceYdirection[0]*=ny;
517  surfaceYdirection[1]*=ny;
518  surfaceYdirection[2]*=ny;
519  // the rotation
520  Amg::RotationMatrix3D surfaceRotation;
521  surfaceRotation.col(0) = surfaceXdirection;
522  surfaceRotation.col(1) = surfaceYdirection;
523  surfaceRotation.col(2) = surfaceZdirection;
524  // return it
525  if (alphaZ==0.)
526  return Amg::Transform3D(surfaceRotation, surfacePosition);
527  Amg::Transform3D nominalTransform(surfaceRotation, surfacePosition);
528  return Amg::Transform3D(nominalTransform*Amg::AngleAxis3D(alphaZ,zAxis));
529 
530  }
531 
532  return Amg::Transform3D(Amg::Translation3D(x,y,z));
533 }
534 
Trk::y
@ y
Definition: ParamDefs.h:56
Trk::TrackStateOnSurface::trackParameters
const TrackParameters * trackParameters() const
return ptr to trackparameters const overload
Trk::z
@ z
global position (cartesian)
Definition: ParamDefs.h:57
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
PlotCalibFromCool.zAxis
zAxis
Definition: PlotCalibFromCool.py:76
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Trk::oppositeMomentum
@ oppositeMomentum
Definition: PropDirection.h:21
Trk::ParametersT
Dummy class used to allow special convertors to be called for surfaces owned by a detector element.
Definition: EMErrorDetail.h:25
M_PI
#define M_PI
Definition: ActiveFraction.h:11
Trk::loc2
@ loc2
generic first and second local coordinate
Definition: ParamDefs.h:35
ExtrapolationValidation.h
Trk::alongMomentum
@ alongMomentum
Definition: PropDirection.h:20
Trk::ExtrapolationValidation::~ExtrapolationValidation
~ExtrapolationValidation()
Default Destructor.
Definition: ExtrapolationValidation.cxx:33
drawFromPickle.cos
cos
Definition: drawFromPickle.py:36
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
drawFromPickle.exp
exp
Definition: drawFromPickle.py:36
drawFromPickle.atan
atan
Definition: drawFromPickle.py:36
Trk::ExtrapolationValidation::finalize
StatusCode finalize()
standard Athena-Algorithm method
Definition: ExtrapolationValidation.cxx:110
Trk::ExtrapolationValidation::createTransform
static Amg::Transform3D createTransform(double x, double y, double z, double phi=0., double theta=0., double alphaZ=0.)
private helper method to create a HepTransform
Definition: ExtrapolationValidation.cxx:493
Trk::AmgSymMatrix
AmgSymMatrix(5) &GXFTrackState
Definition: GXFTrackState.h:156
Trk::ParticleHypothesis
ParticleHypothesis
Definition: ParticleHypothesis.h:25
CylinderVolumeBounds.h
Trk::TrackingGeometry::highestTrackingVolume
const TrackingVolume * highestTrackingVolume() const
return the world
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
CheckAppliedSFs.e3
e3
Definition: CheckAppliedSFs.py:264
Trk::theta
@ theta
Definition: ParamDefs.h:66
Trk::TrackingGeometry
Definition: TrackingGeometry.h:67
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
Trk::CylinderSurface
Definition: CylinderSurface.h:55
Amg::Transform3D
Eigen::Affine3d Transform3D
Definition: GeoPrimitives.h:46
CylinderSurface.h
Trk::CylinderVolumeBounds::halflengthZ
double halflengthZ() const
This method returns the halflengthZ.
Definition: CylinderVolumeBounds.h:207
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
Trk::ParametersBase
Definition: ParametersBase.h:55
Trk::ExtrapolationValidation::ExtrapolationValidation
ExtrapolationValidation(const std::string &name, ISvcLocator *pSvcLocator)
Standard Athena-Algorithm Constructor.
Definition: ExtrapolationValidation.cxx:27
ParticleHypothesis.h
AthAlgorithm
Definition: AthAlgorithm.h:47
Trk::CylinderVolumeBounds
Definition: CylinderVolumeBounds.h:70
Trk::TrackStateOnSurface
represents the track state (measurement, material, fit parameters and quality) at a surface.
Definition: TrackStateOnSurface.h:71
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
Trk::CylinderVolumeBounds::outerRadius
double outerRadius() const
This method returns the outer radius.
Definition: CylinderVolumeBounds.h:191
charge
double charge(const T &p)
Definition: AtlasPID.h:931
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
Trk::ExtrapolationValidation::initialize
StatusCode initialize()
standard Athena-Algorithm method
Definition: ExtrapolationValidation.cxx:43
TrackingVolume.h
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::PlaneSurface
Definition: PlaneSurface.h:64
Amg::RotationMatrix3D
Eigen::Matrix< double, 3, 3 > RotationMatrix3D
Definition: GeoPrimitives.h:49
Trk::addNoise
@ addNoise
Definition: MaterialUpdateMode.h:19
PlaneSurface.h
Amg::Translation3D
Eigen::Translation< double, 3 > Translation3D
Definition: GeoPrimitives.h:44
Trk::qOverP
@ qOverP
perigee
Definition: ParamDefs.h:67
DiscSurface.h
Trk::ParametersBase::eta
double eta() const
Access method for pseudorapidity - from momentum.
TrackingGeometry.h
Amg::AngleAxis3D
Eigen::AngleAxisd AngleAxis3D
Definition: GeoPrimitives.h:45
Trk::phi
@ phi
Definition: ParamDefs.h:75
drawFromPickle.sin
sin
Definition: drawFromPickle.py:36
Trk::x
@ x
Definition: ParamDefs.h:55
Trk::ExtrapolationValidation::execute
StatusCode execute()
standard Athena-Algorithm method
Definition: ExtrapolationValidation.cxx:132
Trk::loc1
@ loc1
Definition: ParamDefs.h:34
Trk::removeNoise
@ removeNoise
Definition: MaterialUpdateMode.h:20
TrackStateOnSurface.h
Trk::ParametersBase::clone
virtual ParametersBase< DIM, T > * clone() const override=0
clone method for polymorphic deep copy
Generated on Sun Apr 27 2025 21:10:42 for ATLAS Offline Software by   doxygen 1.8.18