Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4ParallelWorldScoringProcess Class Reference

#include <G4ParallelWorldScoringProcess.hh>

+ Inheritance diagram for G4ParallelWorldScoringProcess:

Public Member Functions

 G4ParallelWorldScoringProcess (const G4String &processName="ParaWorldScore", G4ProcessType theType=fParameterisation)
 
virtual ~G4ParallelWorldScoringProcess ()
 
void SetParallelWorld (G4String parallelWorldName)
 
void SetParallelWorld (G4VPhysicalVolume *parallelWorld)
 
G4bool IsAtRestRequired (G4ParticleDefinition *partDef)
 
void StartTracking (G4Track *)
 
G4double AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
 
G4VParticleChange * AtRestDoIt (const G4Track &, const G4Step &)
 
G4double AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
 
G4VParticleChange * AlongStepDoIt (const G4Track &, const G4Step &)
 
G4double PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
 
G4VParticleChange * PostStepDoIt (const G4Track &, const G4Step &)
 
void Verbose (const G4Step &) const
 
- Public Member Functions inherited from G4VProcess
 G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
 
 G4VProcess (const G4VProcess &right)
 
virtual ~G4VProcess ()
 
G4VProcess & operator= (const G4VProcess &)=delete
 
G4bool operator== (const G4VProcess &right) const
 
G4bool operator!= (const G4VProcess &right) const
 
virtual G4VParticleChange * PostStepDoIt (const G4Track &track, const G4Step &stepData)=0
 
virtual G4VParticleChange * AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0
 
virtual G4VParticleChange * AtRestDoIt (const G4Track &track, const G4Step &stepData)=0
 
virtual G4double AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0
 
virtual G4double AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0
 
virtual G4double PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0
 
G4double GetCurrentInteractionLength () const
 
void SetPILfactor (G4double value)
 
G4double GetPILfactor () const
 
G4double AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
 
G4double AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
 
G4double PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
 
virtual G4bool IsApplicable (const G4ParticleDefinition &)
 
virtual void BuildPhysicsTable (const G4ParticleDefinition &)
 
virtual void PreparePhysicsTable (const G4ParticleDefinition &)
 
virtual G4bool StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
 
virtual G4bool RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
 
const G4String & GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
 
const G4String & GetProcessName () const
 
G4ProcessType GetProcessType () const
 
void SetProcessType (G4ProcessType)
 
G4int GetProcessSubType () const
 
void SetProcessSubType (G4int)
 
virtual const G4VProcess * GetCreatorProcess () const
 
virtual void StartTracking (G4Track *)
 
virtual void EndTracking ()
 
virtual void SetProcessManager (const G4ProcessManager *)
 
virtual const G4ProcessManager * GetProcessManager ()
 
virtual void ResetNumberOfInteractionLengthLeft ()
 
G4double GetNumberOfInteractionLengthLeft () const
 
G4double GetTotalNumberOfInteractionLengthTraversed () const
 
G4bool isAtRestDoItIsEnabled () const
 
G4bool isAlongStepDoItIsEnabled () const
 
G4bool isPostStepDoItIsEnabled () const
 
virtual void DumpInfo () const
 
virtual void ProcessDescription (std::ostream &outfile) const
 
void SetVerboseLevel (G4int value)
 
G4int GetVerboseLevel () const
 
virtual void SetMasterProcess (G4VProcess *masterP)
 
const G4VProcess * GetMasterProcess () const
 
virtual void BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
 
virtual void PrepareWorkerPhysicsTable (const G4ParticleDefinition &)
 

Additional Inherited Members

- Static Public Member Functions inherited from G4VProcess
static const G4String & GetProcessTypeName (G4ProcessType)
 
- Protected Member Functions inherited from G4VProcess
void SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)
 
void ClearNumberOfInteractionLengthLeft ()
 
- Protected Attributes inherited from G4VProcess
const G4ProcessManager * aProcessManager = nullptr
 
G4VParticleChange * pParticleChange = nullptr
 
