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
G4ImportanceProcess Class Reference

#include <G4ImportanceProcess.hh>

+ Inheritance diagram for G4ImportanceProcess:

Public Member Functions

 G4ImportanceProcess (const G4VImportanceAlgorithm &aImportanceAlgorithm, const G4VIStore &aIstore, const G4VTrackTerminator *TrackTerminator, const G4String &aName="ImportanceProcess", G4bool para=false)
 
virtual ~G4ImportanceProcess ()
 
void SetParallelWorld (const G4String &parallelWorldName)
 
void StartTracking (G4Track *)
 
virtual G4double PostStepGetPhysicalInteractionLength (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)
 
virtual G4VParticleChange * PostStepDoIt (const G4Track &, const G4Step &)
 
virtual void KillTrack () const
 
virtual const G4String & GetName () const
 
virtual G4double AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
 
virtual G4double AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
 
virtual G4VParticleChange * AtRestDoIt (const G4Track &, const G4Step &)
 
virtual G4VParticleChange * AlongStepDoIt (const G4Track &, const G4Step &)
 
- 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 &)
 
- Public Member Functions inherited from G4VTrackTerminator
 G4VTrackTerminator ()
 
virtual ~G4VTrackTerminator ()
 
virtual void KillTrack () const =0
 
virtual const G4String & GetName () const =0
 

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
 
- Protected Attributes inherited from G4VTrackTerminator
G4double kCarTolerance
 

Detailed Description

Definition at line 57 of file G4ImportanceProcess.hh.

Constructor & Destructor Documentation

◆ G4ImportanceProcess()

G4ImportanceProcess::G4ImportanceProcess ( const G4VImportanceAlgorithm &  aImportanceAlgorithm,
const G4VIStore &  aIstore,
const G4VTrackTerminator *  TrackTerminator,
const G4String &  aName = "ImportanceProcess",
G4bool  para = false 
)

Definition at line 49 of file G4ImportanceProcess.cc.

54 : G4VProcess(aName, fParallel),
55 fParticleChange(new G4ParticleChange),
56 fImportanceAlgorithm(aImportanceAlgorithm),
57 fIStore(aIstore),
58 fParaflag(para)
59{
60 G4cout << "### G4ImportanceProcess:: Creating " << G4endl;
61 if (TrackTerminator != nullptr)
62 {
63 fPostStepAction = new G4SamplingPostStepAction(*TrackTerminator);
64 }
65 else
66 {
67 fPostStepAction = new G4SamplingPostStepAction(*this);
68 }
69 if (fParticleChange == nullptr)
70 {
71 G4Exception("G4ImportanceProcess::G4ImportanceProcess()",
72 "FatalError", FatalException,
73 "Failed allocation of G4ParticleChange !");
74 }
75 G4VProcess::pParticleChange = fParticleChange;
76
77
78 fGhostStep = new G4Step();
79 fGhostPreStepPoint = fGhostStep->GetPreStepPoint();
80 fGhostPostStepPoint = fGhostStep->GetPostStepPoint();
81
82 fTransportationManager = G4TransportationManager::GetTransportationManager();
83 fPathFinder = G4PathFinder::GetInstance();
84
85 if (verboseLevel>0)
86 {
87 G4cout << GetProcessName() << " is created " << G4endl;
88 }
89
90 G4cout << "G4ImportanceProcess:: importance process paraflag is: " << fParaflag << G4endl;
91
92}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
fParallel
@ fParallel
Definition: G4ProcessType.hh:49
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

◆ ~G4ImportanceProcess()

G4ImportanceProcess::~G4ImportanceProcess ( )
virtual

Definition at line 94 of file G4ImportanceProcess.cc.

95{
96
97 delete fPostStepAction;
98 delete fParticleChange;
99 // delete fGhostStep;
100 // delete fGhostWorld;
101 // delete fGhostNavigator;
102
103}

Member Function Documentation

◆ AlongStepDoIt()

G4VParticleChange * G4ImportanceProcess::AlongStepDoIt ( const G4Track &  aTrack,
const G4Step &   
)
virtual

Implements G4VProcess.

