G4ParallelGeometriesLimiterProcess Class Reference

#include <G4ParallelGeometriesLimiterProcess.hh>

Inheritance diagram for G4ParallelGeometriesLimiterProcess:

Public Member Functions
	G4ParallelGeometriesLimiterProcess (const G4String &processName="biasLimiter")
virtual	~G4ParallelGeometriesLimiterProcess ()
void	AddParallelWorld (const G4String &parallelWorldName)
void	RemoveParallelWorld (const G4String &parallelWorldName)
const std::vector< G4VPhysicalVolume * > &	GetParallelWorlds () const
G4int	GetParallelWorldIndex (const G4VPhysicalVolume *parallelWorld) const
G4int	GetParallelWorldIndex (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
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 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 61 of file G4ParallelGeometriesLimiterProcess.hh.

Constructor & Destructor Documentation

G4ParallelGeometriesLimiterProcess()

G4ParallelGeometriesLimiterProcess::G4ParallelGeometriesLimiterProcess

(

const G4String &

processName = "biasLimiter"

)

Definition at line 40 of file G4ParallelGeometriesLimiterProcess.cc.

                                                                                                  :
  G4VProcess(processName, fParallel),
  fParallelWorldSafety( 0.0   ),
  fIsTrackingTime     ( false ),
  fFieldTrack         ( '0'   )
{
  // -- Process Sub Type ? §§
  
  fPathFinder            = G4PathFinder::GetInstance();
  fTransportationManager = G4TransportationManager::GetTransportationManager();
}

~G4ParallelGeometriesLimiterProcess()

virtual G4ParallelGeometriesLimiterProcess::~G4ParallelGeometriesLimiterProcess ( )

inlinevirtual

Definition at line 70 of file G4ParallelGeometriesLimiterProcess.hh.

  {}

Member Function Documentation

AddParallelWorld()

void G4ParallelGeometriesLimiterProcess::AddParallelWorld

(

const G4String &

parallelWorldName

)

Definition at line 56 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(const G4String& parallelWorldName)",
          "BIAS.GEN.21",
          JustWarning, ed,
          "Call ignored.");
      return;
    }
  
  else
    
    {
      G4VPhysicalVolume* newWorld = fTransportationManager->IsWorldExisting( parallelWorldName );
      
      // -- Fatal exception if requested world does not exist:
      if (newWorld == 0)
    {
      G4ExceptionDescription  tellWhatIsWrong;
      tellWhatIsWrong << "Volume `" <<  parallelWorldName
              << "' is not a parallel world nor the mass world volume."
              << G4endl;
      G4Exception("G4ParallelGeometriesLimiterProcess::SetWorldVolume(const G4String)",
              "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(const G4String& parallelWorldName)",
              "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(const G4String& parallelWorldName)",
              "BIAS.GEN.24",
              JustWarning, ed,
              "Call ignored.");
      return;
    }
    }
  
}

AlongStepDoIt()

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

virtual

Implements G4VProcess.

Definition at line 370 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 253 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_G4MT_TLS_ = 0 ;
  if (!endTrack_G4MT_TLS_) endTrack_G4MT_TLS_ = new  G4FieldTrack ('0') ;
  G4FieldTrack &endTrack = *endTrack_G4MT_TLS_;
  
  static G4ThreadLocal ELimited *eLimited_G4MT_TLS_ = 0 ;
  if (!eLimited_G4MT_TLS_) eLimited_G4MT_TLS_ = new  ELimited  ;
  ELimited &eLimited = *eLimited_G4MT_TLS_;
 
 
  // -------------------
  // -- 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 ( 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)
    {
      returnedStep = smallestReturnedStep* (1.0 + 1.0e-9);   // -- Expand to disable its selection in Step Manager comparison
    }
 
      // -- 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 156 of file G4ParallelGeometriesLimiterProcess.hh.

  { return nullptr; }

AtRestGetPhysicalInteractionLength()

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

inlinevirtual

Implements G4VProcess.

Definition at line 152 of file G4ParallelGeometriesLimiterProcess.hh.

  { return DBL_MAX; }