G4ParticleChange aParticleChange
 
G4double theNumberOfInteractionLengthLeft = -1.0
 
G4double currentInteractionLength = -1.0
 
G4double theInitialNumberOfInteractionLength = -1.0
 
G4String theProcessName
 
G4String thePhysicsTableFileName
 
G4ProcessType theProcessType = fNotDefined
 
G4int theProcessSubType = -1
 
G4double thePILfactor = 1.0
 
G4int verboseLevel = 0
 
G4bool enableAtRestDoIt = true
 
G4bool enableAlongStepDoIt = true
 
G4bool enablePostStepDoIt = true
 

Detailed Description

Definition at line 67 of file G4ParallelWorldScoringProcess.hh.

Constructor & Destructor Documentation

◆ G4ParallelWorldScoringProcess()

G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess ( const G4String &  processName = "ParaWorldScore",
G4ProcessType  theType = fParameterisation 
)

Definition at line 52 of file G4ParallelWorldScoringProcess.cc.

54:G4VProcess(processName,theType), fGhostNavigator(0), fNavigatorID(-1), fFieldTrack('0')
55{
56 pParticleChange = &aDummyParticleChange;
57
58 fGhostStep = new G4Step();
59 fGhostPreStepPoint = fGhostStep->GetPreStepPoint();
60 fGhostPostStepPoint = fGhostStep->GetPostStepPoint();
61
62 fTransportationManager = G4TransportationManager::GetTransportationManager();
63 fPathFinder = G4PathFinder::GetInstance();
64
65 fGhostWorld = 0;
66 fGhostSafety = 0.;
67 fOnBoundary = false;
68
69 if (verboseLevel>0)
70 {
71 G4cout << GetProcessName() << " is created " << G4endl;
72 }
73}
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4PathFinder::GetInstance
static G4PathFinder * GetInstance()
Definition: G4PathFinder.cc:52
G4Step
Definition: G4Step.hh:62
G4Step::GetPreStepPoint
G4StepPoint * GetPreStepPoint() const
G4Step::GetPostStepPoint
G4StepPoint * GetPostStepPoint() const
G4TransportationManager::GetTransportationManager
static G4TransportationManager * GetTransportationManager()
Definition: G4TransportationManager.cc:104
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:360
G4VProcess::pParticleChange
G4VParticleChange * pParticleChange
Definition: G4VProcess.hh:325
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition: G4VProcess.hh:386

◆ ~G4ParallelWorldScoringProcess()

G4ParallelWorldScoringProcess::~G4ParallelWorldScoringProcess ( )
virtual

Definition at line 78 of file G4ParallelWorldScoringProcess.cc.

79{
80 delete fGhostStep;
81}

Member Function Documentation

◆ AlongStepDoIt()

G4VParticleChange * G4ParallelWorldScoringProcess::AlongStepDoIt ( const G4Track &  track,
const G4Step &   
)
virtual

Implements G4VProcess.

Definition at line 387 of file G4ParallelWorldScoringProcess.cc.

389{
390 // Dummy ParticleChange ie: does nothing
391 // Expecting G4Transportation to move the track
392 pParticleChange->Initialize(track);
393 return pParticleChange;
394}
G4VParticleChange::Initialize
virtual void Initialize(const G4Track &)

◆ AlongStepGetPhysicalInteractionLength()

G4double G4ParallelWorldScoringProcess::AlongStepGetPhysicalInteractionLength ( const G4Track &  track,
G4double  previousStepSize,
G4double  currentMinimumStep,
G4double &  proposedSafety,
G4GPILSelection *  selection 
)
virtual

Implements G4VProcess.

Definition at line 321 of file G4ParallelWorldScoringProcess.cc.