Definition at line 436 of file G4ImportanceProcess.cc.

438{
439 // Dummy ParticleChange ie: does nothing
440 // Expecting G4Transportation to move the track
441 //AH G4cout << " along step do it " << G4endl;
442 pParticleChange->Initialize(aTrack);
443 return pParticleChange;
444}
G4VParticleChange::Initialize
virtual void Initialize(const G4Track &)

◆ AlongStepGetPhysicalInteractionLength()

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

Implements G4VProcess.

Definition at line 347 of file G4ImportanceProcess.cc.

351{
352 if(fParaflag) {
353 *selection = NotCandidateForSelection;
354 G4double returnedStep = DBL_MAX;
355
356 if (previousStepSize > 0.)
357 { fGhostSafety -= previousStepSize; }
358 // else
359 // { fGhostSafety = -1.; }
360 if (fGhostSafety < 0.) fGhostSafety = 0.0;
361
362 // ------------------------------------------
363 // Determination of the proposed STEP LENGTH:
364 // ------------------------------------------
365 if (currentMinimumStep <= fGhostSafety && currentMinimumStep > 0.)
366 {
367 // I have no chance to limit
368 returnedStep = currentMinimumStep;
369 fOnBoundary = false;
370 proposedSafety = fGhostSafety - currentMinimumStep;
371 //AH G4cout << " step not limited, why? " << G4endl;
372 }
373 else // (currentMinimumStep > fGhostSafety: I may limit the Step)
374 {
375 G4FieldTrackUpdator::Update(&fFieldTrack,&track);
376 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
377 // ComputeStep
378 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
379 returnedStep
380 = fPathFinder->ComputeStep(fFieldTrack,currentMinimumStep,fNavigatorID,
381 track.GetCurrentStepNumber(),fGhostSafety,feLimited,
382 fEndTrack,track.GetVolume());
383 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
384 if(feLimited == kDoNot)
385 {
386 //AH G4cout << " computestep came back with not-boundary " << G4endl;
387 // Track is not on the boundary
388 fOnBoundary = false;
389 fGhostSafety = fGhostNavigator->ComputeSafety(fEndTrack.GetPosition());
390 }
391 else
392 {
393 // Track is on the boundary
394 //AH G4cout << " FOUND A BOUNDARY ! " << track.GetCurrentStepNumber() << G4endl;
395 fOnBoundary = true;
396 // proposedSafety = fGhostSafety;
397 }
398 proposedSafety = fGhostSafety;
399 if(feLimited == kUnique || feLimited == kSharedOther) {
400 *selection = CandidateForSelection;
401 }else if (feLimited == kSharedTransport) {
402 returnedStep *= (1.0 + 1.0e-9);
403 // Expand to disable its selection in Step Manager comparison
404 }
405
406 }
407
408 // ----------------------------------------------
409 // Returns the fGhostSafety as the proposedSafety
410 // The SteppingManager will take care of keeping
411 // the smallest one.
412 // ----------------------------------------------
413 return returnedStep;
414
415 } else {
416
417 return DBL_MAX;
418
419 }
420
421}
CandidateForSelection
@ CandidateForSelection
Definition: G4GPILSelection.hh:42
NotCandidateForSelection
@ NotCandidateForSelection
Definition: G4GPILSelection.hh:47
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

◆ AtRestDoIt()

G4VParticleChange * G4ImportanceProcess::AtRestDoIt ( const G4Track &  ,
const G4Step &   
)
virtual

Implements G4VProcess.

Definition at line 430 of file G4ImportanceProcess.cc.

432{
433 return nullptr;
434}

◆ AtRestGetPhysicalInteractionLength()

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

Implements G4VProcess.

Definition at line 423 of file G4ImportanceProcess.cc.

426{
427 return -1.0;
428}

◆ GetName()

const G4String & G4ImportanceProcess::GetName ( ) const
virtual

Implements G4VTrackTerminator.

Definition at line 342 of file G4ImportanceProcess.cc.

343{
344 return theProcessName;
345}
G4VProcess::theProcessName
G4String theProcessName
Definition: G4VProcess.hh:345

◆ KillTrack()

