Geant4  10.03.p01
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | List of all members
G4ParallelGeometriesLimiterProcess Class Reference

#include <G4ParallelGeometriesLimiterProcess.hh>

Inheritance diagram for G4ParallelGeometriesLimiterProcess:
Inheritance graph
[legend]
Collaboration diagram for G4ParallelGeometriesLimiterProcess:
Collaboration graph
[legend]

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 ()
 
G4int operator== (const G4VProcess &right) const
 
G4int 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 G4ProcessManager * GetProcessManager ()
 
virtual void ResetNumberOfInteractionLengthLeft ()
 
G4double GetNumberOfInteractionLengthLeft () const
 
G4double GetTotalNumberOfInteractionLengthTraversed () const
 
G4bool isAtRestDoItIsEnabled () const
 
G4bool isAlongStepDoItIsEnabled () const
 
G4bool isPostStepDoItIsEnabled () const
 
virtual void DumpInfo () 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 previousStepSize)
 
void ClearNumberOfInteractionLengthLeft ()
 
- Protected Attributes inherited from G4VProcess
const G4ProcessManager * aProcessManager
 
G4VParticleChange * pParticleChange
 
G4ParticleChange aParticleChange
 
G4double theNumberOfInteractionLengthLeft
 
G4double currentInteractionLength
 
G4double theInitialNumberOfInteractionLength
 
G4String theProcessName
 
G4String thePhysicsTableFileName
 
G4ProcessType theProcessType
 
G4int theProcessSubType
 
G4double thePILfactor
 
G4bool enableAtRestDoIt
 
G4bool enableAlongStepDoIt
 
G4bool enablePostStepDoIt
 
G4int verboseLevel
 

Detailed Description

Definition at line 62 of file G4ParallelGeometriesLimiterProcess.hh.

Constructor & Destructor Documentation

G4ParallelGeometriesLimiterProcess::G4ParallelGeometriesLimiterProcess ( const G4String &  processName = "biasLimiter")

Definition at line 41 of file G4ParallelGeometriesLimiterProcess.cc.

