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< IActsExtrapolationTool > 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 35 of file ActsGeantFollowerHelper.cxx.

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

◆ ~ActsGeantFollowerHelper()

virtual ActsGeantFollowerHelper::~ActsGeantFollowerHelper ( )
virtualdefault

Member Function Documentation

◆ beginEvent()

void ActsGeantFollowerHelper::beginEvent ( )
overridevirtual

Definition at line 133 of file ActsGeantFollowerHelper.cxx.

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

◆ endEvent()

void ActsGeantFollowerHelper::endEvent ( )
overridevirtual

Definition at line 352 of file ActsGeantFollowerHelper.cxx.

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

◆ finalize()

StatusCode ActsGeantFollowerHelper::finalize ( )
overridevirtual

Definition at line 128 of file ActsGeantFollowerHelper.cxx.

129 {
130  return StatusCode::SUCCESS;
131 }

◆ initialize()

StatusCode ActsGeantFollowerHelper::initialize ( )
overridevirtual

Definition at line 46 of file ActsGeantFollowerHelper.cxx.

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

◆ trackParticle()

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

Definition at line 152 of file ActsGeantFollowerHelper.cxx.

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

Member Data Documentation

◆ m_actsExtrapolator

ToolHandle<IActsExtrapolationTool> 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:
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_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
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
ActsGeometryContext::context
Acts::GeometryContext context() const
Definition: ActsGeometryContext.h:45
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:729
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
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:621
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:986
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
Generated on Sun Aug 31 2025 21:26:34 for ATLAS Offline Software by   doxygen 1.8.18