void G4ImportanceProcess::KillTrack ( ) const
virtual

Implements G4VTrackTerminator.

Definition at line 337 of file G4ImportanceProcess.cc.

338{
339 fParticleChange->ProposeTrackStatus(fStopAndKill);
340}
fStopAndKill
@ fStopAndKill
Definition: G4TrackStatus.hh:46
G4VParticleChange::ProposeTrackStatus
void ProposeTrackStatus(G4TrackStatus status)

◆ PostStepDoIt()

G4VParticleChange * G4ImportanceProcess::PostStepDoIt ( const G4Track &  aTrack,
const G4Step &  aStep 
)
virtual

Implements G4VProcess.

Definition at line 202 of file G4ImportanceProcess.cc.

204{
205 fParticleChange->Initialize(aTrack);
206
207 if(fParaflag) {
208 fOldGhostTouchable = fGhostPostStepPoint->GetTouchableHandle();
209 //xbug? fOnBoundary = false;
210 CopyStep(aStep);
211
212 if(fOnBoundary)
213 {
214//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
215// Locate the point and get new touchable
216//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
217 //?? fPathFinder->Locate(step.GetPostStepPoint()->GetPosition(),
218 //?? step.GetPostStepPoint()->GetMomentumDirection());
219 fNewGhostTouchable = fPathFinder->CreateTouchableHandle(fNavigatorID);
220 //AH G4cout << " on boundary " << G4endl;
221//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
222 }
223 else
224 {
225 // Do I need this ??????????????????????????????????????????????????????????
226 // fGhostNavigator->LocateGlobalPointWithinVolume(track.GetPosition());
227 // ?????????????????????????????????????????????????????????????????????????
228
229 // fPathFinder->ReLocate(track.GetPosition());
230
231 // reuse the touchable
232 fNewGhostTouchable = fOldGhostTouchable;
233 //AH G4cout << " NOT on boundary " << G4endl;
234 }
235
236 fGhostPreStepPoint->SetTouchableHandle(fOldGhostTouchable);
237 fGhostPostStepPoint->SetTouchableHandle(fNewGhostTouchable);
238
239// if ( (aStep.GetPostStepPoint()->GetStepStatus() == fGeomBoundary)
240// && (aStep.GetStepLength() > kCarTolerance) )
241// {
242// if (aTrack.GetTrackStatus()==fStopAndKill)
243// {
244// G4cout << "WARNING - G4ImportanceProcess::PostStepDoIt()"
245// << " StopAndKill track." << G4endl;
246// }
247
248// G4StepPoint *prepoint = aStep.GetPreStepPoint();
249// G4StepPoint *postpoint = aStep.GetPostStepPoint();
250// G4GeometryCell prekey(*(prepoint->GetPhysicalVolume()),
251// prepoint->GetTouchable()->GetReplicaNumber());
252// G4GeometryCell postkey(*(postpoint->GetPhysicalVolume()),
253// postpoint->GetTouchable()->GetReplicaNumber());
254
255
256 if ( (fGhostPostStepPoint->GetStepStatus() == fGeomBoundary)
257 && (aStep.GetStepLength() > kCarTolerance) )
258 {
259 if (aTrack.GetTrackStatus()==fStopAndKill)
260 {
261 G4cout << "WARNING - G4ImportanceProcess::PostStepDoIt()"
262 << " StopAndKill track. on boundary" << G4endl;
263 }
264
265 G4GeometryCell prekey(*(fGhostPreStepPoint->GetPhysicalVolume()),
266 fGhostPreStepPoint->GetTouchable()->GetReplicaNumber());
267 G4GeometryCell postkey(*(fGhostPostStepPoint->GetPhysicalVolume()),
268 fGhostPostStepPoint->GetTouchable()->GetReplicaNumber());
269
270 //AH
271 /*
272 G4cout << G4endl;
273 G4cout << G4endl;
274 G4cout << " inside parallel importance process " << aTrack.GetCurrentStepNumber() << G4endl;
275 G4cout << G4endl;
276 G4cout << G4endl;
277 G4cout << " prekey: " << fGhostPreStepPoint->GetPhysicalVolume()->GetName() << " replica:"
278 << fGhostPreStepPoint->GetTouchable()->GetReplicaNumber() << G4endl;
279 G4cout << " prekey ISTORE: " << fIStore.GetImportance(prekey) << G4endl;
280 G4cout << " postkey: " << G4endl;
281 G4cout << " postkey ISTORE: " << fIStore.GetImportance(postkey) << G4endl;
282 */
283 //AH
284 G4Nsplit_Weight nw = fImportanceAlgorithm.
285 Calculate(fIStore.GetImportance(prekey),
286 fIStore.GetImportance(postkey),
287 aTrack.GetWeight());
288 //AH
289 /*
290 G4cout << " prekey weight: " << fIStore.GetImportance(prekey)
291 << " postkey weight: " << fIStore.GetImportance(postkey)
292 << " split weight: " << nw << G4endl;
293 G4cout << " before poststepaction " << G4endl;
294 */
295 //AH
296 fPostStepAction->DoIt(aTrack, fParticleChange, nw);
297 //AH G4cout << " after post step do it " << G4endl;
298 }
299 } else {
300 if ( (aStep.GetPostStepPoint()->GetStepStatus() == fGeomBoundary)
301 && (aStep.GetStepLength() > kCarTolerance) )
302 {
303 //AH G4cout << " inside non-parallel importance process " << G4endl;
304 if (aTrack.GetTrackStatus()==fStopAndKill)
305 {
306 G4cout << "WARNING - G4ImportanceProcess::PostStepDoIt()"
307 << " StopAndKill track. on boundary non-parallel" << G4endl;
308 }
309
310 G4StepPoint *prepoint = aStep.GetPreStepPoint();
311 G4StepPoint *postpoint = aStep.GetPostStepPoint();
312
313 G4GeometryCell prekey(*(prepoint->GetPhysicalVolume()),
314 prepoint->GetTouchable()->GetReplicaNumber());
315 G4GeometryCell postkey(*(postpoint->GetPhysicalVolume()),
316 postpoint->GetTouchable()->GetReplicaNumber());
317
318 G4Nsplit_Weight nw = fImportanceAlgorithm.
319 Calculate(fIStore.GetImportance(prekey),
320 fIStore.GetImportance(postkey),
321 aTrack.GetWeight());
322 //AH
323 /*
324 G4cout << " prekey weight: " << fIStore.GetImportance(prekey)
325 << " postkey weight: " << fIStore.GetImportance(postkey)
326 << " split weight: " << nw << G4endl;
327 G4cout << " before poststepaction 2 " << G4endl;
328 */
329 //AH
330 fPostStepAction->DoIt(aTrack, fParticleChange, nw);
331 //AH G4cout << " after poststepaction 2 " << G4endl;
332 }
333 }
334 return fParticleChange;
335}
fGeomBoundary
@ fGeomBoundary
Definition: G4StepStatus.hh:43
G4Nsplit_Weight
Definition: G4Nsplit_Weight.hh:41
G4ParticleChange::Initialize
void Initialize(const G4Track &) override
Definition: G4ParticleChange.cc:107
G4PathFinder::CreateTouchableHandle
G4TouchableHandle CreateTouchableHandle(G4int navId) const
Definition: G4PathFinder.cc:769
G4SamplingPostStepAction::DoIt
void DoIt(const G4Track &aTrack, G4ParticleChange *aParticleChange, const G4Nsplit_Weight &nw)
Definition: G4SamplingPostStepAction.cc:53
G4StepPoint::GetStepStatus
G4StepStatus GetStepStatus() const
G4StepPoint::GetTouchable
const G4VTouchable * GetTouchable() const
G4StepPoint::SetTouchableHandle
void SetTouchableHandle(const G4TouchableHandle &apValue)
G4StepPoint::GetTouchableHandle
const G4TouchableHandle & GetTouchableHandle() const
G4StepPoint::GetPhysicalVolume
G4VPhysicalVolume * GetPhysicalVolume() const
G4Step::GetStepLength
G4double GetStepLength() const
G4Track::GetTrackStatus
G4TrackStatus GetTrackStatus() const
G4Track::GetWeight
G4double GetWeight() const
G4VIStore::GetImportance
virtual G4double GetImportance(const G4GeometryCell &gCell) const =0
G4VTouchable::GetReplicaNumber
virtual G4int GetReplicaNumber(G4int depth=0) const
Definition: G4VTouchable.cc:50

