G4ParallelGeometriesLimiterProcess Class Reference

#include <G4ParallelGeometriesLimiterProcess.hh>

Inheritance diagram for G4ParallelGeometriesLimiterProcess:

Public Member Functions
	G4ParallelGeometriesLimiterProcess (const G4String &processName="biasLimiter")
virtual	~G4ParallelGeometriesLimiterProcess ()=default
void	AddParallelWorld (const G4String &parallelWorldName)
void	RemoveParallelWorld (const G4String &parallelWorldName)
const std::vector< G4VPhysicalVolume * > &	GetParallelWorlds () const
G4int	GetParallelWorldIndex (const G4VPhysicalVolume *parallelWorld) const
G4int	GetParallelWorldIndex (const G4String &parallelWorldName) const
const std::vector< G4Navigator * > &	GetActiveNavigators () const
const G4Navigator *	GetNavigator (G4int worldIndex) const
const std::vector< const G4VPhysicalVolume * > &	GetCurrentVolumes () const
const std::vector< const G4VPhysicalVolume * > &	GetPreviousVolumes () const
const G4VPhysicalVolume *	GetCurrentVolume (G4int worldIndex) const
const G4VPhysicalVolume *	GetPreviousVolume (G4int worldIndex) const
const std::vector< G4bool > &	GetIsLimiting () const
const std::vector< G4bool > &	GetWasLimiting () const
G4bool	GetIsLimiting (G4int worldIndex) const
G4bool	GetWasLimiting (G4int worldIndex) const
void	StartTracking (G4Track *)
void	EndTracking ()
G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double, G4ForceCondition *)
G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)
G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &step)
G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual void	SetProcessManager (const G4ProcessManager *)
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
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 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 49 of file G4ParallelGeometriesLimiterProcess.hh.

Constructor & Destructor Documentation

G4ParallelGeometriesLimiterProcess()

G4ParallelGeometriesLimiterProcess::G4ParallelGeometriesLimiterProcess

(

const G4String &

processName = "biasLimiter"

)

Definition at line 39 of file G4ParallelGeometriesLimiterProcess.cc.

  : G4VProcess(processName, fParallel)
{
  // -- Process Sub Type ?
  
  fPathFinder = G4PathFinder::GetInstance();
  fTransportationManager = G4TransportationManager::GetTransportationManager();
}

~G4ParallelGeometriesLimiterProcess()

virtual G4ParallelGeometriesLimiterProcess::~G4ParallelGeometriesLimiterProcess ( )

virtualdefault

Member Function Documentation

AddParallelWorld()

void G4ParallelGeometriesLimiterProcess::AddParallelWorld

(

const G4String &

parallelWorldName

)

Definition at line 52 of file G4ParallelGeometriesLimiterProcess.cc.

{
  // -- Refuse adding parallel geometry during tracking time:
  if (fIsTrackingTime)
  {
    G4ExceptionDescription ed;
    ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
       << "': adding a parallel world volume at tracking time is not allowed."
       << G4endl;
    G4Exception("G4ParallelGeometriesLimiterProcess::AddParallelWorld(..)",
                "BIAS.GEN.21", JustWarning, ed, "Call ignored.");
    return;
  }
  else
  {
    G4VPhysicalVolume* newWorld = fTransportationManager->IsWorldExisting( parallelWorldName );
 
    // -- Fatal exception if requested world does not exist:
    if (newWorld == nullptr)
    {
      G4ExceptionDescription  tellWhatIsWrong;
      tellWhatIsWrong << "Volume `" <<  parallelWorldName
                      << "' is not a parallel world nor the mass world volume."
                      << G4endl;
      G4Exception("G4ParallelGeometriesLimiterProcess::SetWorldVolume(..)",
                  "BIAS.GEN.22", FatalException, tellWhatIsWrong);
    }
 
    // -- Protection against adding the mass geometry world as parallel world:
    if ( newWorld ==  fTransportationManager->GetNavigatorForTracking()->GetWorldVolume() )
    {
      G4ExceptionDescription ed;
      ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
         << "': trying to add the world volume for tracking as a parallel world."
         << G4endl;
      G4Exception("G4ParallelGeometriesLimiterProcess::AddParallelWorld(..)",
                  "BIAS.GEN.23", JustWarning, ed, "Call ignored.");
      return;
    }
 
    // -- Add parallel world, taking care it is not in the list yet:
    G4bool isNew = true;
    for ( auto knownWorld : fParallelWorlds )
    {
      if ( knownWorld == newWorld )  { isNew = false; }
    } 
    if ( isNew )
    {
      fParallelWorlds.push_back( newWorld );
    }
    else
    {
      G4ExceptionDescription ed;
      ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
         << "': trying to re-add the parallel world volume `"
         << parallelWorldName << "'." << G4endl;
      G4Exception("G4ParallelGeometriesLimiterProcess::AddParallelWorld(..)",
                  "BIAS.GEN.24", JustWarning, ed, "Call ignored.");
      return;
    }
  }
}