324{
325 static G4ThreadLocal G4FieldTrack *endTrack_G4MT_TLS_ = 0 ; if (!endTrack_G4MT_TLS_) endTrack_G4MT_TLS_ = new G4FieldTrack ('0') ; G4FieldTrack &endTrack = *endTrack_G4MT_TLS_;
326 static G4ThreadLocal ELimited *eLimited_G4MT_TLS_ = 0 ; if (!eLimited_G4MT_TLS_) eLimited_G4MT_TLS_ = new ELimited ; ELimited &eLimited = *eLimited_G4MT_TLS_;
327
328 *selection = NotCandidateForSelection;
329 G4double returnedStep = DBL_MAX;
330
331 if (previousStepSize > 0.)
332 { fGhostSafety -= previousStepSize; }
333// else
334// { fGhostSafety = -1.; }
335 if (fGhostSafety < 0.) fGhostSafety = 0.0;
336
337 // ------------------------------------------
338 // Determination of the proposed STEP LENGTH:
339 // ------------------------------------------
340 if (currentMinimumStep <= fGhostSafety && currentMinimumStep > 0.)
341 {
342 // I have no chance to limit
343 returnedStep = currentMinimumStep;
344 fOnBoundary = false;
345 proposedSafety = fGhostSafety - currentMinimumStep;
346 }
347 else // (currentMinimumStep > fGhostSafety: I may limit the Step)
348 {
349 G4FieldTrackUpdator::Update(&fFieldTrack,&track);
350//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
351// ComputeStep
352//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
353 returnedStep
354 = fPathFinder->ComputeStep(fFieldTrack,currentMinimumStep,fNavigatorID,
355 track.GetCurrentStepNumber(),fGhostSafety,eLimited,
356 endTrack,track.GetVolume());
357//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
358 if(eLimited == kDoNot)
359 {
360 // Track is not on the boundary
361 fOnBoundary = false;
362 fGhostSafety = fGhostNavigator->ComputeSafety(endTrack.GetPosition());
363 }
364 else
365 {
366 // Track is on the boundary
367 fOnBoundary = true;
368 // fEndGhostSafety = 0.0; // Will apply at the end of the step ...
369 }
370 proposedSafety = fGhostSafety;
371 if(eLimited == kUnique || eLimited == kSharedOther) {
372 *selection = CandidateForSelection;
373 }else if (eLimited == kSharedTransport) {
374 returnedStep *= (1.0 + 1.0e-9);
375 // Expand to disable its selection in Step Manager comparison
376 }
377 }
378
379 // ----------------------------------------------
380 // Returns the fGhostSafety as the proposedSafety
381 // The SteppingManager will take care of keeping
382 // the smallest one.
383 // ----------------------------------------------
384 return returnedStep;
385}
CandidateForSelection
@ CandidateForSelection
Definition: G4GPILSelection.hh:42
NotCandidateForSelection
@ NotCandidateForSelection
Definition: G4GPILSelection.hh:47
ELimited
ELimited
Definition: G4MultiNavigator.hh:49
kDoNot
@ kDoNot
Definition: G4MultiNavigator.hh:49
kUnique
@ kUnique
Definition: G4MultiNavigator.hh:49
kSharedOther
@ kSharedOther
Definition: G4MultiNavigator.hh:49
kSharedTransport
@ kSharedTransport
Definition: G4MultiNavigator.hh:49
G4double
double G4double
Definition: G4Types.hh:83
G4FieldTrackUpdator::Update
static void Update(G4FieldTrack *, const G4Track *)
Definition: G4FieldTrackUpdator.cc:52
G4FieldTrack::GetPosition
G4ThreeVector GetPosition() const
G4Navigator::ComputeSafety
virtual G4double ComputeSafety(const G4ThreeVector &globalpoint, const G4double pProposedMaxLength=DBL_MAX, const G4bool keepState=true)
Definition: G4Navigator.cc:1784
G4PathFinder::ComputeStep
G4double ComputeStep(const G4FieldTrack &pFieldTrack, G4double pCurrentProposedStepLength, G4int navigatorId, G4int stepNo, G4double &pNewSafety, ELimited &limitedStep, G4FieldTrack &EndState, G4VPhysicalVolume *currentVolume)
Definition: G4PathFinder.cc:142
G4Track::GetVolume
G4VPhysicalVolume * GetVolume() const
G4Track::GetCurrentStepNumber
G4int GetCurrentStepNumber() const
DBL_MAX
#define DBL_MAX
Definition: templates.hh:62
G4ThreadLocal
#define G4ThreadLocal
Definition: tls.hh:77

