ATLAS Offline Software
Classes | Public Member Functions | Private Attributes | List of all members
ActsGeantFollowerHelper Class Reference

#include <ActsGeantFollowerHelper.h>

Inheritance diagram for ActsGeantFollowerHelper:
Collaboration diagram for ActsGeantFollowerHelper:

Classes

struct  TreeData
 Ntuple variables : initial parameters Split this out into a separate, dynamically-allocated block. More...
 

Public Member Functions

 ActsGeantFollowerHelper (const std::string &, const std::string &, const IInterface *)
 
virtual ~ActsGeantFollowerHelper ()
 
virtual StatusCode initialize () override
 
virtual StatusCode finalize () override
 
virtual void beginEvent () override
 
virtual void trackParticle (const G4ThreeVector &pos, const G4ThreeVector &mom, int pdg, double charge, float t, float X0, bool isSensitive) override
 
virtual void endEvent () override
 

Private Attributes

ToolHandle< Trk::IExtrapolationEngine > m_extrapolationEngine
 
ToolHandle< IActsExtrapolationTool > m_actsExtrapolator
 
bool m_extrapolateDirectly
 
bool m_extrapolateIncrementally
 
Trk::TrackParameters * m_parameterCache
 
std::optional< Acts::BoundTrackParameters > m_actsParameterCache
 
std::unique_ptr< std::vector< Acts::SurfaceHit > > m_actsSurfaceCache
 
std::vector< Acts::SurfaceHit >::iterator m_actsSurfaceIterator
 
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
 
float m_tX0Cache
 
float m_tX0NonSensitiveCache
 
float m_tNonSensitiveCache
 
float m_tX0CacheActs
 
float m_tX0CacheATLAS
 
std::string m_validationTreeName
 validation tree name - to be acessed by this from root More...
 
std::string m_validationTreeDescription
 validation tree description - second argument in TTree More...
 
std::string m_validationTreeFolder
 stream/folder to for the TTree to be written out More...
 
TTree * m_validationTree
 Root Validation Tree. More...
 
std::unique_ptr< TreeData > m_treeData
 

Detailed Description

Definition at line 35 of file ActsGeantFollowerHelper.h.

Constructor & Destructor Documentation

◆ ActsGeantFollowerHelper()

ActsGeantFollowerHelper::ActsGeantFollowerHelper ( const std::string &  t,
const std::string &  n,
const IInterface *  p 
)

Definition at line 36 of file ActsGeantFollowerHelper.cxx.

36  :
37  base_class(t,n,p),
38  m_extrapolationEngine(""),
39  m_actsExtrapolator(""),
40  m_extrapolateDirectly(true),
41  m_extrapolateIncrementally(true),
42  m_parameterCache(nullptr),
43  m_actsParameterCache(std::nullopt),
44  m_tX0Cache(0.),
45  m_tX0NonSensitiveCache(0.),
46  m_tNonSensitiveCache(0.),
47  m_tX0CacheActs(0.),
48  m_tX0CacheATLAS(0.),
49  m_validationTreeName("G4Follower_"+n),
50  m_validationTreeDescription("Output of the G4Follower_"),
51  m_validationTreeFolder("/val/G4Follower_"+n),
52  m_validationTree(nullptr)
53 {
54  // properties
55  declareProperty("ExtrapolationEngine", m_extrapolationEngine);
56  declareProperty("ActsExtrapolator", m_actsExtrapolator);
57  declareProperty("ExtrapolateDirectly", m_extrapolateDirectly);
58  declareProperty("ExtrapolateIncrementally", m_extrapolateIncrementally);
59 }

◆ ~ActsGeantFollowerHelper()

ActsGeantFollowerHelper::~ActsGeantFollowerHelper ( )
virtual

Definition at line 62 of file ActsGeantFollowerHelper.cxx.

63 {}

Member Function Documentation

◆ beginEvent()

void ActsGeantFollowerHelper::beginEvent ( )
overridevirtual

Definition at line 160 of file ActsGeantFollowerHelper.cxx.

161 {
162  m_treeData->m_t_x = 0.;
163  m_treeData->m_t_y = 0.;
164  m_treeData->m_t_z = 0.;
165  m_treeData->m_t_theta = 0.;
166  m_treeData->m_t_eta = 0.;
167  m_treeData->m_t_phi = 0.;
168  m_treeData->m_t_p = 0.;
169  m_treeData->m_t_charge = 0.;
170  m_treeData->m_t_pdg = 0;
171  m_treeData->m_g4_steps = 0;
172  m_tX0Cache = 0.;
173  m_tX0NonSensitiveCache = 0.;
174  m_tNonSensitiveCache = 0.;
175  m_tX0CacheActs = 0.;
176  m_tX0CacheATLAS = 0.;
177 }