41  :
42  G4VProcess(processName, fParallel),
43  fParallelWorldSafety( 0.0 ),
44  fIsTrackingTime ( false ),
45  fFieldTrack ( '0' )
46 {
47  // -- Process Sub Type ? §§
48 
49  fPathFinder = G4PathFinder::GetInstance();
50  fTransportationManager = G4TransportationManager::GetTransportationManager();
51 }
G4PathFinder::GetInstance
static G4PathFinder * GetInstance()
Definition: G4PathFinder.cc:57
G4VProcess::G4VProcess
G4VProcess(const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
Definition: G4VProcess.cc:52
G4TransportationManager::GetTransportationManager
static G4TransportationManager * GetTransportationManager()
Definition: G4TransportationManager.cc:100
fParallel
Definition: G4ProcessType.hh:55

Here is the call graph for this function:

virtual G4ParallelGeometriesLimiterProcess::~G4ParallelGeometriesLimiterProcess ( )
inlinevirtual

Definition at line 71 of file G4ParallelGeometriesLimiterProcess.hh.

72  {}

Member Function Documentation

void G4ParallelGeometriesLimiterProcess::AddParallelWorld ( const G4String &  parallelWorldName)

Definition at line 57 of file G4ParallelGeometriesLimiterProcess.cc.

58 {
59 
60  // -- Refuse adding parallel geometry during tracking time:
61  if (fIsTrackingTime)
62  {
63  G4ExceptionDescription ed;
64  ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
65  << "': adding a parallel world volume at tracking time is not allowed." << G4endl;
66  G4Exception("G4ParallelGeometriesLimiterProcess::AddParallelWorld(const G4String& parallelWorldName)",
67  "BIAS.GEN.21",
68  JustWarning, ed,
69  "Call ignored.");
70  return;
71  }
72 
73  else
74 
75  {
76  G4VPhysicalVolume* newWorld = fTransportationManager->IsWorldExisting( parallelWorldName );
77 
78  // -- Fatal exception if requested world does not exist:
79  if (newWorld == 0)
80  {
81  G4ExceptionDescription tellWhatIsWrong;
82  tellWhatIsWrong << "Volume `" << parallelWorldName
83  << "' is not a parallel world nor the mass world volume."
84  << G4endl;
85  G4Exception("G4ParallelGeometriesLimiterProcess::SetWorldVolume(const G4String)",
86  "BIAS.GEN.22",
87  FatalException,
88  tellWhatIsWrong);
89  }
90 
91  // -- Protection against adding the mass geometry world as parallel world:
92  if ( newWorld == fTransportationManager->GetNavigatorForTracking()->GetWorldVolume() )
93  {
94  G4ExceptionDescription ed;
95  ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
96  << "': trying to add the world volume for tracking as a parallel world." << G4endl;
97  G4Exception("G4ParallelGeometriesLimiterProcess::AddParallelWorld(const G4String& parallelWorldName)",
98  "BIAS.GEN.23",
99  JustWarning, ed,
100  "Call ignored.");
101  return;
102  }
103 
104  // -- Add parallel world, taking care it is not in the list yet:
105  G4bool isNew = true;
106  for ( auto knownWorld : fParallelWorlds )
107  {
108  if ( knownWorld == newWorld ) isNew = false;
109  }
110  if ( isNew ) fParallelWorlds.push_back( newWorld );
111  else
112  {
113  G4ExceptionDescription ed;
114  ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
115  << "': trying to re-add the parallel world volume `" << parallelWorldName << "'." << G4endl;
116  G4Exception("G4ParallelGeometriesLimiterProcess::AddParallelWorld(const G4String& parallelWorldName)",
117  "BIAS.GEN.24",
118  JustWarning, ed,
119  "Call ignored.");
120  return;
121  }
122  }
123 
124 }
G4TransportationManager::IsWorldExisting
G4VPhysicalVolume * IsWorldExisting(const G4String &worldName)
Definition: G4TransportationManager.cc:392
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
G4TransportationManager::GetNavigatorForTracking
G4Navigator * GetNavigatorForTracking() const
JustWarning
Definition: G4ExceptionSeverity.hh:64
G4bool
bool G4bool
Definition: G4Types.hh:79
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
FatalException
Definition: G4ExceptionSeverity.hh:60
G4endl
#define G4endl
Definition: G4ios.hh:61
G4Navigator::GetWorldVolume
G4VPhysicalVolume * GetWorldVolume() const

Here is the call graph for this function:

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

Implements G4VProcess.

Definition at line 371 of file G4ParallelGeometriesLimiterProcess.cc.

373 {
374 
375  fDummyParticleChange.Initialize(track);
376  return &fDummyParticleChange;
377 }
G4ParticleChangeForNothing::Initialize
virtual void Initialize(const G4Track &track)
Definition: G4ParticleChangeForNothing.hh:51

Here is the call graph for this function:

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

Implements G4VProcess.

Definition at line 254 of file G4ParallelGeometriesLimiterProcess.cc.

259 {
260 
261  // -- Init:
262  // -- Note that the returnedStep must be physically meaningful, even if we return NotCandidateForSelection as condition;
263  // -- the reason is that the stepping manager always takes the smallest alongstep among the returned ones (point related
264  // -- to geometry step length wrt to true path length).
265  *selection = NotCandidateForSelection;
266  G4double returnedStep = DBL_MAX;
267 
268  // -- G4FieldTrack and ELimited:
269  static G4ThreadLocal G4FieldTrack *endTrack_G4MT_TLS_ = 0 ;
270  if (!endTrack_G4MT_TLS_) endTrack_G4MT_TLS_ = new G4FieldTrack ('0') ;
271  G4FieldTrack &endTrack = *endTrack_G4MT_TLS_;
272 
273  static G4ThreadLocal ELimited *eLimited_G4MT_TLS_ = 0 ;
274  if (!eLimited_G4MT_TLS_) eLimited_G4MT_TLS_ = new ELimited ;
275  ELimited &eLimited = *eLimited_G4MT_TLS_;
276 
277 
278  // -------------------
279  // -- Update safeties:
280  // -------------------
281  if ( previousStepSize > 0.0 )
282  {
283  for ( auto& parallelWorldSafety : fParallelWorldSafeties )
284  {
285  parallelWorldSafety -= previousStepSize;
286  if ( parallelWorldSafety < 0. ) parallelWorldSafety = 0.0;
287  fParallelWorldSafety = parallelWorldSafety < fParallelWorldSafety ? parallelWorldSafety : fParallelWorldSafety ;
288  }
289  }
290 
291 
292  // ------------------------------------------
293  // Determination of the proposed step length:
294  // ------------------------------------------
295  if ( ( currentMinimumStep <= fParallelWorldSafety ) && ( currentMinimumStep > 0. ) )
296  {
297  // -- No chance to limit the step, as proposed move inside safety
298 
299  returnedStep = currentMinimumStep;
300  proposedSafety = fParallelWorldSafety - currentMinimumStep;
301  }
302  else
303  {
304  // -- Proposed move exceeds common safety, need to state
305  G4double smallestReturnedStep = -1.0;
306  ELimited eLimitedForSmallestStep = kDoNot;
307  for ( size_t i = 0 ; i < fParallelWorldNavigatorIndeces.size() ; i++ )
308  {
309  // -- Update safety of geometries having safety smaller than current minimum step
310  if ( currentMinimumStep >= fParallelWorldSafeties[i] )
311  {
312  G4FieldTrackUpdator::Update(&fFieldTrack, &track);
313  G4double tmpReturnedStep = fPathFinder->ComputeStep(fFieldTrack,
314  currentMinimumStep,
315  fParallelWorldNavigatorIndeces[i],
316  track.GetCurrentStepNumber(),
317  fParallelWorldSafeties[i],
318  eLimited,
319  endTrack,
320  track.GetVolume());
321 
322  if ( ( smallestReturnedStep < 0.0 ) || ( tmpReturnedStep <= smallestReturnedStep ) )
323  {
324  smallestReturnedStep = tmpReturnedStep;
325  eLimitedForSmallestStep = eLimited;
326  }
327 
328  if (eLimited == kDoNot)
329  {
330  // -- Step not limited by this geometry
331  fParallelWorldSafeties[i] = fParallelWorldNavigators[i]->ComputeSafety(endTrack.GetPosition());
332  fParallelWorldIsLimiting[i] = false;
333  }
334  else
335  {
336  fParallelWorldIsLimiting[i] = true;
337  }
338  }
339 
340  // -- update with smallest safety:
341  fParallelWorldSafety = fParallelWorldSafeties[i] < fParallelWorldSafety ? fParallelWorldSafeties[i] : fParallelWorldSafety ;
342  }
343 
344  // -- no geometry limitation among all geometries, can return currentMinimumStep (or DBL_MAX):
345  // -- Beware : the returnedStep must be physically meaningful, even if we say "NotCandidateForSelection" !
346  if ( eLimitedForSmallestStep == kDoNot )
347  {
348  returnedStep = currentMinimumStep;
349  }
350  // -- proposed step length of limiting geometry:
351  if ( eLimitedForSmallestStep == kUnique ||
352  eLimitedForSmallestStep == kSharedOther )
353  {
354  *selection = CandidateForSelection;
355  returnedStep = smallestReturnedStep;
356  }
357  else if ( eLimitedForSmallestStep == kSharedTransport)
358  {
359  returnedStep = smallestReturnedStep* (1.0 + 1.0e-9); // -- Expand to disable its selection in Step Manager comparison
360  }
361 
362  // -- and smallest safety among geometries:
363  proposedSafety = fParallelWorldSafety ;
364  }
365 
366  // -- returns step length, and proposedSafety
367  return returnedStep;
368 }
kSharedOther
Definition: G4MultiNavigator.hh:54
ELimited
ELimited
Definition: G4MultiNavigator.hh:54
G4ThreadLocal
#define G4ThreadLocal
Definition: tls.hh:89
CandidateForSelection
Definition: G4GPILSelection.hh:52
kUnique
Definition: G4MultiNavigator.hh:54
G4Track::GetCurrentStepNumber
G4int GetCurrentStepNumber() const
G4PathFinder::ComputeStep
G4double ComputeStep(const G4FieldTrack &pFieldTrack, G4double pCurrentProposedStepLength, G4int navigatorId, G4int stepNo, G4double &pNewSafety, ELimited &limitedStep, G4FieldTrack &EndState, G4VPhysicalVolume *currentVolume)
Definition: G4PathFinder.cc:151
NotCandidateForSelection
Definition: G4GPILSelection.hh:57
G4Track::GetVolume
G4VPhysicalVolume * GetVolume() const
G4double
double G4double
Definition: G4Types.hh:76
kDoNot
Definition: G4MultiNavigator.hh:54
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83
kSharedTransport
Definition: G4MultiNavigator.hh:54
G4FieldTrackUpdator::Update
static void Update(G4FieldTrack *, const G4Track *)
Definition: G4FieldTrackUpdator.cc:60

Here is the call graph for this function:

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

Implements G4VProcess.

Definition at line 157 of file G4ParallelGeometriesLimiterProcess.hh.

158  { return nullptr; }
G4double G4ParallelGeometriesLimiterProcess::AtRestGetPhysicalInteractionLength ( const G4Track &  ,
G4ForceCondition *   
)
inlinevirtual

Implements G4VProcess.

Definition at line 153 of file G4ParallelGeometriesLimiterProcess.hh.

155  { return DBL_MAX; }
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83
void G4ParallelGeometriesLimiterProcess::EndTracking ( )
virtual

Reimplemented from G4VProcess.

Definition at line 229 of file G4ParallelGeometriesLimiterProcess.cc.

230 {
231  fIsTrackingTime = false;
232  for ( auto parallelWorldNavigator : fParallelWorldNavigators )
233  fTransportationManager->DeActivateNavigator( parallelWorldNavigator );
234 }
G4TransportationManager::DeActivateNavigator
void DeActivateNavigator(G4Navigator *aNavigator)
Definition: G4TransportationManager.cc:339

Here is the call graph for this function:

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

Definition at line 95 of file G4ParallelGeometriesLimiterProcess.hh.

95 { return fParallelWorldNavigators; }
const G4VPhysicalVolume* G4ParallelGeometriesLimiterProcess::GetCurrentVolume ( G4int  worldIndex) const
inline

Definition at line 112 of file G4ParallelGeometriesLimiterProcess.hh.

112 { return fCurrentVolumes[size_t(worldIndex)]; }
const std::vector< const G4VPhysicalVolume* >& G4ParallelGeometriesLimiterProcess::GetCurrentVolumes ( ) const
inline

Definition at line 108 of file G4ParallelGeometriesLimiterProcess.hh.

108 { return fCurrentVolumes; }

Here is the caller graph for this function:

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

Definition at line 115 of file G4ParallelGeometriesLimiterProcess.hh.

115 { return fParallelWorldIsLimiting; }
G4bool G4ParallelGeometriesLimiterProcess::GetIsLimiting ( G4int  worldIndex) const
inline

Definition at line 119 of file G4ParallelGeometriesLimiterProcess.hh.

119 { return fParallelWorldIsLimiting[size_t(worldIndex)]; }
const G4Navigator* G4ParallelGeometriesLimiterProcess::GetNavigator ( G4int  worldIndex) const
inline

Definition at line 98 of file G4ParallelGeometriesLimiterProcess.hh.

98 { return fParallelWorldNavigators[size_t(worldIndex)]; }

Here is the caller graph for this function:

G4int G4ParallelGeometriesLimiterProcess::GetParallelWorldIndex ( const G4VPhysicalVolume *  parallelWorld) const

Definition at line 407 of file G4ParallelGeometriesLimiterProcess.cc.

408 {
409  G4int toReturn = -1;
410  G4int iWorld = 0;
411  for ( auto world : fParallelWorlds )
412  {
413  if ( world == parallelWorld )
414  {
415  toReturn = iWorld;
416  break;
417  }
418  iWorld++;
419  }
420  return toReturn;
421 }
G4int
int G4int
Definition: G4Types.hh:78

Here is the caller graph for this function:

G4int G4ParallelGeometriesLimiterProcess::GetParallelWorldIndex ( G4String  parallelWorldName) const

Definition at line 424 of file G4ParallelGeometriesLimiterProcess.cc.

425 {
426  G4VPhysicalVolume* aWorld = fTransportationManager->IsWorldExisting( parallelWorldName ); // note aWorld might be nullptr
427  return GetParallelWorldIndex( aWorld );
428 }
G4TransportationManager::IsWorldExisting
G4VPhysicalVolume * IsWorldExisting(const G4String &worldName)
Definition: G4TransportationManager.cc:392
G4ParallelGeometriesLimiterProcess::GetParallelWorldIndex
G4int GetParallelWorldIndex(const G4VPhysicalVolume *parallelWorld) const
Definition: G4ParallelGeometriesLimiterProcess.cc:407

Here is the call graph for this function:

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

Definition at line 81 of file G4ParallelGeometriesLimiterProcess.hh.

81 { return fParallelWorlds; }
const G4VPhysicalVolume* G4ParallelGeometriesLimiterProcess::GetPreviousVolume ( G4int  worldIndex) const
inline

Definition at line 113 of file G4ParallelGeometriesLimiterProcess.hh.

113 { return fPreviousVolumes[size_t(worldIndex)]; }
const std::vector< const G4VPhysicalVolume* >& G4ParallelGeometriesLimiterProcess::GetPreviousVolumes ( ) const
inline

Definition at line 109 of file G4ParallelGeometriesLimiterProcess.hh.

109 { return fPreviousVolumes; }
const std::vector< G4bool >& G4ParallelGeometriesLimiterProcess::GetWasLimiting ( ) const
inline

Definition at line 116 of file G4ParallelGeometriesLimiterProcess.hh.

116 { return fParallelWorldWasLimiting; }

Here is the caller graph for this function:

G4bool G4ParallelGeometriesLimiterProcess::GetWasLimiting ( G4int  worldIndex) const
inline

Definition at line 120 of file G4ParallelGeometriesLimiterProcess.hh.

120 { return fParallelWorldWasLimiting[size_t(worldIndex)]; }
G4VParticleChange* G4ParallelGeometriesLimiterProcess::PostStepDoIt ( const G4Track &  ,
const G4Step &   
)
inlinevirtual

Implements G4VProcess.

Definition at line 136 of file G4ParallelGeometriesLimiterProcess.hh.

137  { return nullptr; }
G4double G4ParallelGeometriesLimiterProcess::PostStepGetPhysicalInteractionLength ( const G4Track &  ,
G4double  ,
G4ForceCondition *  condition 
)
virtual

Implements G4VProcess.

Definition at line 237 of file G4ParallelGeometriesLimiterProcess.cc.

238 {
239 
240  // -- push previous step limitation flags and volumes:
241  // -- §§ consider switching pointers insteads of making copies of std::vector's:
242  fParallelWorldWasLimiting = fParallelWorldIsLimiting;
243  fPreviousVolumes = fCurrentVolumes;
244 
245  // -- update volumes:
246  size_t i = 0;
247  for ( auto navigatorIndex : fParallelWorldNavigatorIndeces ) fCurrentVolumes[i++] = fPathFinder->GetLocatedVolume( navigatorIndex );
248 
249  *condition = NotForced;
250  return DBL_MAX;
251 }
condition
G4double condition(const G4ErrorSymMatrix &m)
G4PathFinder::GetLocatedVolume
G4VPhysicalVolume * GetLocatedVolume(G4int navId) const
Definition: G4PathFinder.hh:284
NotForced
Definition: G4ForceCondition.hh:56
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83

Here is the call graph for this function:

void G4ParallelGeometriesLimiterProcess::RemoveParallelWorld ( const G4String &  parallelWorldName)

Definition at line 127 of file G4ParallelGeometriesLimiterProcess.cc.

128 {
129 
130  // -- Refuse refuse removing parallel geometry during tracking time:
131  if (fIsTrackingTime)
132  {
133  G4ExceptionDescription ed;
134  ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
135  << "': removing a parallel world volume at tracking time is not allowed." << G4endl;
136  G4Exception("G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(const G4String& parallelWorldName)",
137  "BIAS.GEN.25",
138  JustWarning, ed,
139  "Call ignored.");
140  return;
141  }
142 
143  else
144 
145  {
146  G4VPhysicalVolume* newWorld = fTransportationManager->IsWorldExisting( parallelWorldName );
147 
148  if (newWorld == 0)
149  {
150 
151  G4ExceptionDescription ed;
152  ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
153  << "': trying to remove an inexisting parallel world '" << parallelWorldName << "'." << G4endl;
154  G4Exception("G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(const G4String& parallelWorldName)",
155  "BIAS.GEN.26",
156  JustWarning, ed,
157  "Call ignored.");
158  return;
159  }
160 
161  // -- get position of world volume in list:
162  size_t iWorld = 0;
163  for ( auto knownWorld : fParallelWorlds )
164  {
165  if ( knownWorld == newWorld ) break;
166  iWorld++;
167  }
168 
169  if ( iWorld == fParallelWorlds.size() )
170  {
171  G4ExceptionDescription ed;
172  ed << "G4ParallelGeometriesLimiterProcess `" << GetProcessName()
173  << "': trying to remove an non-registerered parallel world '" << parallelWorldName << "'." << G4endl;
174  G4Exception("G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(const G4String& parallelWorldName)",
175  "BIAS.GEN.27",
176  JustWarning, ed,
177  "Call ignored.");
178  return;
179  }
180 
181  // -- remove from vector:
182  fParallelWorlds.erase( fParallelWorlds.begin() + iWorld );
183 
184  }
185 
186 
187 
188 }
G4TransportationManager::IsWorldExisting
G4VPhysicalVolume * IsWorldExisting(const G4String &worldName)
Definition: G4TransportationManager.cc:392
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
JustWarning
Definition: G4ExceptionSeverity.hh:64
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4endl
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

void G4ParallelGeometriesLimiterProcess::SetProcessManager ( const G4ProcessManager *  mgr)
virtual

Reimplemented from G4VProcess.

Definition at line 380 of file G4ParallelGeometriesLimiterProcess.cc.

381 {
382  G4BiasingProcessSharedData *sharedData(nullptr);
383 
384  // -- initialize sharedData pointer:
385  if ( G4BiasingProcessSharedData::fSharedDataMap.Find(mgr) == G4BiasingProcessSharedData::fSharedDataMap.End() )
386  {
387  sharedData = new G4BiasingProcessSharedData( mgr );
388  G4BiasingProcessSharedData::fSharedDataMap[mgr] = sharedData;
389  }
390  else sharedData = G4BiasingProcessSharedData::fSharedDataMap[mgr] ;
391 
392  // -- add itself to the shared data:
393  if ( sharedData->fParallelGeometriesLimiterProcess == nullptr ) sharedData->fParallelGeometriesLimiterProcess = this;
394  else
395  {
396  G4ExceptionDescription ed;
397  ed << " Trying to add more than one G4ParallelGeometriesLimiterProcess process to the process manager " << mgr
398  << " (process manager for `" << mgr->GetParticleType()->GetParticleName() << "'). Only one is needed. Call ignored." << G4endl;
399  G4Exception(" G4ParallelGeometriesLimiterProcess::SetProcessManager(...)",
400  "BIAS.GEN.29",
401  JustWarning,
402  ed);
403  }
404 }
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
JustWarning
Definition: G4ExceptionSeverity.hh:64
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:120
G4ProcessManager::GetParticleType
G4ParticleDefinition * GetParticleType() const
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4endl
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

void G4ParallelGeometriesLimiterProcess::StartTracking ( G4Track *  track)
virtual

Reimplemented from G4VProcess.

Definition at line 194 of file G4ParallelGeometriesLimiterProcess.cc.

195 {
196  fIsTrackingTime = true;
197 
198  // -- fetch the navigators, their indeces, and activate:
199  fParallelWorldNavigators .clear();
200  fParallelWorldNavigatorIndeces.clear();
201  fParallelWorldSafeties .clear();
202  fParallelWorldIsLimiting .clear();
203  fParallelWorldWasLimiting .clear();
204  fCurrentVolumes .clear();
205  fPreviousVolumes .clear();
206  for ( auto parallelWorld : fParallelWorlds )
207  {
208  fParallelWorldNavigators .push_back( fTransportationManager-> GetNavigator( parallelWorld ) );
209  fParallelWorldNavigatorIndeces.push_back( fTransportationManager->ActivateNavigator( fParallelWorldNavigators.back() ) );
210  fParallelWorldSafeties .push_back( 0.0 );
211  fParallelWorldIsLimiting .push_back( false );
212  fParallelWorldWasLimiting .push_back( false );
213  }
214 
215  fPathFinder->PrepareNewTrack( track->GetPosition(), track->GetMomentumDirection() );
216  // -- §§ does it work at this level, after "PrepareNewTrack" above ?
217  for ( auto navigatorIndex : fParallelWorldNavigatorIndeces )
218  {
219  fPreviousVolumes.push_back( nullptr );
220  fCurrentVolumes .push_back( fPathFinder->GetLocatedVolume( navigatorIndex ) );
221  }
222 
223  // -- will force updating safety:
224  fParallelWorldSafety = 0.0;
225  for ( size_t i = 0 ; i < fParallelWorldNavigatorIndeces.size() ; i++ ) fParallelWorldSafeties[i] = 0.0;
226 }
G4PathFinder::PrepareNewTrack
void PrepareNewTrack(const G4ThreeVector &position, const G4ThreeVector &direction, G4VPhysicalVolume *massStartVol=0)
Definition: G4PathFinder.cc:351
G4Track::GetPosition
const G4ThreeVector & GetPosition() const
G4ParallelGeometriesLimiterProcess::GetNavigator
const G4Navigator * GetNavigator(G4int worldIndex) const
Definition: G4ParallelGeometriesLimiterProcess.hh:98
G4PathFinder::GetLocatedVolume
G4VPhysicalVolume * GetLocatedVolume(G4int navId) const
Definition: G4PathFinder.hh:284
G4TransportationManager::ActivateNavigator
G4int ActivateNavigator(G4Navigator *aNavigator)
Definition: G4TransportationManager.cc:304
G4Track::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const

Here is the call graph for this function:

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