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

ServiceHandle< ActsTrk::ITrackingGeometrySvc > m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
ActsTrk::ContextUtility m_ctxProvider {this}
 Context provider for geometry, magnetic field and calibration contexts.
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}
std::unique_ptr< 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 36 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:82
ActsGeantFollowerHelper::m_validationTreeName
std::string m_validationTreeName
validation tree name - to be acessed by this from root
Definition ActsGeantFollowerHelper.h:80
ActsGeantFollowerHelper::m_validationTreeDescription
std::string m_validationTreeDescription
validation tree description - second argument in TTree
Definition ActsGeantFollowerHelper.h:81
ActsGeantFollowerHelper::m_validationTree
TTree * m_validationTree
Root Validation Tree.
Definition ActsGeantFollowerHelper.h:84

◆ ~ActsGeantFollowerHelper()

virtual ActsGeantFollowerHelper::~ActsGeantFollowerHelper ( )
virtualdefault

Member Function Documentation

◆ beginEvent()

void ActsGeantFollowerHelper::beginEvent ( )
overridevirtual

Definition at line 132 of file ActsGeantFollowerHelper.cxx.

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

◆ endEvent()

void ActsGeantFollowerHelper::endEvent ( )
overridevirtual

Definition at line 358 of file ActsGeantFollowerHelper.cxx.

359{
360 if (m_tX0Cache != 0)
361 {
362 // fill the validation tree
363 m_validationTree->Fill();
364 m_actsParameterCache.reset();
365 }
366}
ActsGeantFollowerHelper::m_actsParameterCache
std::optional< Acts::BoundTrackParameters > m_actsParameterCache
Definition ActsGeantFollowerHelper.h:68

◆ finalize()

StatusCode ActsGeantFollowerHelper::finalize ( )
overridevirtual

Definition at line 127 of file ActsGeantFollowerHelper.cxx.

128{
129 return StatusCode::SUCCESS;
130}

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

◆ trackParticle()

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

Definition at line 151 of file ActsGeantFollowerHelper.cxx.

