ATLAS Offline Software
Loading...
Searching...
No Matches
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
std::string m_validationTreeDescription
 validation tree description - second argument in TTree
std::string m_validationTreeFolder
 stream/folder to for the TTree to be written out
TTree * m_validationTree {nullptr}
 Root Validation Tree.
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::m_validationTreeFolder
std::string m_validationTreeFolder
stream/folder to for the TTree to be written out
Definition ActsGeantFollowerHelper.h:78
ActsGeantFollowerHelper::m_validationTreeName
std::string m_validationTreeName
validation tree name - to be acessed by this from root
Definition ActsGeantFollowerHelper.h:76
ActsGeantFollowerHelper::m_validationTreeDescription
std::string m_validationTreeDescription
validation tree description - second argument in TTree
Definition ActsGeantFollowerHelper.h:77
ActsGeantFollowerHelper::m_validationTree
TTree * m_validationTree
Root Validation Tree.
Definition ActsGeantFollowerHelper.h:80

◆ ~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}
ActsGeantFollowerHelper::m_treeData
std::unique_ptr< TreeData > m_treeData
Definition ActsGeantFollowerHelper.h:138

◆ endEvent()

void ActsGeantFollowerHelper::endEvent ( )
overridevirtual

Definition at line 354 of file ActsGeantFollowerHelper.cxx.

355{
356 if (m_tX0Cache != 0)
357 {
358 // fill the validation tree
359 m_validationTree->Fill();
360 delete m_parameterCache;
361 m_actsParameterCache.reset();
362 }
363}
ActsGeantFollowerHelper::m_parameterCache
Trk::TrackParameters * m_parameterCache
Definition ActsGeantFollowerHelper.h:63
ActsGeantFollowerHelper::m_actsParameterCache
std::optional< Acts::BoundTrackParameters > m_actsParameterCache
Definition ActsGeantFollowerHelper.h:64

◆ 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}
ATH_CHECK
#define ATH_CHECK
Evaluate an expression and check for errors.
Definition AthCheckMacros.h:40
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition AthMsgStreamMacros.h:33
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition AthMsgStreamMacros.h:31
ActsGeantFollowerHelper::m_actsExtrapolator
ToolHandle< ActsTrk::IExtrapolationTool > m_actsExtrapolator
Definition ActsGeantFollowerHelper.h:59
ActsGeantFollowerHelper::m_extrapolationEngine
ToolHandle< Trk::IExtrapolationEngine > m_extrapolationEngine
Definition ActsGeantFollowerHelper.h:58
ActsGeantFollowerHelper::m_trackingGeometryTool
PublicToolHandle< ActsTrk::ITrackingGeometryTool > m_trackingGeometryTool
Definition ActsGeantFollowerHelper.h:55