AlongStepDoIt()

G4VParticleChange * G4ParallelGeometriesLimiterProcess::AlongStepDoIt ( const G4Track & track, const G4Step & step )

virtual

Implements G4VProcess.

Definition at line 354 of file G4ParallelGeometriesLimiterProcess.cc.

{
  fDummyParticleChange.Initialize(track);
  return &fDummyParticleChange;
}

AlongStepGetPhysicalInteractionLength()

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

virtual

Implements G4VProcess.

Definition at line 236 of file G4ParallelGeometriesLimiterProcess.cc.

{
  // -- Init:
  // -- Note that the returnedStep must be physically meaningful,
  // -- even if we return NotCandidateForSelection as condition;
  // -- the reason is that the stepping manager always takes the smallest
  // -- alongstep among the returned ones (point related
  // -- to geometry step length wrt to true path length).
  *selection = NotCandidateForSelection;
  G4double returnedStep = DBL_MAX;
  
  // -- G4FieldTrack and ELimited:
  static G4ThreadLocal G4FieldTrack* endTrack_MT = nullptr;
  if (!endTrack_MT) endTrack_MT = new G4FieldTrack ('0');
  G4FieldTrack& endTrack = *endTrack_MT;
  
  static G4ThreadLocal ELimited* eLimited_MT = nullptr;
  if (!eLimited_MT) eLimited_MT = new ELimited;
  ELimited &eLimited = *eLimited_MT;
 
  // -------------------
  // -- Update safeties:
  // -------------------
  if ( previousStepSize > 0.0 )
  {
    for ( auto& parallelWorldSafety : fParallelWorldSafeties )
    {
      parallelWorldSafety -= previousStepSize;
      if ( parallelWorldSafety < 0. )  { parallelWorldSafety = 0.0; }
      fParallelWorldSafety = parallelWorldSafety < fParallelWorldSafety
                           ? parallelWorldSafety : fParallelWorldSafety;
    }
  }
 
  // ------------------------------------------
  // Determination of the proposed step length:
  // ------------------------------------------
  if ( ( currentMinimumStep <= fParallelWorldSafety )
    && ( currentMinimumStep > 0. ) )
  {
    // -- No chance to limit the step, as proposed move inside safety
 
    returnedStep   = currentMinimumStep;
    proposedSafety = fParallelWorldSafety - currentMinimumStep;
  }
  else
  {
    // -- Proposed move exceeds common safety, need to state
    G4double smallestReturnedStep = -1.0;
    ELimited eLimitedForSmallestStep = kDoNot;
    for ( std::size_t i = 0 ; i < fParallelWorldNavigatorIndeces.size() ; ++i )
    {
      // -- Update safety of geometries having safety smaller than current minimum step
      if (  currentMinimumStep >= fParallelWorldSafeties[i] )
      {
        G4FieldTrackUpdator::Update(&fFieldTrack, &track);
        G4double tmpReturnedStep = fPathFinder->ComputeStep(fFieldTrack,
                                     currentMinimumStep,
                                     fParallelWorldNavigatorIndeces[i],
                                     track.GetCurrentStepNumber(),
                                     fParallelWorldSafeties[i],
                                     eLimited, endTrack, track.GetVolume());
 
        if ( ( smallestReturnedStep < 0.0 ) || ( tmpReturnedStep <= smallestReturnedStep ) )
        {
          smallestReturnedStep = tmpReturnedStep;
          eLimitedForSmallestStep = eLimited;
        }
 
        if (eLimited == kDoNot)
        {
          // -- Step not limited by this geometry
          fParallelWorldSafeties[i] = fParallelWorldNavigators[i]->ComputeSafety(endTrack.GetPosition());
          fParallelWorldIsLimiting[i] = false;
        }
        else
        {
          fParallelWorldIsLimiting[i] = true;
        }
      }
 
      // -- update with smallest safety:
      fParallelWorldSafety = fParallelWorldSafeties[i] < fParallelWorldSafety
                           ?  fParallelWorldSafeties[i] : fParallelWorldSafety;
    }
 
    // -- no geometry limitation among all geometries, can return currentMinimumStep (or DBL_MAX):
    // -- Beware : the returnedStep must be physically meaningful, even if we say "NotCandidateForSelection" !
    if (  eLimitedForSmallestStep == kDoNot )
    {
      returnedStep = currentMinimumStep;
    }
    // -- proposed step length of limiting geometry:
    if ( eLimitedForSmallestStep == kUnique  ||
         eLimitedForSmallestStep == kSharedOther )
    {
      *selection = CandidateForSelection;
      returnedStep = smallestReturnedStep;
    }
    else if ( eLimitedForSmallestStep == kSharedTransport )
    {
      // -- Expand to disable its selection in Step Manager comparison
      returnedStep = smallestReturnedStep* (1.0 + 1.0e-9);
    }
 
    // -- and smallest safety among geometries:
    proposedSafety = fParallelWorldSafety ;
  }
 
  // -- returns step length, and proposedSafety
  return returnedStep;
}