◆ AtRestDoIt()

G4VParticleChange * G4ParallelWorldScoringProcess::AtRestDoIt ( const G4Track &  track,
const G4Step &  step 
)
virtual

Implements G4VProcess.

Definition at line 195 of file G4ParallelWorldScoringProcess.cc.

198{
199 fOldGhostTouchable = fGhostPostStepPoint->GetTouchableHandle();
200 G4VSensitiveDetector* aSD = 0;
201 if(fOldGhostTouchable->GetVolume())
202 { aSD = fOldGhostTouchable->GetVolume()->GetLogicalVolume()->GetSensitiveDetector(); }
203 fOnBoundary = false;
204 CopyStep(step);
205 fGhostPreStepPoint->SetSensitiveDetector(aSD);
206
207 fNewGhostTouchable = fOldGhostTouchable;
208
209 fGhostPreStepPoint->SetTouchableHandle(fOldGhostTouchable);
210 fGhostPostStepPoint->SetTouchableHandle(fNewGhostTouchable);
211 if(fNewGhostTouchable->GetVolume())
212 {
213 fGhostPostStepPoint->SetSensitiveDetector(
214 fNewGhostTouchable->GetVolume()->GetLogicalVolume()->GetSensitiveDetector());
215 }
216 else
217 { fGhostPostStepPoint->SetSensitiveDetector(0); }
218
219 if (verboseLevel>1) Verbose(step);
220
221 G4VSensitiveDetector* sd = fGhostPreStepPoint->GetSensitiveDetector();
222 if(sd)
223 {
224 sd->Hit(fGhostStep);
225 }
226
227 pParticleChange->Initialize(track);
228 return pParticleChange;
229}
G4LogicalVolume::GetSensitiveDetector
G4VSensitiveDetector * GetSensitiveDetector() const
Definition: G4LogicalVolume.cc:469
G4StepPoint::SetSensitiveDetector
void SetSensitiveDetector(G4VSensitiveDetector *)
G4StepPoint::SetTouchableHandle
void SetTouchableHandle(const G4TouchableHandle &apValue)
G4StepPoint::GetTouchableHandle
const G4TouchableHandle & GetTouchableHandle() const
G4StepPoint::GetSensitiveDetector
G4VSensitiveDetector * GetSensitiveDetector() const
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const
G4VSensitiveDetector::Hit
G4bool Hit(G4Step *aStep)
Definition: G4VSensitiveDetector.hh:112
G4VTouchable::GetVolume
virtual G4VPhysicalVolume * GetVolume(G4int depth=0) const
Definition: G4VTouchable.cc:34

◆ AtRestGetPhysicalInteractionLength()

G4double G4ParallelWorldScoringProcess::AtRestGetPhysicalInteractionLength ( const G4Track &  ,
G4ForceCondition *  condition 
)
virtual

Implements G4VProcess.

Definition at line 182 of file G4ParallelWorldScoringProcess.cc.

185{
186 *condition = Forced;
187 return DBL_MAX;
188}
condition
G4double condition(const G4ErrorSymMatrix &m)
Forced
@ Forced
Definition: G4ForceCondition.hh:44

◆ IsAtRestRequired()

G4bool G4ParallelWorldScoringProcess::IsAtRestRequired ( G4ParticleDefinition *  partDef)

Definition at line 112 of file G4ParallelWorldScoringProcess.cc.

114{
115 G4int pdgCode = partDef->GetPDGEncoding();
116 if(pdgCode==0)
117 {
118 G4String partName = partDef->GetParticleName();
119 if(partName=="geantino") return false;
120 if(partName=="chargedgeantino") return false;
121 }
122 else
123 {
124 if(pdgCode==11 || pdgCode==2212) return false; // electrons and proton
125 pdgCode = std::abs(pdgCode);
126 if(pdgCode==22) return false; // gamma and optical photons
127 if(pdgCode==12 || pdgCode==14 || pdgCode==16) return false; // all neutronos
128 }
129 return true;
130}
G4int
int G4int
Definition: G4Types.hh:85
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:109