EndTracking()

void G4ParallelGeometriesLimiterProcess::EndTracking ( )

virtual

Reimplemented from G4VProcess.

Definition at line 228 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 94 of file G4ParallelGeometriesLimiterProcess.hh.

{ return fParallelWorldNavigators;                     }

GetCurrentVolume()

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

inline

Definition at line 111 of file G4ParallelGeometriesLimiterProcess.hh.

{ return  fCurrentVolumes[size_t(worldIndex)];          }

GetCurrentVolumes()

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

inline

Definition at line 107 of file G4ParallelGeometriesLimiterProcess.hh.

{ return  fCurrentVolumes;                              }

Referenced by G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength().

GetIsLimiting() [1/2]

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

inline

Definition at line 114 of file G4ParallelGeometriesLimiterProcess.hh.

{ return  fParallelWorldIsLimiting;                     }

GetIsLimiting() [2/2]

G4bool G4ParallelGeometriesLimiterProcess::GetIsLimiting ( G4int  worldIndex ) const

inline

Definition at line 118 of file G4ParallelGeometriesLimiterProcess.hh.

{ return  fParallelWorldIsLimiting[size_t(worldIndex)]; }

GetNavigator()

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

inline

Definition at line 97 of file G4ParallelGeometriesLimiterProcess.hh.

{ return fParallelWorldNavigators[size_t(worldIndex)]; }

Referenced by StartTracking().

GetParallelWorldIndex() [1/2]

G4int G4ParallelGeometriesLimiterProcess::GetParallelWorldIndex

(

const G4VPhysicalVolume *

parallelWorld

)

const

Definition at line 406 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().

GetParallelWorldIndex() [2/2]

G4int G4ParallelGeometriesLimiterProcess::GetParallelWorldIndex

(

G4String

parallelWorldName

)

const

Definition at line 423 of file G4ParallelGeometriesLimiterProcess.cc.

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

GetParallelWorlds()

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

inline

Definition at line 80 of file G4ParallelGeometriesLimiterProcess.hh.

{ return fParallelWorlds; }

GetPreviousVolume()

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

inline

Definition at line 112 of file G4ParallelGeometriesLimiterProcess.hh.

{ return fPreviousVolumes[size_t(worldIndex)];          }

GetPreviousVolumes()

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

inline

Definition at line 108 of file G4ParallelGeometriesLimiterProcess.hh.

{ return fPreviousVolumes;                              }

GetWasLimiting() [1/2]

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

inline

Definition at line 115 of file G4ParallelGeometriesLimiterProcess.hh.

{ return fParallelWorldWasLimiting;                     }

Referenced by G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength().

GetWasLimiting() [2/2]

G4bool G4ParallelGeometriesLimiterProcess::GetWasLimiting ( G4int  worldIndex ) const

inline

Definition at line 119 of file G4ParallelGeometriesLimiterProcess.hh.

{ return fParallelWorldWasLimiting[size_t(worldIndex)]; }

PostStepDoIt()

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

inlinevirtual

Implements G4VProcess.

Definition at line 135 of file G4ParallelGeometriesLimiterProcess.hh.

  { return nullptr; }

PostStepGetPhysicalInteractionLength()

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

virtual

Implements G4VProcess.

Definition at line 236 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:
  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 126 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(const G4String& parallelWorldName)",
          "BIAS.GEN.25",
          JustWarning, ed,
          "Call ignored.");
      return;
    }
  
  else
    
    {
      G4VPhysicalVolume* newWorld = fTransportationManager->IsWorldExisting( parallelWorldName );
      
      if (newWorld == 0)
    {
      
      G4ExceptionDescription ed;
      ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
         << "': trying to remove an inexisting parallel world '" << parallelWorldName << "'." << G4endl;
      G4Exception("G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(const G4String& parallelWorldName)",
              "BIAS.GEN.26",
              JustWarning, ed,
              "Call ignored.");
      return;
    }
      
      // -- get position of world volume in list:
      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(const G4String& parallelWorldName)",
              "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 379 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 193 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 ( 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