◆ 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, static_cast<float>(charge)};
193 m_actsParameterCache = Acts::BoundTrackParameters::create(
194 gctx.context(), surface, actsStart, dir, charge/(mom.mag()/1000), std::nullopt, hypothesis)
195 .value();
196 }
197
198 // Store material in cache
199 float tX0 = X0 > 10e-5f ? t/X0 : 0.f;
200 m_tX0NonSensitiveCache += tX0;
201 m_tNonSensitiveCache += t;
202 if (!isSensitive)
203 {
204 return;
205 }
206
207 // jumping over inital step
208 m_treeData->m_g4_steps = (m_treeData->m_g4_steps == -1) ? 0 : m_treeData->m_g4_steps;
209
210 if (!m_parameterCache){
211 ATH_MSG_WARNING("No Parameters available. Bailing out.");
212 return;
213 }
214
215 if ( m_treeData->m_g4_steps >= MAXPROBES) {
216 ATH_MSG_WARNING("Maximum number of " << MAXPROBES << " reached, step is ignored.");
217 return;
218 }
219 // parameters of the G4 step point
220 Trk::CurvilinearParameters* g4Parameters = new Trk::CurvilinearParameters(npos, nmom, m_treeData->m_t_charge);
221 // destination surface
222 const Trk::PlaneSurface& destinationSurface = g4Parameters->associatedSurface();
223 // extrapolate to the destination surface
224 Trk::ExtrapolationCell<Trk::TrackParameters> ecc(*m_parameterCache);
225 ecc.setParticleHypothesis((Trk::ParticleHypothesis) particleHypo);
226 ecc.addConfigurationMode(Trk::ExtrapolationMode::StopAtBoundary);
227 ecc.addConfigurationMode(Trk::ExtrapolationMode::CollectMaterial);
228 // call the extrapolation engine
229 auto eCodeSteps = m_extrapolationEngine->extrapolate(ecc, &destinationSurface);
230 Trk::TrackParameters *trkParameters = ecc.endParameters;
231 float X0ATLAS = ecc.materialX0;
232
233 if(eCodeSteps.code != 2 ){
234 ATH_MSG_ERROR("Error in the Extrapolator Engine, skip the current step");
235 return;
236 }
237
238 // create a Acts::Surface that correspond to the Trk::Surface
239 auto destinationSurfaceActs = Acts::CurvilinearSurface(destinationSurface.center(), destinationSurface.normal()).planeSurface();
240 Acts::Result<Acts::BoundTrackParameters> actsParameters = m_actsExtrapolator->propagate(ctx,
241 *m_actsParameterCache,
242 *destinationSurfaceActs,
243 Acts::Direction::Forward(),
244 std::numeric_limits<double>::max());
245 if(not actsParameters.ok()){
246 ATH_MSG_ERROR("Error in the Acts extrapolation, skip the current step");
247 return;
248 }
249
250 auto actsSteps = m_actsExtrapolator->propagationSteps(ctx,
251 *m_actsParameterCache,
252 *destinationSurfaceActs,
253 Acts::Direction::Forward(),
254 std::numeric_limits<double>::max());
255 if(not actsSteps.ok()){
256 ATH_MSG_ERROR("Error in the Acts extrapolation, skip the current step");
257 return;
258 }
259 float X0Acts = actsSteps->second.materialInX0;
260
261 int volID = trackingGeometry->lowestTrackingVolume(gctx.context(), actsParameters->position(gctx.context()))->geometryId().volume();
262
263 // fill the geant information and the trk information
264 m_treeData->m_g4_pt[m_treeData->m_g4_steps] = mom.mag()/std::cosh(mom.eta());
265 m_treeData->m_g4_eta[m_treeData->m_g4_steps] = mom.eta();
266 m_treeData->m_g4_theta[m_treeData->m_g4_steps] = mom.theta();
267 m_treeData->m_g4_phi[m_treeData->m_g4_steps] = mom.phi();
268 m_treeData->m_g4_x[m_treeData->m_g4_steps] = pos.x();
269 m_treeData->m_g4_y[m_treeData->m_g4_steps] = pos.y();
270 m_treeData->m_g4_z[m_treeData->m_g4_steps] = pos.z();
271
272 m_tX0Cache += m_tX0NonSensitiveCache;
273 m_treeData->m_g4_tX0[m_treeData->m_g4_steps] = m_tX0NonSensitiveCache;
274 m_treeData->m_g4_accX0[m_treeData->m_g4_steps] = m_tX0Cache;
275 m_treeData->m_g4_t[m_treeData->m_g4_steps] = m_tNonSensitiveCache;
276 m_treeData->m_g4_X0[m_treeData->m_g4_steps] = m_tNonSensitiveCache/m_tX0NonSensitiveCache;
277
278 m_treeData->m_trk_status[m_treeData->m_g4_steps] = trkParameters ? 1 : 0;
279 m_treeData->m_trk_pt[m_treeData->m_g4_steps] = trkParameters ? trkParameters->pT() : 0.;
280 m_treeData->m_trk_eta[m_treeData->m_g4_steps] = trkParameters ? trkParameters->momentum().eta() : 0.;
281 m_treeData->m_trk_theta[m_treeData->m_g4_steps] = trkParameters ? trkParameters->momentum().theta() : 0.;
282 m_treeData->m_trk_phi[m_treeData->m_g4_steps] = trkParameters ? trkParameters->momentum().phi() : 0.;
283 m_treeData->m_trk_x[m_treeData->m_g4_steps] = trkParameters ? trkParameters->position().x() : 0.;
284 m_treeData->m_trk_y[m_treeData->m_g4_steps] = trkParameters ? trkParameters->position().y() : 0.;
285 m_treeData->m_trk_z[m_treeData->m_g4_steps] = trkParameters ? trkParameters->position().z() : 0.;
286 m_treeData->m_trk_lx[m_treeData->m_g4_steps] = trkParameters ? trkParameters->parameters()[Trk::locX] : 0.;
287 m_treeData->m_trk_ly[m_treeData->m_g4_steps] = trkParameters ? trkParameters->parameters()[Trk::locY] : 0.;
288 // Incremental extrapolation, the extrapolation correspond to one step
289 if(m_extrapolateIncrementally || m_treeData->m_g4_steps == 0){
290 float tATLAS = (trkParameters->position() - m_parameterCache->position()).norm();
291 m_tX0CacheATLAS += X0ATLAS;
292 m_treeData->m_trk_tX0[m_treeData->m_g4_steps] = X0ATLAS;
293 m_treeData->m_trk_accX0[m_treeData->m_g4_steps] = m_tX0CacheATLAS;
294 m_treeData->m_trk_t[m_treeData->m_g4_steps] = tATLAS;
295 m_treeData->m_trk_X0[m_treeData->m_g4_steps] = tATLAS/X0ATLAS;
296 }
297 // Extrapolation perform from the start, step varaible need to be computed by comparing to the last extrapolation.
298 else{
299 Amg::Vector3D previousPos(m_treeData->m_trk_x[m_treeData->m_g4_steps-1],
300 m_treeData->m_trk_y[m_treeData->m_g4_steps-1],
301 m_treeData->m_trk_z[m_treeData->m_g4_steps-1]);
302 float tATLAS = (trkParameters->position() - previousPos).norm();
303 m_treeData->m_trk_tX0[m_treeData->m_g4_steps] = X0ATLAS - m_treeData->m_trk_accX0[m_treeData->m_g4_steps-1] ;
304 m_treeData->m_trk_accX0[m_treeData->m_g4_steps] = X0ATLAS;
305 m_treeData->m_trk_t[m_treeData->m_g4_steps] = tATLAS;
306 m_treeData->m_trk_X0[m_treeData->m_g4_steps] = tATLAS/m_treeData->m_trk_tX0[m_treeData->m_g4_steps];
307 }
308
309 m_treeData->m_acts_status[m_treeData->m_g4_steps] = actsParameters.ok() ? 1 : 0;
310 m_treeData->m_acts_volumeID[m_treeData->m_g4_steps] = actsParameters.ok() ? volID : 0;
311 m_treeData->m_acts_pt[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->transverseMomentum()*1000 : 0.;
312 m_treeData->m_acts_eta[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->momentum().eta() : 0.;
313 m_treeData->m_acts_theta[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->momentum().theta() : 0.;
314 m_treeData->m_acts_phi[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->momentum().phi() : 0.;
315 m_treeData->m_acts_x[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->position(gctx.context()).x() : 0.;
316 m_treeData->m_acts_y[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->position(gctx.context()).y() : 0.;
317 m_treeData->m_acts_z[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->position(gctx.context()).z() : 0.;
318 // Incremental extrapolation, the extrapolation correspond to one step
319 if(m_extrapolateIncrementally || m_treeData->m_g4_steps == 0){
320 float tActs = (actsParameters->position(gctx.context()) - m_actsParameterCache->position(gctx.context())).norm();
321 m_tX0CacheActs += X0Acts;
322 m_treeData->m_acts_tX0[m_treeData->m_g4_steps] = X0Acts;
323 m_treeData->m_acts_accX0[m_treeData->m_g4_steps] = m_tX0CacheActs;
324 m_treeData->m_acts_t[m_treeData->m_g4_steps] = tActs;
325 m_treeData->m_acts_X0[m_treeData->m_g4_steps] = tActs/X0Acts;
326 }
327 // Extrapolation perform from the start, step varaible need to be computed by comparing to the last extrapolation.
328 else{
329 Acts::Vector3 previousPos(m_treeData->m_acts_x[m_treeData->m_g4_steps-1],
330 m_treeData->m_acts_y[m_treeData->m_g4_steps-1],
331 m_treeData->m_acts_z[m_treeData->m_g4_steps-1]);
332 float tActs = (actsParameters->position(gctx.context()) - previousPos).norm();
333 m_treeData->m_acts_tX0[m_treeData->m_g4_steps] = X0Acts - m_treeData->m_acts_accX0[m_treeData->m_g4_steps-1] ;
334 m_treeData->m_acts_accX0[m_treeData->m_g4_steps] = X0Acts;
335 m_treeData->m_acts_t[m_treeData->m_g4_steps] = tActs;
336 m_treeData->m_acts_X0[m_treeData->m_g4_steps] = tActs/m_treeData->m_acts_tX0[m_treeData->m_g4_steps];
337 }
338
339 // update the parameters if needed/configured
340 if (m_extrapolateIncrementally && trkParameters && actsParameters.ok()) {
341 delete m_parameterCache;
342 m_actsParameterCache.reset();
343 m_parameterCache = trkParameters;
344 m_actsParameterCache = actsParameters.value();
345 }
346 // delete cache and increment
347 delete g4Parameters;
348 destinationSurfaceActs.reset();
349 m_tX0NonSensitiveCache = 0.;
350 m_tNonSensitiveCache = 0.;
351 ++m_treeData->m_g4_steps;
352}
MAXPROBES
#define MAXPROBES
Definition ActsGeantFollowerHelper.h:24
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
charge
double charge(const T &p)
Definition AtlasPID.h:997
ActsGeantFollowerHelper::m_pdgToParticleHypothesis
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
Definition ActsGeantFollowerHelper.h:68
ActsGeantFollowerHelper::m_extrapolateIncrementally
Gaudi::Property< bool > m_extrapolateIncrementally
Definition ActsGeantFollowerHelper.h:61
ActsTrk::GeometryContext::context
Acts::GeometryContext context() const
Definition GeometryContext.h:46
Trk::CurvilinearParametersT::associatedSurface
virtual const S & associatedSurface() const override final
Access to the Surface method.
Trk::ParametersBase::momentum
const Amg::Vector3D & momentum() const
Access method for the momentum.
Trk::ParametersBase::position
const Amg::Vector3D & position() const
Access method for the position.
Trk::ParametersBase::pT
double pT() const
Access method for transverse momentum.
Trk::Surface::normal
virtual const Amg::Vector3D & normal() const
Returns the normal vector of the Surface (i.e.
Trk::Surface::center
const Amg::Vector3D & center() const
Returns the center position of the Surface.
Amg::Vector3D
Eigen::Matrix< double, 3, 1 > Vector3D
Definition GeoPrimitives.h:47
Base_Fragment.mass
mass
Definition Sherpa_i/share/common/Base_Fragment.py:59
ParticleGun_EoverP_Config.mom
mom
Definition ParticleGun_EoverP_Config.py:63
Trk::ParticleMasses::mass
constexpr double mass[PARTICLEHYPOTHESES]
the array of masses
Definition ParticleHypothesis.h:56
Trk::CurvilinearParameters
CurvilinearParametersT< TrackParametersDim, Charged, PlaneSurface > CurvilinearParameters
Definition Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:29
Trk::locY
@ locY
local cartesian
Definition ParamDefs.h:38
Trk::locX
@ locX
Definition ParamDefs.h:37
Trk::ParticleHypothesis
ParticleHypothesis
Enumeration for Particle hypothesis respecting the interaction with material.
Definition ParticleHypothesis.h:28
Trk::TrackParameters
ParametersBase< TrackParametersDim, Charged > TrackParameters
Definition Tracking/TrkEvent/TrkParameters/TrkParameters/TrackParameters.h:27
pdg_comparison.X0
float X0
Definition pdg_comparison.py:314
read_hist_ntuple.t
t
Definition read_hist_ntuple.py:8

Member Data Documentation

◆ m_actsExtrapolator

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

Definition at line 59 of file ActsGeantFollowerHelper.h.

59{this, "ActsExtrapolator", ""};

◆ m_actsParameterCache

std::optional<Acts::BoundTrackParameters> ActsGeantFollowerHelper::m_actsParameterCache {std::nullopt}
private

Definition at line 64 of file ActsGeantFollowerHelper.h.

64{std::nullopt};

◆ m_actsSurfaceCache

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

Definition at line 65 of file ActsGeantFollowerHelper.h.

65{};

◆ m_actsSurfaceIterator

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

Definition at line 66 of file ActsGeantFollowerHelper.h.

66{};

◆ m_extrapolateDirectly

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

Definition at line 60 of file ActsGeantFollowerHelper.h.

60{this, "ExtrapolateDirectly", true};

◆ m_extrapolateIncrementally

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

Definition at line 61 of file ActsGeantFollowerHelper.h.

61{this, "ExtrapolateIncrementally", true};

◆ m_extrapolationEngine

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

Definition at line 58 of file ActsGeantFollowerHelper.h.

58{this, "ExtrapolationEngine", ""};

◆ m_parameterCache

Trk::TrackParameters* ActsGeantFollowerHelper::m_parameterCache {nullptr}
private

Definition at line 63 of file ActsGeantFollowerHelper.h.

63{nullptr};

◆ 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.

71{0.f};

◆ m_trackingGeometryTool

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

Definition at line 55 of file ActsGeantFollowerHelper.h.

55{this, "TrackingGeometryTool", "ActsTrackingGeometryTool"};

◆ 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.

69{0.f};

◆ m_tX0CacheActs

float ActsGeantFollowerHelper::m_tX0CacheActs {0.f}
private

Definition at line 72 of file ActsGeantFollowerHelper.h.

72{0.f};

◆ m_tX0CacheATLAS

float ActsGeantFollowerHelper::m_tX0CacheATLAS {0.f}
private

Definition at line 73 of file ActsGeantFollowerHelper.h.

73{0.f};

◆ m_tX0NonSensitiveCache

float ActsGeantFollowerHelper::m_tX0NonSensitiveCache {0.f}
private

Definition at line 70 of file ActsGeantFollowerHelper.h.

70{0.f};

◆ m_validationTree

TTree* ActsGeantFollowerHelper::m_validationTree {nullptr}
private

Root Validation Tree.

Definition at line 80 of file ActsGeantFollowerHelper.h.

80{nullptr};

◆ 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:
Generated on for ATLAS Offline Software by doxygen 1.16.1