◆ PostStepDoIt()

G4VParticleChange * G4ParallelWorldScoringProcess::PostStepDoIt ( const G4Track &  track,
const G4Step &  step 
)
virtual

Implements G4VProcess.

Definition at line 252 of file G4ParallelWorldScoringProcess.cc.

255{
256 fOldGhostTouchable = fGhostPostStepPoint->GetTouchableHandle();
257 G4VSensitiveDetector* aSD = 0;
258 if(fOldGhostTouchable->GetVolume())
259 { aSD = fOldGhostTouchable->GetVolume()->GetLogicalVolume()->GetSensitiveDetector(); }
260 CopyStep(step);
261 fGhostPreStepPoint->SetSensitiveDetector(aSD);
262
263 // fPathFinder->Locate( track.GetPosition(),
264 // track.GetMomentumDirection(),
265 // true);
266
267 // fPathFinder->Locate(step.GetPostStepPoint()->GetPosition(),
268 // step.GetPostStepPoint()->GetMomentumDirection());
269
270 if(fOnBoundary)
271 {
272//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
273// Locate the point and get new touchable
274//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
275 //?? fPathFinder->Locate(step.GetPostStepPoint()->GetPosition(),
276 //?? step.GetPostStepPoint()->GetMomentumDirection());
277 fNewGhostTouchable = fPathFinder->CreateTouchableHandle(fNavigatorID);
278//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
279 }
280 else
281 {
282// Do I need this ??????????????????????????????????????????????????????????
283// fGhostNavigator->LocateGlobalPointWithinVolume(track.GetPosition());
284// ?????????????????????????????????????????????????????????????????????????
285
286 // fPathFinder->ReLocate(track.GetPosition());
287
288 // reuse the touchable
289 fNewGhostTouchable = fOldGhostTouchable;
290 }
291
292 fGhostPreStepPoint->SetTouchableHandle(fOldGhostTouchable);
293 fGhostPostStepPoint->SetTouchableHandle(fNewGhostTouchable);
294
295 if(fNewGhostTouchable->GetVolume())
296 {
297 fGhostPostStepPoint->SetSensitiveDetector(
298 fNewGhostTouchable->GetVolume()->GetLogicalVolume()->GetSensitiveDetector());
299 }
300 else
301 { fGhostPostStepPoint->SetSensitiveDetector(0); }
302
303 if (verboseLevel>1) Verbose(step);
304
305 G4VSensitiveDetector* sd = fGhostPreStepPoint->GetSensitiveDetector();
306 if(sd)
307 {
308 sd->Hit(fGhostStep);
309 }
310
311 pParticleChange->Initialize(track); // Does not change the track properties
312 return pParticleChange;
313}
G4PathFinder::CreateTouchableHandle
G4TouchableHandle CreateTouchableHandle(G4int navId) const
Definition: G4PathFinder.cc:769

◆ PostStepGetPhysicalInteractionLength()

G4double G4ParallelWorldScoringProcess::PostStepGetPhysicalInteractionLength ( const G4Track &  track,
G4double  previousStepSize,
G4ForceCondition *  condition 
)
virtual

Implements G4VProcess.

Definition at line 237 of file G4ParallelWorldScoringProcess.cc.

241{
242 // I must be invoked anyway to score the hit.
243 *condition = StronglyForced;
244 return DBL_MAX;
245}
StronglyForced
@ StronglyForced
Definition: G4ForceCondition.hh:55

◆ SetParallelWorld() [1/2]

void G4ParallelWorldScoringProcess::SetParallelWorld ( G4String  parallelWorldName)

Definition at line 88 of file G4ParallelWorldScoringProcess.cc.