◆ PostStepGetPhysicalInteractionLength()

G4double G4ImportanceProcess::PostStepGetPhysicalInteractionLength ( const G4Track &  aTrack,
G4double  previousStepSize,
G4ForceCondition *  condition 
)
virtual

Implements G4VProcess.

Definition at line 188 of file G4ImportanceProcess.cc.

192{
193// *condition = Forced;
194// return kInfinity;
195
196// *condition = StronglyForced;
197 *condition = Forced;
198 return DBL_MAX;
199}
condition
G4double condition(const G4ErrorSymMatrix &m)
Forced
@ Forced
Definition: G4ForceCondition.hh:44

◆ SetParallelWorld()

void G4ImportanceProcess::SetParallelWorld ( const G4String &  parallelWorldName)

Definition at line 112 of file G4ImportanceProcess.cc.

114{
115 G4cout << G4endl << G4endl << G4endl;
116 G4cout << "G4ImportanceProcess:: SetParallelWorld name = " << parallelWorldName << G4endl;
117//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
118// Get pointers of the parallel world and its navigator
119//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
120 fGhostWorldName = parallelWorldName;
121 fGhostWorld = fTransportationManager->GetParallelWorld(fGhostWorldName);
122 fGhostNavigator = fTransportationManager->GetNavigator(fGhostWorld);
123//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
124}
G4TransportationManager::GetParallelWorld
G4VPhysicalVolume * GetParallelWorld(const G4String &worldName)
Definition: G4TransportationManager.cc:178
G4TransportationManager::GetNavigator
G4Navigator * GetNavigator(const G4String &worldName)
Definition: G4TransportationManager.cc:202