◆ endEvent()

void ActsGeantFollowerHelper::endEvent ( )
overridevirtual

Definition at line 379 of file ActsGeantFollowerHelper.cxx.

380 {
381  if (m_tX0Cache != 0)
382  {
383  // fill the validation tree
384  m_validationTree->Fill();
385  delete m_parameterCache;
386  m_actsParameterCache.reset();
387  }
388 }

◆ finalize()

StatusCode ActsGeantFollowerHelper::finalize ( )
overridevirtual

Definition at line 155 of file ActsGeantFollowerHelper.cxx.

156 {
157  return StatusCode::SUCCESS;
158 }

◆ initialize()

StatusCode ActsGeantFollowerHelper::initialize ( )
overridevirtual

Definition at line 67 of file ActsGeantFollowerHelper.cxx.

68 {
69  m_treeData = std::make_unique<TreeData>();
70 
71  // if (m_extrapolator.retrieve().isFailure()){
72  // ATH_MSG_ERROR("Could not retrieve Extrapolator " << m_extrapolator << " . Abort.");
73  // return StatusCode::FAILURE;
74  // }
75  if (m_extrapolationEngine.retrieve().isFailure()){
76  ATH_MSG_ERROR("Could not retrieve Extrapolator Engine " << m_extrapolationEngine << " . Abort.");
77  return StatusCode::FAILURE;
78  }
79 
80  if (m_actsExtrapolator.retrieve().isFailure()){
81  ATH_MSG_ERROR("Could not retrieve ActsExtrapolator " << m_actsExtrapolator << " . Abort.");
82  return StatusCode::FAILURE;
83  }
84 
85  // create the new Tree
86  m_validationTree = new TTree(m_validationTreeName.c_str(), m_validationTreeDescription.c_str());
87 
88  m_validationTree->Branch("InitX", &m_treeData->m_t_x, "initX/F");
89  m_validationTree->Branch("InitY", &m_treeData->m_t_y, "initY/F");
90  m_validationTree->Branch("InitZ", &m_treeData->m_t_z, "initZ/F");
91  m_validationTree->Branch("InitTheta", &m_treeData->m_t_theta, "initTheta/F");
92  m_validationTree->Branch("InitEta", &m_treeData->m_t_eta, "initEta/F");
93  m_validationTree->Branch("InitPhi", &m_treeData->m_t_phi, "initPhi/F");
94  m_validationTree->Branch("InitP", &m_treeData->m_t_p, "initP/F");
95  m_validationTree->Branch("InitPdg", &m_treeData->m_t_pdg, "initPdg/I");
96  m_validationTree->Branch("InitCharge", &m_treeData->m_t_charge, "initQ/F");
97 
98  m_validationTree->Branch("G4Steps", &m_treeData->m_g4_steps, "g4steps/I");
99  m_validationTree->Branch("G4StepPt", m_treeData->m_g4_pt, "g4stepPt[g4steps]/F");
100  m_validationTree->Branch("G4StepEta", m_treeData->m_g4_eta, "g4stepEta[g4steps]/F");
101  m_validationTree->Branch("G4StepTheta", m_treeData->m_g4_theta, "g4stepTheta[g4steps]/F");
102  m_validationTree->Branch("G4StepPhi", m_treeData->m_g4_phi, "g4stepPhi[g4steps]/F");
103  m_validationTree->Branch("G4StepX", m_treeData->m_g4_x, "g4stepX[g4steps]/F");
104  m_validationTree->Branch("G4StepY", m_treeData->m_g4_y, "g4stepY[g4steps]/F");
105  m_validationTree->Branch("G4StepZ", m_treeData->m_g4_z, "g4stepZ[g4steps]/F");
106  m_validationTree->Branch("G4StepTX0", m_treeData->m_g4_tX0, "g4stepTX0[g4steps]/F");
107  m_validationTree->Branch("G4AccumX0", m_treeData->m_g4_accX0, "g4stepAccTX0[g4steps]/F");
108  m_validationTree->Branch("G4StepT", m_treeData->m_g4_t, "g4stepTX[g4steps]/F");
109  m_validationTree->Branch("G4StepX0", m_treeData->m_g4_X0, "g4stepX0[g4steps]/F");
110 
111  m_validationTree->Branch("TrkStepStatus",m_treeData->m_trk_status, "trkstepStatus[g4steps]/I");
112  m_validationTree->Branch("TrkStepPt", m_treeData->m_trk_pt, "trkstepPt[g4steps]/F");
113  m_validationTree->Branch("TrkStepEta", m_treeData->m_trk_eta, "trkstepEta[g4steps]/F");
114  m_validationTree->Branch("TrkStepTheta", m_treeData->m_trk_theta, "trkstepTheta[g4steps]/F");
115  m_validationTree->Branch("TrkStepPhi", m_treeData->m_trk_phi, "trkstepPhi[g4steps]/F");
116  m_validationTree->Branch("TrkStepX", m_treeData->m_trk_x, "trkstepX[g4steps]/F");
117  m_validationTree->Branch("TrkStepY", m_treeData->m_trk_y, "trkstepY[g4steps]/F");
118  m_validationTree->Branch("TrkStepZ", m_treeData->m_trk_z, "trkstepZ[g4steps]/F");
119  m_validationTree->Branch("TrkStepLocX", m_treeData->m_trk_lx, "trkstepLX[g4steps]/F");
120  m_validationTree->Branch("TrkStepLocY", m_treeData->m_trk_ly, "trkstepLY[g4steps]/F");
121  m_validationTree->Branch("TrkStepTX0", m_treeData->m_trk_tX0, "trkstepTX0[g4steps]/F");
122  m_validationTree->Branch("TrkAccumX0", m_treeData->m_trk_accX0, "trkstepAccTX0[g4steps]/F");
123  m_validationTree->Branch("TrkStepT", m_treeData->m_trk_t, "trkstepTX[g4steps]/F");
124  m_validationTree->Branch("TrkStepX0", m_treeData->m_trk_X0, "trkstepX0[g4steps]/F");
125 
126  m_validationTree->Branch("ActsStepStatus",m_treeData->m_acts_status, "actsstepStatus[g4steps]/I");
127  m_validationTree->Branch("ActsVolumeId", m_treeData->m_acts_volumeID,"actsvolumeid[g4steps]/I");
128  m_validationTree->Branch("ActsStepPt", m_treeData->m_acts_pt, "actsstepPt[g4steps]/F");
129  m_validationTree->Branch("ActsStepEta", m_treeData->m_acts_eta, "actsstepEta[g4steps]/F");
130  m_validationTree->Branch("ActsStepTheta", m_treeData->m_acts_theta, "actsstepTheta[g4steps]/F");
131  m_validationTree->Branch("ActsStepPhi", m_treeData->m_acts_phi, "actsstepPhi[g4steps]/F");
132  m_validationTree->Branch("ActsStepX", m_treeData->m_acts_x, "actsstepX[g4steps]/F");
133  m_validationTree->Branch("ActsStepY", m_treeData->m_acts_y, "actsstepY[g4steps]/F");
134  m_validationTree->Branch("ActsStepZ", m_treeData->m_acts_z, "actsstepZ[g4steps]/F");
135  m_validationTree->Branch("ActsStepTX0", m_treeData->m_acts_tX0, "actsstepTX0[g4steps]/F");
136  m_validationTree->Branch("ActsAccumX0", m_treeData->m_acts_accX0, "actsstepAccTX0[g4steps]/F");
137  m_validationTree->Branch("ActsStepT", m_treeData->m_acts_t, "actsstepTX[g4steps]/F");
138  m_validationTree->Branch("ActsStepX0", m_treeData->m_acts_X0, "actsstepX0[g4steps]/F");
139 
140  // now register the Tree
141  SmartIF<ITHistSvc> tHistSvc{service("THistSvc")};
142  if (!tHistSvc){
143  ATH_MSG_ERROR( "Could not find Hist Service -> Switching ValidationMode Off !" );
144  delete m_validationTree; m_validationTree = 0;
145  }
146  if ((tHistSvc->regTree(m_validationTreeFolder, m_validationTree)).isFailure()) {
147  ATH_MSG_ERROR( "Could not register the validation Tree -> Switching ValidationMode Off !" );
148  delete m_validationTree; m_validationTree = 0;
149  }
150 
151  ATH_MSG_INFO("initialize() successful" );
152  return StatusCode::SUCCESS;
153 }

◆ trackParticle()

void ActsGeantFollowerHelper::trackParticle ( const G4ThreeVector &  pos,
const G4ThreeVector &  mom,
int  pdg,
double  charge,
float  t,
float  X0,
bool  isSensitive 
)
overridevirtual

Definition at line 179 of file ActsGeantFollowerHelper.cxx.

183 {
184  // const EventContext ctx;
185  const EventContext &ctx = Gaudi::Hive::currentContext();
186  const ActsGeometryContext &gctx = m_actsExtrapolator->trackingGeometryTool()->getGeometryContext(ctx);
187  auto trackingGeometry = m_actsExtrapolator->trackingGeometryTool()->trackingGeometry();
188  // construct the initial parameters
189  Amg::Vector3D npos(pos.x(),pos.y(),pos.z());
190  Amg::Vector3D nmom(mom.x(),mom.y(),mom.z());
191 
192  // Use the G4 pdgId as the particle hypothesis
193  Trk::ParticleHypothesis particleHypo = m_pdgToParticleHypothesis.convert(m_treeData->m_t_pdg, m_treeData->m_t_charge);
194 
195  if(m_treeData->m_g4_steps == 0 && m_tNonSensitiveCache == 0){
196  ATH_MSG_INFO("Initial step ... preparing event cache.");
197  m_treeData->m_t_x = pos.x();
198  m_treeData->m_t_y = pos.y();
199  m_treeData->m_t_z = pos.z();
200  m_treeData->m_t_theta = mom.theta();
201  m_treeData->m_t_eta = mom.eta();
202  m_treeData->m_t_phi = mom.phi();
203  m_treeData->m_t_p = mom.mag();
204  m_treeData->m_t_charge = charge;
205  m_treeData->m_t_pdg = pdg;
206  m_treeData->m_g4_steps = -1;
207  m_tX0Cache = 0.;
208  m_tX0CacheActs = 0.;
209  m_parameterCache = new Trk::CurvilinearParameters(npos, nmom, charge);
210 
211  std::shared_ptr<Acts::PerigeeSurface> surface =
212  Acts::Surface::makeShared<Acts::PerigeeSurface>(
213  npos);
214 
215 
216  float mass = Trk::ParticleMasses::mass[particleHypo] * Acts::UnitConstants::MeV;
217 
218  Acts::Vector4 actsStart(pos.x(),pos.y(),pos.z(),0);
219  Acts::Vector3 dir = nmom.normalized();
220  Acts::ParticleHypothesis hypothesis{Acts::makeAbsolutePdgParticle(static_cast<Acts::PdgParticle>(pdg)),
221  mass,
222  Acts::AnyCharge{static_cast<float>(charge)}};
223  m_actsParameterCache = Acts::GenericBoundTrackParameters<Acts::ParticleHypothesis>::create(
224  surface, gctx.context(), actsStart, dir, charge/(mom.mag()/1000), std::nullopt, hypothesis)
225  .value();
226  }
227 
228  // Store material in cache
229  float tX0 = X0 > 10e-5 ? t/X0 : 0.;
230  m_tX0NonSensitiveCache += tX0;
231  m_tNonSensitiveCache += t;
232  if (!isSensitive)
233  {
234  return;
235  }
236 
237  // jumping over inital step
238  m_treeData->m_g4_steps = (m_treeData->m_g4_steps == -1) ? 0 : m_treeData->m_g4_steps;
239 
240  if (!m_parameterCache){
241  ATH_MSG_WARNING("No Parameters available. Bailing out.");
242  return;
243  }
244 
245  if ( m_treeData->m_g4_steps >= MAXPROBES) {
246  ATH_MSG_WARNING("Maximum number of " << MAXPROBES << " reached, step is ignored.");
247  return;
248  }
249  // parameters of the G4 step point
250  Trk::CurvilinearParameters* g4Parameters = new Trk::CurvilinearParameters(npos, nmom, m_treeData->m_t_charge);
251  // destination surface
252  const Trk::PlaneSurface& destinationSurface = g4Parameters->associatedSurface();
253  // extrapolate to the destination surface
254  Trk::ExtrapolationCell<Trk::TrackParameters> ecc(*m_parameterCache);
255  ecc.setParticleHypothesis((Trk::ParticleHypothesis) particleHypo);
256  ecc.addConfigurationMode(Trk::ExtrapolationMode::StopAtBoundary);
257  ecc.addConfigurationMode(Trk::ExtrapolationMode::CollectMaterial);
258  // call the extrapolation engine
259  auto eCodeSteps = m_extrapolationEngine->extrapolate(ecc, &destinationSurface);
260  Trk::TrackParameters *trkParameters = ecc.endParameters;
261  float X0ATLAS = ecc.materialX0;
262 
263  if(eCodeSteps.code != 2 ){
264  ATH_MSG_ERROR("Error in the Extrapolator Engine, skip the current step");
265  return;
266  }
267 
268  // create a Acts::Surface that correspond to the Trk::Surface
269  auto destinationSurfaceActs = Acts::CurvilinearSurface(destinationSurface.center(), destinationSurface.normal()).planeSurface();
270  std::optional<Acts::BoundTrackParameters> actsParameters = m_actsExtrapolator->propagate(ctx,
271  *m_actsParameterCache,
272  *destinationSurfaceActs,
273  Acts::Direction::Forward,
274  std::numeric_limits<double>::max());
275 
276  float X0Acts = m_actsExtrapolator->propagationSteps(ctx,
277  *m_actsParameterCache,
278  *destinationSurfaceActs,
279  Acts::Direction::Forward,
280  std::numeric_limits<double>::max()).second.materialInX0;
281 
282  if(not actsParameters.has_value()){
283  ATH_MSG_ERROR("Error in the Acts extrapolation, skip the current step");
284  return;
285  }
286  int volID = trackingGeometry->lowestTrackingVolume(gctx.context(), actsParameters->position(gctx.context()))->geometryId().volume();
287 
288  // fill the geant information and the trk information
289  m_treeData->m_g4_pt[m_treeData->m_g4_steps] = mom.mag()/std::cosh(mom.eta());
290  m_treeData->m_g4_eta[m_treeData->m_g4_steps] = mom.eta();
291  m_treeData->m_g4_theta[m_treeData->m_g4_steps] = mom.theta();
292  m_treeData->m_g4_phi[m_treeData->m_g4_steps] = mom.phi();
293  m_treeData->m_g4_x[m_treeData->m_g4_steps] = pos.x();
294  m_treeData->m_g4_y[m_treeData->m_g4_steps] = pos.y();
295  m_treeData->m_g4_z[m_treeData->m_g4_steps] = pos.z();
296 
297  m_tX0Cache += m_tX0NonSensitiveCache;
298  m_treeData->m_g4_tX0[m_treeData->m_g4_steps] = m_tX0NonSensitiveCache;
299  m_treeData->m_g4_accX0[m_treeData->m_g4_steps] = m_tX0Cache;
300  m_treeData->m_g4_t[m_treeData->m_g4_steps] = m_tNonSensitiveCache;
301  m_treeData->m_g4_X0[m_treeData->m_g4_steps] = m_tNonSensitiveCache/m_tX0NonSensitiveCache;
302 
303  m_treeData->m_trk_status[m_treeData->m_g4_steps] = trkParameters ? 1 : 0;
304  m_treeData->m_trk_pt[m_treeData->m_g4_steps] = trkParameters ? trkParameters->pT() : 0.;
305  m_treeData->m_trk_eta[m_treeData->m_g4_steps] = trkParameters ? trkParameters->momentum().eta() : 0.;
306  m_treeData->m_trk_theta[m_treeData->m_g4_steps] = trkParameters ? trkParameters->momentum().theta() : 0.;
307  m_treeData->m_trk_phi[m_treeData->m_g4_steps] = trkParameters ? trkParameters->momentum().phi() : 0.;
308  m_treeData->m_trk_x[m_treeData->m_g4_steps] = trkParameters ? trkParameters->position().x() : 0.;
309  m_treeData->m_trk_y[m_treeData->m_g4_steps] = trkParameters ? trkParameters->position().y() : 0.;
310  m_treeData->m_trk_z[m_treeData->m_g4_steps] = trkParameters ? trkParameters->position().z() : 0.;
311  m_treeData->m_trk_lx[m_treeData->m_g4_steps] = trkParameters ? trkParameters->parameters()[Trk::locX] : 0.;
312  m_treeData->m_trk_ly[m_treeData->m_g4_steps] = trkParameters ? trkParameters->parameters()[Trk::locY] : 0.;
313  // Incremental extrapolation, the extrapolation correspond to one step
314  if(m_extrapolateIncrementally || m_treeData->m_g4_steps == 0){
315  float tATLAS = (trkParameters->position() - m_parameterCache->position()).norm();
316  m_tX0CacheATLAS += X0ATLAS;
317  m_treeData->m_trk_tX0[m_treeData->m_g4_steps] = X0ATLAS;
318  m_treeData->m_trk_accX0[m_treeData->m_g4_steps] = m_tX0CacheATLAS;
319  m_treeData->m_trk_t[m_treeData->m_g4_steps] = tATLAS;
320  m_treeData->m_trk_X0[m_treeData->m_g4_steps] = tATLAS/X0ATLAS;
321  }
322  // Extrapolation perform from the start, step varaible need to be computed by comparing to the last extrapolation.
323  else{
324  Amg::Vector3D previousPos(m_treeData->m_trk_x[m_treeData->m_g4_steps-1],
325  m_treeData->m_trk_y[m_treeData->m_g4_steps-1],
326  m_treeData->m_trk_z[m_treeData->m_g4_steps-1]);
327  float tATLAS = (trkParameters->position() - previousPos).norm();
328  m_treeData->m_trk_tX0[m_treeData->m_g4_steps] = X0ATLAS - m_treeData->m_trk_accX0[m_treeData->m_g4_steps-1] ;
329  m_treeData->m_trk_accX0[m_treeData->m_g4_steps] = X0ATLAS;
330  m_treeData->m_trk_t[m_treeData->m_g4_steps] = tATLAS;
331  m_treeData->m_trk_X0[m_treeData->m_g4_steps] = tATLAS/m_treeData->m_trk_tX0[m_treeData->m_g4_steps];
332  }
333 
334  m_treeData->m_acts_status[m_treeData->m_g4_steps] = actsParameters ? 1 : 0;
335  m_treeData->m_acts_volumeID[m_treeData->m_g4_steps] = actsParameters ? volID : 0;
336  m_treeData->m_acts_pt[m_treeData->m_g4_steps] = actsParameters ? actsParameters->transverseMomentum()*1000 : 0.;
337  m_treeData->m_acts_eta[m_treeData->m_g4_steps] = actsParameters ? actsParameters->momentum().eta() : 0.;
338  m_treeData->m_acts_theta[m_treeData->m_g4_steps] = actsParameters ? actsParameters->momentum().theta() : 0.;
339  m_treeData->m_acts_phi[m_treeData->m_g4_steps] = actsParameters ? actsParameters->momentum().phi() : 0.;
340  m_treeData->m_acts_x[m_treeData->m_g4_steps] = actsParameters ? actsParameters->position(gctx.context()).x() : 0.;
341  m_treeData->m_acts_y[m_treeData->m_g4_steps] = actsParameters ? actsParameters->position(gctx.context()).y() : 0.;
342  m_treeData->m_acts_z[m_treeData->m_g4_steps] = actsParameters ? actsParameters->position(gctx.context()).z() : 0.;
343  // Incremental extrapolation, the extrapolation correspond to one step
344  if(m_extrapolateIncrementally || m_treeData->m_g4_steps == 0){
345  float tActs = (actsParameters->position(gctx.context()) - m_actsParameterCache->position(gctx.context())).norm();
346  m_tX0CacheActs += X0Acts;
347  m_treeData->m_acts_tX0[m_treeData->m_g4_steps] = X0Acts;
348  m_treeData->m_acts_accX0[m_treeData->m_g4_steps] = m_tX0CacheActs;
349  m_treeData->m_acts_t[m_treeData->m_g4_steps] = tActs;
350  m_treeData->m_acts_X0[m_treeData->m_g4_steps] = tActs/X0Acts;
351  }
352  // Extrapolation perform from the start, step varaible need to be computed by comparing to the last extrapolation.
353  else{
354  Acts::Vector3 previousPos(m_treeData->m_acts_x[m_treeData->m_g4_steps-1],
355  m_treeData->m_acts_y[m_treeData->m_g4_steps-1],
356  m_treeData->m_acts_z[m_treeData->m_g4_steps-1]);
357  float tActs = (actsParameters->position(gctx.context()) - previousPos).norm();
358  m_treeData->m_acts_tX0[m_treeData->m_g4_steps] = X0Acts - m_treeData->m_acts_accX0[m_treeData->m_g4_steps-1] ;
359  m_treeData->m_acts_accX0[m_treeData->m_g4_steps] = X0Acts;
360  m_treeData->m_acts_t[m_treeData->m_g4_steps] = tActs;
361  m_treeData->m_acts_X0[m_treeData->m_g4_steps] = tActs/m_treeData->m_acts_tX0[m_treeData->m_g4_steps];
362  }
363 
364  // update the parameters if needed/configured
365  if (m_extrapolateIncrementally && trkParameters && actsParameters) {
366  delete m_parameterCache;
367  m_actsParameterCache.reset();
368  m_parameterCache = trkParameters;
369  m_actsParameterCache = actsParameters;
370  }
371  // delete cache and increment
372  delete g4Parameters;
373  destinationSurfaceActs.reset();
374  m_tX0NonSensitiveCache = 0.;
375  m_tNonSensitiveCache = 0.;
376  ++m_treeData->m_g4_steps;
377 }

Member Data Documentation

◆ m_actsExtrapolator

ToolHandle<IActsExtrapolationTool> ActsGeantFollowerHelper::m_actsExtrapolator
private

Definition at line 59 of file ActsGeantFollowerHelper.h.

◆ m_actsParameterCache

std::optional<Acts::BoundTrackParameters> ActsGeantFollowerHelper::m_actsParameterCache
private

Definition at line 64 of file ActsGeantFollowerHelper.h.

◆ m_actsSurfaceCache

std::unique_ptr<std::vector<Acts::SurfaceHit> > ActsGeantFollowerHelper::m_actsSurfaceCache
private

Definition at line 65 of file ActsGeantFollowerHelper.h.

◆ m_actsSurfaceIterator

std::vector<Acts::SurfaceHit>::iterator ActsGeantFollowerHelper::m_actsSurfaceIterator
private

Definition at line 66 of file ActsGeantFollowerHelper.h.

◆ m_extrapolateDirectly

bool ActsGeantFollowerHelper::m_extrapolateDirectly
private

Definition at line 60 of file ActsGeantFollowerHelper.h.

◆ m_extrapolateIncrementally

bool ActsGeantFollowerHelper::m_extrapolateIncrementally
private

Definition at line 61 of file ActsGeantFollowerHelper.h.

◆ m_extrapolationEngine

ToolHandle<Trk::IExtrapolationEngine> ActsGeantFollowerHelper::m_extrapolationEngine
private

Definition at line 58 of file ActsGeantFollowerHelper.h.

◆ m_parameterCache

Trk::TrackParameters* ActsGeantFollowerHelper::m_parameterCache
private

Definition at line 63 of file ActsGeantFollowerHelper.h.

◆ m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis ActsGeantFollowerHelper::m_pdgToParticleHypothesis
private

Definition at line 68 of file ActsGeantFollowerHelper.h.

◆ m_tNonSensitiveCache

float ActsGeantFollowerHelper::m_tNonSensitiveCache
private

Definition at line 71 of file ActsGeantFollowerHelper.h.

◆ m_treeData

std::unique_ptr<TreeData> ActsGeantFollowerHelper::m_treeData
private

Definition at line 138 of file ActsGeantFollowerHelper.h.

◆ m_tX0Cache

float ActsGeantFollowerHelper::m_tX0Cache
private

Definition at line 69 of file ActsGeantFollowerHelper.h.

◆ m_tX0CacheActs

float ActsGeantFollowerHelper::m_tX0CacheActs
private

Definition at line 72 of file ActsGeantFollowerHelper.h.

◆ m_tX0CacheATLAS

float ActsGeantFollowerHelper::m_tX0CacheATLAS
private

Definition at line 73 of file ActsGeantFollowerHelper.h.

◆ m_tX0NonSensitiveCache

float ActsGeantFollowerHelper::m_tX0NonSensitiveCache
private

Definition at line 70 of file ActsGeantFollowerHelper.h.

◆ m_validationTree

TTree* ActsGeantFollowerHelper::m_validationTree
private

Root Validation Tree.

Definition at line 80 of file ActsGeantFollowerHelper.h.

◆ m_validationTreeDescription

std::string ActsGeantFollowerHelper::m_validationTreeDescription
private

validation tree description - second argument in TTree

Definition at line 77 of file ActsGeantFollowerHelper.h.

◆ m_validationTreeFolder

std::string ActsGeantFollowerHelper::m_validationTreeFolder
private

stream/folder to for the TTree to be written out

Definition at line 78 of file ActsGeantFollowerHelper.h.

◆ m_validationTreeName

std::string ActsGeantFollowerHelper::m_validationTreeName
private

validation tree name - to be acessed by this from root

Definition at line 76 of file ActsGeantFollowerHelper.h.

The documentation for this class was generated from the following files:
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
ActsGeantFollowerHelper::m_extrapolateIncrementally
bool m_extrapolateIncrementally
Definition: ActsGeantFollowerHelper.h:61
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Trk::locX
@ locX
Definition: ParamDefs.h:37
Trk::PdgToParticleHypothesis::convert
Trk::ParticleHypothesis convert(int pdg, bool &stable, bool &exiting, double charge=1.) const
Converter method : PDG -> Particle Hyptothesis.
Trk::locY
@ locY
local cartesian
Definition: ParamDefs.h:38
Base_Fragment.mass
mass
Definition: Sherpa_i/share/common/Base_Fragment.py:59
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
Trk::CurvilinearParameters
CurvilinearParametersT< TrackParametersDim, Charged, PlaneSurface > CurvilinearParameters
Definition: Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:29
ActsGeantFollowerHelper::m_extrapolateDirectly
bool m_extrapolateDirectly
Definition: ActsGeantFollowerHelper.h:60
python.SystemOfUnits.MeV
int MeV
Definition: SystemOfUnits.py:154
ActsGeantFollowerHelper::m_tX0CacheATLAS
float m_tX0CacheATLAS
Definition: ActsGeantFollowerHelper.h:73
ActsGeantFollowerHelper::m_treeData
std::unique_ptr< TreeData > m_treeData
Definition: ActsGeantFollowerHelper.h:138
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
Trk::Surface::center
const Amg::Vector3D & center() const
Returns the center position of the Surface.
x
#define x
ActsGeantFollowerHelper::m_actsExtrapolator
ToolHandle< IActsExtrapolationTool > m_actsExtrapolator
Definition: ActsGeantFollowerHelper.h:59
ActsGeantFollowerHelper::m_tX0Cache
float m_tX0Cache
Definition: ActsGeantFollowerHelper.h:69
ActsGeantFollowerHelper::m_tX0NonSensitiveCache
float m_tX0NonSensitiveCache
Definition: ActsGeantFollowerHelper.h:70
ActsGeantFollowerHelper::m_parameterCache
Trk::TrackParameters * m_parameterCache
Definition: ActsGeantFollowerHelper.h:63
pdg_comparison.X0
X0
Definition: pdg_comparison.py:314
ActsGeometryContext::context
Acts::GeometryContext context() const
Definition: ActsGeometryContext.h:45
Trk::ParticleHypothesis
ParticleHypothesis
Definition: ParticleHypothesis.h:25
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
ParticleGun_EoverP_Config.mom
mom
Definition: ParticleGun_EoverP_Config.py:63
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
ActsGeantFollowerHelper::m_extrapolationEngine
ToolHandle< Trk::IExtrapolationEngine > m_extrapolationEngine
Definition: ActsGeantFollowerHelper.h:58
z
#define z
beamspotman.n
n
Definition: beamspotman.py:731
ActsGeantFollowerHelper::m_validationTree
TTree * m_validationTree
Root Validation Tree.
Definition: ActsGeantFollowerHelper.h:80
Trk::Surface::normal
virtual const Amg::Vector3D & normal() const
Returns the normal vector of the Surface (i.e.
ActsGeantFollowerHelper::m_validationTreeFolder
std::string m_validationTreeFolder
stream/folder to for the TTree to be written out
Definition: ActsGeantFollowerHelper.h:78
Trk::ParametersBase
Definition: ParametersBase.h:55
Trk::CurvilinearParametersT
Definition: CurvilinearParametersT.h:48
ActsGeantFollowerHelper::m_validationTreeDescription
std::string m_validationTreeDescription
validation tree description - second argument in TTree
Definition: ActsGeantFollowerHelper.h:77
ActsGeantFollowerHelper::m_tNonSensitiveCache
float m_tNonSensitiveCache
Definition: ActsGeantFollowerHelper.h:71
ActsGeometryContext
Include the GeoPrimitives which need to be put first.
Definition: ActsGeometryContext.h:27
beamspotman.dir
string dir
Definition: beamspotman.py:623
Trk::ParticleMasses::mass
constexpr double mass[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:53
Trk::CurvilinearParametersT::associatedSurface
virtual const S & associatedSurface() const override final
Access to the Surface method.
Trk::ParametersBase::pT
double pT() const
Access method for transverse momentum.
charge
double charge(const T &p)
Definition: AtlasPID.h:756
xAOD::ParticleHypothesis
ParticleHypothesis
Definition: TrackingPrimitives.h:192
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition: GeoPrimitives.h:47
ActsGeantFollowerHelper::m_pdgToParticleHypothesis
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
Definition: ActsGeantFollowerHelper.h:68
Trk::ExtrapolationMode::CollectMaterial
@ CollectMaterial
Definition: ExtrapolationCell.h:59
ActsGeantFollowerHelper::m_validationTreeName
std::string m_validationTreeName
validation tree name - to be acessed by this from root
Definition: ActsGeantFollowerHelper.h:76
ActsGeantFollowerHelper::m_actsParameterCache
std::optional< Acts::BoundTrackParameters > m_actsParameterCache
Definition: ActsGeantFollowerHelper.h:64
ActsGeantFollowerHelper::m_tX0CacheActs
float m_tX0CacheActs
Definition: ActsGeantFollowerHelper.h:72
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:18
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
Trk::ExtrapolationCell
Definition: ExtrapolationCell.h:231
y
#define y
MAXPROBES
#define MAXPROBES
Definition: ActsGeantFollowerHelper.h:22
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trk::PlaneSurface
Definition: PlaneSurface.h:64
if
if(febId1==febId2)
Definition: LArRodBlockPhysicsV0.cxx:567
Trk::ExtrapolationMode::StopAtBoundary
@ StopAtBoundary
Definition: ExtrapolationCell.h:55
Generated on Mon Dec 23 2024 21:25:37 for ATLAS Offline Software by   doxygen 1.8.18