155{
156 // const EventContext ctx;
157 const EventContext &ctx = Gaudi::Hive::currentContext();
158 const Acts::GeometryContext tgContext = m_ctxProvider.getGeometryContext(ctx);
159 auto trackingGeometry = m_trackingGeometrySvc->trackingGeometry();
160 // construct the initial parameters
161 Amg::Vector3D npos(pos.x(),pos.y(),pos.z());
162 Amg::Vector3D nmom(mom.x(),mom.y(),mom.z());
163
164 // Use the G4 pdgId as the particle hypothesis
165 Trk::ParticleHypothesis particleHypo = m_pdgToParticleHypothesis.convert(m_treeData->m_t_pdg, m_treeData->m_t_charge);
166
167 if(m_treeData->m_g4_steps == 0 && m_tNonSensitiveCache == 0){
168 ATH_MSG_INFO("Initial step ... preparing event cache.");
169 m_treeData->m_t_x = pos.x();
170 m_treeData->m_t_y = pos.y();
171 m_treeData->m_t_z = pos.z();
172 m_treeData->m_t_theta = mom.theta();
173 m_treeData->m_t_eta = mom.eta();
174 m_treeData->m_t_phi = mom.phi();
175 m_treeData->m_t_p = mom.mag();
176 m_treeData->m_t_charge = charge;
177 m_treeData->m_t_pdg = pdg;
178 m_treeData->m_g4_steps = -1;
179 m_tX0Cache = 0.;
180 m_tX0CacheActs = 0.;
181 m_parameterCache = std::make_unique<Trk::CurvilinearParameters>(npos, nmom, charge);
182
183 std::shared_ptr<Acts::PerigeeSurface> surface =
184 Acts::Surface::makeShared<Acts::PerigeeSurface>(
185 npos);
186
187
188 float mass = Trk::ParticleMasses::mass[particleHypo] * Acts::UnitConstants::MeV;
189
190 Acts::Vector4 actsStart(pos.x(),pos.y(),pos.z(),0);
191 Acts::Vector3 dir = nmom.normalized();
192 Acts::ParticleHypothesis hypothesis{Acts::makeAbsolutePdgParticle(static_cast<Acts::PdgParticle>(pdg)),
193 mass, static_cast<float>(charge)};
194 m_actsParameterCache = Acts::BoundTrackParameters::create(
195 tgContext, 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 auto g4Parameters = std::make_unique<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 std::unique_ptr<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 Acts::Result<Acts::BoundTrackParameters> actsParameters = m_actsExtrapolator->propagate(ctx,
242 *m_actsParameterCache,
243 *destinationSurfaceActs,
244 Acts::Direction::Forward(),
245 std::numeric_limits<double>::max());
246 if(not actsParameters.ok()){
247 ATH_MSG_ERROR("Error in the Acts extrapolation, skip the current step");
248 return;
249 }
250
251 auto actsSteps = m_actsExtrapolator->propagationSteps(ctx,
252 *m_actsParameterCache,
253 *destinationSurfaceActs,
254 Acts::Direction::Forward(),
255 std::numeric_limits<double>::max());
256 if(not actsSteps.ok()){
257 ATH_MSG_ERROR("Error in the Acts extrapolation, skip the current step");
258 return;
259 }
260 float X0Acts = actsSteps->second.materialInX0;
261
262 auto lowestVolume = trackingGeometry->resolveLowestTrackingVolume(tgContext, actsParameters->position(tgContext));
263 if(not lowestVolume.ok() or *lowestVolume == nullptr){
264 ATH_MSG_ERROR("Could not resolve the lowest tracking volume, skip the current step");
265 return;
266 }
267 int volID = (*lowestVolume)->geometryId().volume();
268
269 // fill the geant information and the trk information
270 m_treeData->m_g4_pt[m_treeData->m_g4_steps] = mom.mag()/std::cosh(mom.eta());
271 m_treeData->m_g4_eta[m_treeData->m_g4_steps] = mom.eta();
272 m_treeData->m_g4_theta[m_treeData->m_g4_steps] = mom.theta();
273 m_treeData->m_g4_phi[m_treeData->m_g4_steps] = mom.phi();
274 m_treeData->m_g4_x[m_treeData->m_g4_steps] = pos.x();
275 m_treeData->m_g4_y[m_treeData->m_g4_steps] = pos.y();
276 m_treeData->m_g4_z[m_treeData->m_g4_steps] = pos.z();
277
278 m_tX0Cache += m_tX0NonSensitiveCache;
279 m_treeData->m_g4_tX0[m_treeData->m_g4_steps] = m_tX0NonSensitiveCache;
280 m_treeData->m_g4_accX0[m_treeData->m_g4_steps] = m_tX0Cache;
281 m_treeData->m_g4_t[m_treeData->m_g4_steps] = m_tNonSensitiveCache;
282 m_treeData->m_g4_X0[m_treeData->m_g4_steps] = m_tNonSensitiveCache/m_tX0NonSensitiveCache;
283
284 m_treeData->m_trk_status[m_treeData->m_g4_steps] = trkParameters ? 1 : 0;
285 m_treeData->m_trk_pt[m_treeData->m_g4_steps] = trkParameters ? trkParameters->pT() : 0.;
286 m_treeData->m_trk_eta[m_treeData->m_g4_steps] = trkParameters ? trkParameters->momentum().eta() : 0.;
287 m_treeData->m_trk_theta[m_treeData->m_g4_steps] = trkParameters ? trkParameters->momentum().theta() : 0.;
288 m_treeData->m_trk_phi[m_treeData->m_g4_steps] = trkParameters ? trkParameters->momentum().phi() : 0.;
289 m_treeData->m_trk_x[m_treeData->m_g4_steps] = trkParameters ? trkParameters->position().x() : 0.;
290 m_treeData->m_trk_y[m_treeData->m_g4_steps] = trkParameters ? trkParameters->position().y() : 0.;
291 m_treeData->m_trk_z[m_treeData->m_g4_steps] = trkParameters ? trkParameters->position().z() : 0.;
292 m_treeData->m_trk_lx[m_treeData->m_g4_steps] = trkParameters ? trkParameters->parameters()[Trk::locX] : 0.;
293 m_treeData->m_trk_ly[m_treeData->m_g4_steps] = trkParameters ? trkParameters->parameters()[Trk::locY] : 0.;
294 // Incremental extrapolation, the extrapolation correspond to one step
295 if (trkParameters){
296 if(m_extrapolateIncrementally || m_treeData->m_g4_steps == 0){
297 float tATLAS = (trkParameters->position() - m_parameterCache->position()).norm();
298 m_tX0CacheATLAS += X0ATLAS;
299 m_treeData->m_trk_tX0[m_treeData->m_g4_steps] = X0ATLAS;
300 m_treeData->m_trk_accX0[m_treeData->m_g4_steps] = m_tX0CacheATLAS;
301 m_treeData->m_trk_t[m_treeData->m_g4_steps] = tATLAS;
302 m_treeData->m_trk_X0[m_treeData->m_g4_steps] = tATLAS/X0ATLAS;
303 }
304 // Extrapolation perform from the start, step varaible need to be computed by comparing to the last extrapolation.
305 else{
306 Amg::Vector3D previousPos(m_treeData->m_trk_x[m_treeData->m_g4_steps-1],
307 m_treeData->m_trk_y[m_treeData->m_g4_steps-1],
308 m_treeData->m_trk_z[m_treeData->m_g4_steps-1]);
309 float tATLAS = (trkParameters->position() - previousPos).norm();
310 m_treeData->m_trk_tX0[m_treeData->m_g4_steps] = X0ATLAS - m_treeData->m_trk_accX0[m_treeData->m_g4_steps-1] ;
311 m_treeData->m_trk_accX0[m_treeData->m_g4_steps] = X0ATLAS;
312 m_treeData->m_trk_t[m_treeData->m_g4_steps] = tATLAS;
313 m_treeData->m_trk_X0[m_treeData->m_g4_steps] = tATLAS/m_treeData->m_trk_tX0[m_treeData->m_g4_steps];
314 }
315 }
316 m_treeData->m_acts_status[m_treeData->m_g4_steps] = actsParameters.ok() ? 1 : 0;
317 m_treeData->m_acts_volumeID[m_treeData->m_g4_steps] = actsParameters.ok() ? volID : 0;
318 m_treeData->m_acts_pt[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->transverseMomentum()*1000 : 0.;
319 m_treeData->m_acts_eta[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->momentum().eta() : 0.;
320 m_treeData->m_acts_theta[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->momentum().theta() : 0.;
321 m_treeData->m_acts_phi[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->momentum().phi() : 0.;
322 m_treeData->m_acts_x[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->position(tgContext).x() : 0.;
323 m_treeData->m_acts_y[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->position(tgContext).y() : 0.;
324 m_treeData->m_acts_z[m_treeData->m_g4_steps] = actsParameters.ok() ? actsParameters->position(tgContext).z() : 0.;
325 // Incremental extrapolation, the extrapolation correspond to one step
326 if(m_extrapolateIncrementally || m_treeData->m_g4_steps == 0){
327 float tActs = (actsParameters->position(tgContext) - m_actsParameterCache->position(tgContext)).norm();
328 m_tX0CacheActs += X0Acts;
329 m_treeData->m_acts_tX0[m_treeData->m_g4_steps] = X0Acts;
330 m_treeData->m_acts_accX0[m_treeData->m_g4_steps] = m_tX0CacheActs;
331 m_treeData->m_acts_t[m_treeData->m_g4_steps] = tActs;
332 m_treeData->m_acts_X0[m_treeData->m_g4_steps] = tActs/X0Acts;
333 }
334 // Extrapolation perform from the start, step varaible need to be computed by comparing to the last extrapolation.
335 else{
336 Acts::Vector3 previousPos(m_treeData->m_acts_x[m_treeData->m_g4_steps-1],
337 m_treeData->m_acts_y[m_treeData->m_g4_steps-1],
338 m_treeData->m_acts_z[m_treeData->m_g4_steps-1]);
339 float tActs = (actsParameters->position(tgContext) - previousPos).norm();
340 m_treeData->m_acts_tX0[m_treeData->m_g4_steps] = X0Acts - m_treeData->m_acts_accX0[m_treeData->m_g4_steps-1] ;
341 m_treeData->m_acts_accX0[m_treeData->m_g4_steps] = X0Acts;
342 m_treeData->m_acts_t[m_treeData->m_g4_steps] = tActs;
343 m_treeData->m_acts_X0[m_treeData->m_g4_steps] = tActs/m_treeData->m_acts_tX0[m_treeData->m_g4_steps];
344 }
345
346 // update the parameters if needed/configured
347 if (m_extrapolateIncrementally && trkParameters && actsParameters.ok()) {
348 m_actsParameterCache.reset();
349 m_parameterCache = std::move(trkParameters);
350 m_actsParameterCache = actsParameters.value();
351 }
352 // delete cache and increment
353 m_tX0NonSensitiveCache = 0.;
354 m_tNonSensitiveCache = 0.;
355 ++m_treeData->m_g4_steps;
356}
MAXPROBES
#define MAXPROBES
Definition ActsGeantFollowerHelper.h:26
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition AthMsgStreamMacros.h:32
charge
double charge(const T &p)
Definition AtlasPID.h:1003
ActsGeantFollowerHelper::m_pdgToParticleHypothesis
Trk::PdgToParticleHypothesis m_pdgToParticleHypothesis
Definition ActsGeantFollowerHelper.h:72
ActsGeantFollowerHelper::m_parameterCache
std::unique_ptr< Trk::TrackParameters > m_parameterCache
Definition ActsGeantFollowerHelper.h:67
ActsGeantFollowerHelper::m_extrapolateIncrementally
Gaudi::Property< bool > m_extrapolateIncrementally
Definition ActsGeantFollowerHelper.h:65
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:61
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::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
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 63 of file ActsGeantFollowerHelper.h.

63{this, "ActsExtrapolator", ""};

◆ m_actsParameterCache

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

Definition at line 68 of file ActsGeantFollowerHelper.h.

68{std::nullopt};

◆ m_actsSurfaceCache

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

Definition at line 69 of file ActsGeantFollowerHelper.h.

69{};

◆ m_actsSurfaceIterator

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

Definition at line 70 of file ActsGeantFollowerHelper.h.

70{};

◆ m_ctxProvider

ActsTrk::ContextUtility ActsGeantFollowerHelper::m_ctxProvider {this}
private

Context provider for geometry, magnetic field and calibration contexts.

Definition at line 59 of file ActsGeantFollowerHelper.h.

59{this};

◆ m_extrapolateDirectly

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

Definition at line 64 of file ActsGeantFollowerHelper.h.

64{this, "ExtrapolateDirectly", true};

◆ m_extrapolateIncrementally

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

Definition at line 65 of file ActsGeantFollowerHelper.h.

65{this, "ExtrapolateIncrementally", true};

◆ m_extrapolationEngine

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

Definition at line 62 of file ActsGeantFollowerHelper.h.

62{this, "ExtrapolationEngine", ""};

◆ m_parameterCache

std::unique_ptr<Trk::TrackParameters> ActsGeantFollowerHelper::m_parameterCache {nullptr}
private

Definition at line 67 of file ActsGeantFollowerHelper.h.

67{nullptr};

◆ m_pdgToParticleHypothesis

Trk::PdgToParticleHypothesis ActsGeantFollowerHelper::m_pdgToParticleHypothesis
private

Definition at line 72 of file ActsGeantFollowerHelper.h.

◆ m_tNonSensitiveCache

float ActsGeantFollowerHelper::m_tNonSensitiveCache {0.f}
private

Definition at line 75 of file ActsGeantFollowerHelper.h.

75{0.f};

◆ m_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> ActsGeantFollowerHelper::m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
private

Definition at line 57 of file ActsGeantFollowerHelper.h.

57{this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};

◆ m_treeData

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

Definition at line 142 of file ActsGeantFollowerHelper.h.

◆ m_tX0Cache

float ActsGeantFollowerHelper::m_tX0Cache {0.f}
private

Definition at line 73 of file ActsGeantFollowerHelper.h.

73{0.f};

◆ m_tX0CacheActs

float ActsGeantFollowerHelper::m_tX0CacheActs {0.f}
private

Definition at line 76 of file ActsGeantFollowerHelper.h.

76{0.f};

◆ m_tX0CacheATLAS

float ActsGeantFollowerHelper::m_tX0CacheATLAS {0.f}
private

Definition at line 77 of file ActsGeantFollowerHelper.h.

77{0.f};

◆ m_tX0NonSensitiveCache

float ActsGeantFollowerHelper::m_tX0NonSensitiveCache {0.f}
private

Definition at line 74 of file ActsGeantFollowerHelper.h.

74{0.f};

◆ m_validationTree

TTree* ActsGeantFollowerHelper::m_validationTree {nullptr}
private

Root Validation Tree.

Definition at line 84 of file ActsGeantFollowerHelper.h.

84{nullptr};

◆ m_validationTreeDescription

std::string ActsGeantFollowerHelper::m_validationTreeDescription
private

validation tree description - second argument in TTree

Definition at line 81 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 82 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 80 of file ActsGeantFollowerHelper.h.

The documentation for this class was generated from the following files:
Generated on for ATLAS Offline Software by doxygen 1.17.0