AtRestDoIt()

G4VParticleChange * G4ParallelGeometriesLimiterProcess::AtRestDoIt ( const G4Track & , const G4Step &  )

inlinevirtual

Implements G4VProcess.

Definition at line 147 of file G4ParallelGeometriesLimiterProcess.hh.

      { return nullptr; }

AtRestGetPhysicalInteractionLength()

G4double G4ParallelGeometriesLimiterProcess::AtRestGetPhysicalInteractionLength ( const G4Track & , G4ForceCondition *  )

inlinevirtual

Implements G4VProcess.

Definition at line 145 of file G4ParallelGeometriesLimiterProcess.hh.

      { return DBL_MAX; }

EndTracking()

void G4ParallelGeometriesLimiterProcess::EndTracking ( )

virtual

Reimplemented from G4VProcess.

Definition at line 207 of file G4ParallelGeometriesLimiterProcess.cc.

{
  fIsTrackingTime = false;
  for ( auto parallelWorldNavigator : fParallelWorldNavigators )
  {
    fTransportationManager->DeActivateNavigator( parallelWorldNavigator ); 
  }
}

GetActiveNavigators()

const std::vector< G4Navigator * > & G4ParallelGeometriesLimiterProcess::GetActiveNavigators ( ) const

inline

Definition at line 81 of file G4ParallelGeometriesLimiterProcess.hh.

      { return fParallelWorldNavigators; }

GetCurrentVolume()

const G4VPhysicalVolume * G4ParallelGeometriesLimiterProcess::GetCurrentVolume ( G4int worldIndex ) const

inline

Definition at line 103 of file G4ParallelGeometriesLimiterProcess.hh.

      { return  fCurrentVolumes[std::size_t(worldIndex)]; }

GetCurrentVolumes()

const std::vector< const G4VPhysicalVolume * > & G4ParallelGeometriesLimiterProcess::GetCurrentVolumes ( ) const

inline

Definition at line 97 of file G4ParallelGeometriesLimiterProcess.hh.

      { return  fCurrentVolumes; }

GetIsLimiting() [1/2]

const std::vector< G4bool > & G4ParallelGeometriesLimiterProcess::GetIsLimiting ( ) const

inline

Definition at line 108 of file G4ParallelGeometriesLimiterProcess.hh.

      { return  fParallelWorldIsLimiting; }

GetIsLimiting() [2/2]

G4bool G4ParallelGeometriesLimiterProcess::GetIsLimiting ( G4int worldIndex ) const

inline

Definition at line 114 of file G4ParallelGeometriesLimiterProcess.hh.

      { return  fParallelWorldIsLimiting[std::size_t(worldIndex)]; }

GetNavigator()

const G4Navigator * G4ParallelGeometriesLimiterProcess::GetNavigator ( G4int worldIndex ) const

inline

Definition at line 85 of file G4ParallelGeometriesLimiterProcess.hh.

      { return fParallelWorldNavigators[std::size_t(worldIndex)]; }

GetParallelWorldIndex() [1/2]

G4int G4ParallelGeometriesLimiterProcess::GetParallelWorldIndex

(

const G4String &

parallelWorldName

)

const

Definition at line 411 of file G4ParallelGeometriesLimiterProcess.cc.