Referenced by G4ImportanceConfigurator::Configure().

◆ StartTracking()

void G4ImportanceProcess::StartTracking ( G4Track *  trk)
virtual

Reimplemented from G4VProcess.

Definition at line 147 of file G4ImportanceProcess.cc.

148{
149//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
150// Activate navigator and get the navigator ID
151//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
152// G4cout << " G4ParallelWorldScoringProcess::StartTracking" << G4endl;
153
154 if(fParaflag) {
155 if(fGhostNavigator != nullptr)
156 { fNavigatorID = fTransportationManager->ActivateNavigator(fGhostNavigator); }
157 else
158 {
159 G4Exception("G4ImportanceProcess::StartTracking",
160 "ProcParaWorld000",FatalException,
161 "G4ImportanceProcess is used for tracking without having a parallel world assigned");
162 }
163//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
164
165// G4cout << "G4ParallelWorldScoringProcess::StartTracking <<<<<<<<<<<<<<<<<< " << G4endl;
166//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
167// Let PathFinder initialize
168//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
169 fPathFinder->PrepareNewTrack(trk->GetPosition(),trk->GetMomentumDirection());
170//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
171
172//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
173// Setup initial touchables for the first step
174//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
175 fOldGhostTouchable = fPathFinder->CreateTouchableHandle(fNavigatorID);
176 fGhostPreStepPoint->SetTouchableHandle(fOldGhostTouchable);
177 fNewGhostTouchable = fOldGhostTouchable;
178 fGhostPostStepPoint->SetTouchableHandle(fNewGhostTouchable);
179
180 // Initialize
181 fGhostSafety = -1.;
182 fOnBoundary = false;
183 }
184
185}
G4PathFinder::PrepareNewTrack
void PrepareNewTrack(const G4ThreeVector &position, const G4ThreeVector &direction, G4VPhysicalVolume *massStartVol=nullptr)
Definition: G4PathFinder.cc:342
G4Track::GetPosition
const G4ThreeVector & GetPosition() const
G4Track::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
G4TransportationManager::ActivateNavigator
G4int ActivateNavigator(G4Navigator *aNavigator)
Definition: G4TransportationManager.cc:313
The documentation for this class was generated from the following files: