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 ()=default
 
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

PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}
 
ToolHandle< Trk::IExtrapolationEngine > m_extrapolationEngine {this, "ExtrapolationEngine", ""}
 
ToolHandle< ActsTrk::IExtrapolationTool > m_actsExtrapolator {this, "ActsExtrapolator", ""}
 
Gaudi::Property< bool > m_extrapolateDirectly {this, "ExtrapolateDirectly", true}
 
Gaudi::Property< bool > m_extrapolateIncrementally {this, "ExtrapolateIncrementally", true}
 
Trk::TrackParameters * m_parameterCache {nullptr}
 
std::optional< Acts::BoundTrackParameters > m_actsParameterCache {std::nullopt}
 
std::unique_ptr< std::vector< Acts::SurfaceHit > > m_actsSurfaceCache {}
 
std::vector< Acts::SurfaceHit >::iterator m_actsSurfaceIterator {}
 
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
 
float m_tX0Cache {0.f}
 
float m_tX0NonSensitiveCache {0.f}
 
float m_tNonSensitiveCache {0.f}
 
float m_tX0CacheActs {0.f}
 
float m_tX0CacheATLAS {0.f}
 
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 {nullptr}
 Root Validation Tree. More...
 
std::unique_ptr< TreeData > m_treeData
 

Detailed Description

Definition at line 34 of file ActsGeantFollowerHelper.h.

Constructor & Destructor Documentation

◆ ActsGeantFollowerHelper()

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

Definition at line 33 of file ActsGeantFollowerHelper.cxx.

33  :
34  base_class(t,n,p),
35  m_validationTreeName("G4Follower_"+n),
36  m_validationTreeDescription("Output of the G4Follower_"),
37  m_validationTreeFolder("/val/G4Follower_"+n),
38  m_validationTree(nullptr){}

◆ ~ActsGeantFollowerHelper()

virtual ActsGeantFollowerHelper::~ActsGeantFollowerHelper ( )
virtualdefault

Member Function Documentation

◆ beginEvent()

void ActsGeantFollowerHelper::beginEvent ( )
overridevirtual

Definition at line 131 of file ActsGeantFollowerHelper.cxx.

132 {
133  m_treeData->m_t_x = 0.;
134  m_treeData->m_t_y = 0.;
135  m_treeData->m_t_z = 0.;
136  m_treeData->m_t_theta = 0.;
137  m_treeData->m_t_eta = 0.;
138  m_treeData->m_t_phi = 0.;
139  m_treeData->m_t_p = 0.;
140  m_treeData->m_t_charge = 0.;
141  m_treeData->m_t_pdg = 0;
142  m_treeData->m_g4_steps = 0;
143  m_tX0Cache = 0.;
144  m_tX0NonSensitiveCache = 0.;
145  m_tNonSensitiveCache = 0.;
146  m_tX0CacheActs = 0.;
147  m_tX0CacheATLAS = 0.;
148 }

◆ endEvent()

void ActsGeantFollowerHelper::endEvent ( )
overridevirtual

Definition at line 350 of file ActsGeantFollowerHelper.cxx.

351 {
352  if (m_tX0Cache != 0)
353  {
354  // fill the validation tree
355  m_validationTree->Fill();
356  delete m_parameterCache;
357  m_actsParameterCache.reset();
358  }
359 }

◆ finalize()

StatusCode ActsGeantFollowerHelper::finalize ( )
overridevirtual

Definition at line 126 of file ActsGeantFollowerHelper.cxx.

127 {
128  return StatusCode::SUCCESS;
129 }

◆ initialize()

StatusCode ActsGeantFollowerHelper::initialize ( )
overridevirtual

Definition at line 44 of file ActsGeantFollowerHelper.cxx.

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

◆ trackParticle()

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

Definition at line 150 of file ActsGeantFollowerHelper.cxx.

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

Member Data Documentation

◆ m_actsExtrapolator

ToolHandle<ActsTrk::IExtrapolationTool> ActsGeantFollowerHelper::m_actsExtrapolator {this, "ActsExtrapolator", ""}
private

Definition at line 59 of file ActsGeantFollowerHelper.h.

◆ m_actsParameterCache

std::optional<Acts::BoundTrackParameters> ActsGeantFollowerHelper::m_actsParameterCache {std::nullopt}
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

Gaudi::Property<bool> ActsGeantFollowerHelper::m_extrapolateDirectly {this, "ExtrapolateDirectly", true}
private