{
  G4VPhysicalVolume* aWorld = fTransportationManager->IsWorldExisting( parallelWorldName );
    // note aWorld might be nullptr
  return GetParallelWorldIndex( aWorld );
}

GetParallelWorldIndex() [2/2]

G4int G4ParallelGeometriesLimiterProcess::GetParallelWorldIndex

(

const G4VPhysicalVolume *

parallelWorld

)

const

Definition at line 394 of file G4ParallelGeometriesLimiterProcess.cc.

{
  G4int toReturn = -1;
  G4int iWorld = 0;
  for ( auto world : fParallelWorlds )
  {
    if ( world == parallelWorld )
    {
      toReturn = iWorld;
      break;
    }
    ++iWorld;
  }
  return toReturn;
}

Referenced by GetParallelWorldIndex().

GetParallelWorlds()

const std::vector< G4VPhysicalVolume * > & G4ParallelGeometriesLimiterProcess::GetParallelWorlds ( ) const

inline

Definition at line 67 of file G4ParallelGeometriesLimiterProcess.hh.

      { return fParallelWorlds; }

GetPreviousVolume()

const G4VPhysicalVolume * G4ParallelGeometriesLimiterProcess::GetPreviousVolume ( G4int worldIndex ) const

inline

Definition at line 105 of file G4ParallelGeometriesLimiterProcess.hh.

      { return fPreviousVolumes[std::size_t(worldIndex)]; }

GetPreviousVolumes()

const std::vector< const G4VPhysicalVolume * > & G4ParallelGeometriesLimiterProcess::GetPreviousVolumes ( ) const

inline

Definition at line 99 of file G4ParallelGeometriesLimiterProcess.hh.

      { return fPreviousVolumes; }

GetWasLimiting() [1/2]

const std::vector< G4bool > & G4ParallelGeometriesLimiterProcess::GetWasLimiting ( ) const

inline

Definition at line 110 of file G4ParallelGeometriesLimiterProcess.hh.

      { return fParallelWorldWasLimiting; }

GetWasLimiting() [2/2]

G4bool G4ParallelGeometriesLimiterProcess::GetWasLimiting ( G4int worldIndex ) const

inline

Definition at line 116 of file G4ParallelGeometriesLimiterProcess.hh.

      { return fParallelWorldWasLimiting[std::size_t(worldIndex)]; }

PostStepDoIt()

G4VParticleChange * G4ParallelGeometriesLimiterProcess::PostStepDoIt ( const G4Track & , const G4Step &  )

inlinevirtual

Implements G4VProcess.

Definition at line 132 of file G4ParallelGeometriesLimiterProcess.hh.

{ return nullptr; }

PostStepGetPhysicalInteractionLength()

G4double G4ParallelGeometriesLimiterProcess::PostStepGetPhysicalInteractionLength ( const G4Track & , G4double , G4ForceCondition * condition )

virtual

Implements G4VProcess.

Definition at line 216 of file G4ParallelGeometriesLimiterProcess.cc.

{
  // -- push previous step limitation flags and volumes:
  // -- consider switching pointers insteads of making copies of std::vector's:
  fParallelWorldWasLimiting = fParallelWorldIsLimiting;
  fPreviousVolumes = fCurrentVolumes;
  
  // -- update volumes:
  std::size_t i = 0;
  for ( auto navigatorIndex : fParallelWorldNavigatorIndeces )
  {
    fCurrentVolumes[i++] = fPathFinder->GetLocatedVolume( navigatorIndex );
  }
  
  *condition = NotForced;
  return DBL_MAX;
}

RemoveParallelWorld()

void G4ParallelGeometriesLimiterProcess::RemoveParallelWorld

(

const G4String &

parallelWorldName

)

Definition at line 116 of file G4ParallelGeometriesLimiterProcess.cc.

{
  // -- Refuse refuse removing parallel geometry during tracking time:
  if (fIsTrackingTime)
  {
    G4ExceptionDescription ed;
    ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
       << "': removing a parallel world volume at tracking time is not allowed."
       << G4endl;
    G4Exception("G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(..)",
                "BIAS.GEN.25", JustWarning, ed, "Call ignored.");
    return;
  }
  else
  {
    G4VPhysicalVolume* newWorld = fTransportationManager->IsWorldExisting( parallelWorldName );
    if (newWorld == nullptr)
    {
      G4ExceptionDescription ed;
      ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
         << "': trying to remove an inexisting parallel world '"
         << parallelWorldName << "'." << G4endl;
      G4Exception("G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(..)",
                  "BIAS.GEN.26", JustWarning, ed, "Call ignored.");
      return;
    }
 
    // -- get position of world volume in list:
    std::size_t iWorld = 0;
    for ( auto knownWorld : fParallelWorlds )
    {
      if ( knownWorld == newWorld ) break;
      ++iWorld;
    }
 
    if ( iWorld == fParallelWorlds.size() )
    {
      G4ExceptionDescription ed;
      ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
         << "': trying to remove an non-registerered parallel world '"
         << parallelWorldName << "'." << G4endl;
      G4Exception("G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(..)",
                  "BIAS.GEN.27", JustWarning, ed, "Call ignored.");
      return;
    }
    // -- remove from vector:
    fParallelWorlds.erase( fParallelWorlds.begin() + iWorld );
  }
}

SetProcessManager()

void G4ParallelGeometriesLimiterProcess::SetProcessManager ( const G4ProcessManager * mgr )

virtual

Reimplemented from G4VProcess.

Definition at line 361 of file G4ParallelGeometriesLimiterProcess.cc.

{
  G4BiasingProcessSharedData *sharedData(nullptr);
  
  // -- initialize sharedData pointer:
  if ( G4BiasingProcessSharedData::fSharedDataMap.Find(mgr) == G4BiasingProcessSharedData::fSharedDataMap.End() )
  {
    sharedData = new G4BiasingProcessSharedData( mgr );
    G4BiasingProcessSharedData::fSharedDataMap[mgr] = sharedData;
  }
  else
  {
    sharedData =  G4BiasingProcessSharedData::fSharedDataMap[mgr] ;
  }
 
  // -- add itself to the shared data:
  if ( sharedData->fParallelGeometriesLimiterProcess == nullptr )
  {
    sharedData->fParallelGeometriesLimiterProcess = this;
  }
  else
  {
    G4ExceptionDescription ed;
    ed << " Trying to add more than one G4ParallelGeometriesLimiterProcess process to the process manager "
       << mgr
       << " (process manager for `" << mgr->GetParticleType()->GetParticleName()
       << "'). Only one is needed. Call ignored." << G4endl;
    G4Exception(" G4ParallelGeometriesLimiterProcess::SetProcessManager(..)",
                "BIAS.GEN.29", JustWarning, ed);
  }
}

StartTracking()

void G4ParallelGeometriesLimiterProcess::StartTracking ( G4Track * track )

virtual

Reimplemented from G4VProcess.

Definition at line 170 of file G4ParallelGeometriesLimiterProcess.cc.

{
  fIsTrackingTime = true;
  
  // -- fetch the navigators, their indeces, and activate:
  fParallelWorldNavigators.clear();
  fParallelWorldNavigatorIndeces.clear();
  fParallelWorldSafeties.clear();
  fParallelWorldIsLimiting.clear();
  fParallelWorldWasLimiting.clear();
  fCurrentVolumes.clear();
  fPreviousVolumes.clear();
  for ( auto parallelWorld : fParallelWorlds )
  {
    fParallelWorldNavigators.push_back( fTransportationManager->GetNavigator( parallelWorld ) );
    fParallelWorldNavigatorIndeces.push_back( fTransportationManager->ActivateNavigator( fParallelWorldNavigators.back() ) );
    fParallelWorldSafeties.push_back( 0.0 );
    fParallelWorldIsLimiting.push_back( false );
    fParallelWorldWasLimiting.push_back( false );
  }
  
  fPathFinder->PrepareNewTrack( track->GetPosition(), track->GetMomentumDirection() );
  // -- Does it work at this level, after "PrepareNewTrack" above ?
  for ( auto navigatorIndex : fParallelWorldNavigatorIndeces )
  {
    fPreviousVolumes.push_back( nullptr );
    fCurrentVolumes .push_back( fPathFinder->GetLocatedVolume( navigatorIndex ) );
    }
 
  // -- will force updating safety:
  fParallelWorldSafety = 0.0;
  for ( std::size_t i = 0 ; i < fParallelWorldNavigatorIndeces.size() ; ++i )
  {
    fParallelWorldSafeties[i] = 0.0;
  }
}

---

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

• G4ParallelGeometriesLimiterProcess.hh
• G4ParallelGeometriesLimiterProcess.cc