90{
91//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
92// Get pointers of the parallel world and its navigator
93//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
94 fGhostWorldName = parallelWorldName;
95 fGhostWorld = fTransportationManager->GetParallelWorld(fGhostWorldName);
96 fGhostNavigator = fTransportationManager->GetNavigator(fGhostWorld);
97//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
98}
G4TransportationManager::GetParallelWorld
G4VPhysicalVolume * GetParallelWorld(const G4String &worldName)
Definition: G4TransportationManager.cc:178
G4TransportationManager::GetNavigator
G4Navigator * GetNavigator(const G4String &worldName)
Definition: G4TransportationManager.cc:202

◆ SetParallelWorld() [2/2]

void G4ParallelWorldScoringProcess::SetParallelWorld ( G4VPhysicalVolume *  parallelWorld)

Definition at line 100 of file G4ParallelWorldScoringProcess.cc.

102{
103//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
104// Get pointer of navigator
105//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
106 fGhostWorldName = parallelWorld->GetName();
107 fGhostWorld = parallelWorld;
108 fGhostNavigator = fTransportationManager->GetNavigator(fGhostWorld);
109//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
110}
G4VPhysicalVolume::GetName
const G4String & GetName() const

◆ StartTracking()

void G4ParallelWorldScoringProcess::StartTracking ( G4Track *  trk)
virtual

Reimplemented from G4VProcess.

Definition at line 138 of file G4ParallelWorldScoringProcess.cc.

139{
140//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
141// Activate navigator and get the navigator ID
142//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
143// G4cout << " G4ParallelWorldScoringProcess::StartTracking" << G4endl;
144 if(fGhostNavigator)
145 { fNavigatorID = fTransportationManager->ActivateNavigator(fGhostNavigator); }
146 else
147 {
148 G4Exception("G4ParallelWorldScoringProcess::StartTracking",
149 "ProcParaWorld000",FatalException,
150 "G4ParallelWorldScoringProcess is used for tracking without having a parallel world assigned");
151 }
152//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
153
154// G4cout << "G4ParallelWorldScoringProcess::StartTracking <<<<<<<<<<<<<<<<<< " << G4endl;
155//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
156// Let PathFinder initialize
157//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
158 fPathFinder->PrepareNewTrack(trk->GetPosition(),trk->GetMomentumDirection());
159//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
160
161//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
162// Setup initial touchables for the first step
163//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
164 fOldGhostTouchable = fPathFinder->CreateTouchableHandle(fNavigatorID);
165 fGhostPreStepPoint->SetTouchableHandle(fOldGhostTouchable);
166 fNewGhostTouchable = fOldGhostTouchable;
167 fGhostPostStepPoint->SetTouchableHandle(fNewGhostTouchable);
168
169 // Initialize
170 fGhostSafety = -1.;
171 fOnBoundary = false;
172 fGhostPreStepPoint->SetStepStatus(fUndefined);
173 fGhostPostStepPoint->SetStepStatus(fUndefined);
174}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
fUndefined
@ fUndefined
Definition: G4StepStatus.hh:55
G4PathFinder::PrepareNewTrack
void PrepareNewTrack(const G4ThreeVector &position, const G4ThreeVector &direction, G4VPhysicalVolume *massStartVol=nullptr)
Definition: G4PathFinder.cc:342
G4StepPoint::SetStepStatus
void SetStepStatus(const G4StepStatus aValue)
G4Track::GetPosition
const G4ThreeVector & GetPosition() const
G4Track::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4TransportationManager::ActivateNavigator
G4int ActivateNavigator(G4Navigator *aNavigator)
Definition: G4TransportationManager.cc:313

◆ Verbose()

void G4ParallelWorldScoringProcess::Verbose ( const G4Step &  step) const

Definition at line 421 of file G4ParallelWorldScoringProcess.cc.