Definition at line 60 of file ActsGeantFollowerHelper.h.

◆ m_extrapolateIncrementally

Gaudi::Property<bool> ActsGeantFollowerHelper::m_extrapolateIncrementally {this, "ExtrapolateIncrementally", true}
private

Definition at line 61 of file ActsGeantFollowerHelper.h.

◆ m_extrapolationEngine

ToolHandle<Trk::IExtrapolationEngine> ActsGeantFollowerHelper::m_extrapolationEngine {this, "ExtrapolationEngine", ""}
private

Definition at line 58 of file ActsGeantFollowerHelper.h.

◆ m_parameterCache

Trk::TrackParameters* ActsGeantFollowerHelper::m_parameterCache {nullptr}
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 {0.f}
private

Definition at line 71 of file ActsGeantFollowerHelper.h.

◆ m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> ActsGeantFollowerHelper::m_trackingGeometryTool {this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}
private

Definition at line 55 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 {0.f}
private

Definition at line 69 of file ActsGeantFollowerHelper.h.

◆ m_tX0CacheActs

float ActsGeantFollowerHelper::m_tX0CacheActs {0.f}
private

Definition at line 72 of file ActsGeantFollowerHelper.h.

◆ m_tX0CacheATLAS

float ActsGeantFollowerHelper::m_tX0CacheATLAS {0.f}
private

Definition at line 73 of file ActsGeantFollowerHelper.h.

◆ m_tX0NonSensitiveCache

float ActsGeantFollowerHelper::m_tX0NonSensitiveCache {0.f}
private

Definition at line 70 of file ActsGeantFollowerHelper.h.

◆ m_validationTree

TTree* ActsGeantFollowerHelper::m_validationTree {nullptr}
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:
ActsGeantFollowerHelper::m_actsExtrapolator
ToolHandle< ActsTrk::IExtrapolationTool > m_actsExtrapolator
Definition: ActsGeantFollowerHelper.h:59
AllowedVariables::e
e
Definition: AsgElectronSelectorTool.cxx:37
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
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_extrapolateIncrementally
Gaudi::Property< bool > m_extrapolateIncrementally
Definition: ActsGeantFollowerHelper.h:61
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_tX0Cache
float m_tX0Cache
Definition: ActsGeantFollowerHelper.h:69
ActsGeantFollowerHelper::m_tX0NonSensitiveCache
float m_tX0NonSensitiveCache
Definition: ActsGeantFollowerHelper.h:70
python.SystemOfUnits.MeV
float MeV
Definition: SystemOfUnits.py:172
ActsGeantFollowerHelper::m_parameterCache
Trk::TrackParameters * m_parameterCache
Definition: ActsGeantFollowerHelper.h:63
pdg_comparison.X0
X0
Definition: pdg_comparison.py:314
Trk::ParticleHypothesis
ParticleHypothesis
Definition: ParticleHypothesis.h:28
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
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:727
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.
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
ActsGeantFollowerHelper::m_validationTreeFolder
std::string m_validationTreeFolder
stream/folder to for the TTree to be written out
Definition: ActsGeantFollowerHelper.h:78
hist_file_dump.f
f
Definition: hist_file_dump.py:140
Trk::ParametersBase
Definition: ParametersBase.h:55
Trk::CurvilinearParametersT
Definition: CurvilinearParametersT.h:48
ActsTrk::GeometryContext
Definition: GeometryContext.h:28
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
beamspotman.dir
string dir
Definition: beamspotman.py:619
Trk::ParticleMasses::mass
constexpr double mass[PARTICLEHYPOTHESES]
the array of masses
Definition: ParticleHypothesis.h:56
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:997
xAOD::ParticleHypothesis
ParticleHypothesis
Definition: TrackingPrimitives.h:193
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:16
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
ActsGeantFollowerHelper::m_trackingGeometryTool
PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool
Definition: ActsGeantFollowerHelper.h:55
Trk::ExtrapolationCell
Definition: ExtrapolationCell.h:231
y
#define y
MAXPROBES
#define MAXPROBES
Definition: ActsGeantFollowerHelper.h:24
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
ActsTrk::GeometryContext::context
Acts::GeometryContext context() const
Definition: GeometryContext.h:46
Generated on Wed Nov 5 2025 21:26:41 for ATLAS Offline Software by   doxygen 1.8.18