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

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

◆ ~ActsGeantFollowerHelper()

ActsGeantFollowerHelper::~ActsGeantFollowerHelper ( )
virtual

Definition at line 61 of file ActsGeantFollowerHelper.cxx.

62 {}

Member Function Documentation

◆ beginEvent()

void ActsGeantFollowerHelper::beginEvent ( )
overridevirtual

Definition at line 159 of file ActsGeantFollowerHelper.cxx.

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

◆ endEvent()

void ActsGeantFollowerHelper::endEvent ( )
overridevirtual

Definition at line 378 of file ActsGeantFollowerHelper.cxx.

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

◆ finalize()

StatusCode ActsGeantFollowerHelper::finalize ( )
overridevirtual

Definition at line 154 of file ActsGeantFollowerHelper.cxx.

155 {
156  return StatusCode::SUCCESS;
157 }

◆ initialize()

StatusCode ActsGeantFollowerHelper::initialize ( )
overridevirtual

Definition at line 66 of file ActsGeantFollowerHelper.cxx.

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

◆ trackParticle()

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

Definition at line 178 of file ActsGeantFollowerHelper.cxx.

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

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:
PlotCalibFromCool.norm
norm
Definition: PlotCalibFromCool.py:100
ActsGeantFollowerHelper::m_extrapolateIncrementally
bool m_extrapolateIncrementally
Definition: ActsGeantFollowerHelper.h:61
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
max
#define max(a, b)
Definition: cfImp.cxx:41
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
Trk::locX
@ locX
Definition: ParamDefs.h:43
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:44
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
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
dqt_zlumi_pandas.mass
mass
Definition: dqt_zlumi_pandas.py:170
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:46
Trk::ParticleHypothesis
ParticleHypothesis
Definition: ParticleHypothesis.h:25
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::CurvilinearParameters
CurvilinearParametersT< 5, Charged, PlaneSurface > CurvilinearParameters
Definition: Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:25
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:28
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:494
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
DiTauMassTools::MaxHistStrategyV2::e
e
Definition: PhysicsAnalysis/TauID/DiTauMassTools/DiTauMassTools/HelperFunctions.h:26
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:569
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
Trk::ExtrapolationMode::StopAtBoundary
@ StopAtBoundary
Definition: ExtrapolationCell.h:55
Generated on Tue Jul 2 2024 21:36:32 for ATLAS Offline Software by   doxygen 1.8.18