422{
423 G4cout << "In mass geometry ------------------------------------------------" << G4endl;
424 G4cout << " StepLength : " << step.GetStepLength()/mm << " TotalEnergyDeposit : "
425 << step.GetTotalEnergyDeposit()/MeV << G4endl;
426 G4cout << " PreStepPoint : "
427 << step.GetPreStepPoint()->GetPhysicalVolume()->GetName() << " - ";
428 if(step.GetPreStepPoint()->GetProcessDefinedStep())
429 { G4cout << step.GetPreStepPoint()->GetProcessDefinedStep()->GetProcessName(); }
430 else
431 { G4cout << "NoProcessAssigned"; }
432 G4cout << G4endl;
433 G4cout << " " << step.GetPreStepPoint()->GetPosition() << G4endl;
434 G4cout << " PostStepPoint : ";
435 if(step.GetPostStepPoint()->GetPhysicalVolume())
436 { G4cout << step.GetPostStepPoint()->GetPhysicalVolume()->GetName(); }
437 else
438 { G4cout << "OutOfWorld"; }
439 G4cout << " - ";
440 if(step.GetPostStepPoint()->GetProcessDefinedStep())
441 { G4cout << step.GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName(); }
442 else
443 { G4cout << "NoProcessAssigned"; }
444 G4cout << G4endl;
445 G4cout << " " << step.GetPostStepPoint()->GetPosition() << G4endl;
446
447 G4cout << "In ghost geometry ------------------------------------------------" << G4endl;
448 G4cout << " StepLength : " << fGhostStep->GetStepLength()/mm
449 << " TotalEnergyDeposit : "
450 << fGhostStep->GetTotalEnergyDeposit()/MeV << G4endl;
451 G4cout << " PreStepPoint : "
452 << fGhostStep->GetPreStepPoint()->GetPhysicalVolume()->GetName() << " ["
453 << fGhostStep->GetPreStepPoint()->GetTouchable()->GetReplicaNumber()
454 << " ]" << " - ";
455 if(fGhostStep->GetPreStepPoint()->GetProcessDefinedStep())
456 { G4cout << fGhostStep->GetPreStepPoint()->GetProcessDefinedStep()->GetProcessName(); }
457 else
458 { G4cout << "NoProcessAssigned"; }
459 G4cout << G4endl;
460 G4cout << " " << fGhostStep->GetPreStepPoint()->GetPosition() << G4endl;
461 G4cout << " PostStepPoint : ";
462 if(fGhostStep->GetPostStepPoint()->GetPhysicalVolume())
463 {
464 G4cout << fGhostStep->GetPostStepPoint()->GetPhysicalVolume()->GetName() << " ["
465 << fGhostStep->GetPostStepPoint()->GetTouchable()->GetReplicaNumber()
466 << " ]";
467 }
468 else
469 { G4cout << "OutOfWorld"; }
470 G4cout << " - ";
471 if(fGhostStep->GetPostStepPoint()->GetProcessDefinedStep())
472 { G4cout << fGhostStep->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName(); }
473 else
474 { G4cout << "NoProcessAssigned"; }
475 G4cout << G4endl;
476 G4cout << " " << fGhostStep->GetPostStepPoint()->GetPosition() << " == "
477 << fGhostStep->GetTrack()->GetMomentumDirection()
478 << G4endl;
479
480}
G4StepPoint::GetTouchable
const G4VTouchable * GetTouchable() const
G4StepPoint::GetProcessDefinedStep
const G4VProcess * GetProcessDefinedStep() const
G4StepPoint::GetPosition
const G4ThreeVector & GetPosition() const
G4StepPoint::GetPhysicalVolume
G4VPhysicalVolume * GetPhysicalVolume() const
G4Step::GetTrack
G4Track * GetTrack() const
G4Step::GetStepLength
G4double GetStepLength() const
G4Step::GetTotalEnergyDeposit
G4double GetTotalEnergyDeposit() const
G4VTouchable::GetReplicaNumber
virtual G4int GetReplicaNumber(G4int depth=0) const
Definition: G4VTouchable.cc:50

Referenced by AtRestDoIt(), and PostStepDoIt().

The documentation for this class was generated from the following files: