#include <G4ITPathFinder.hh>

Inheritance diagram for G4ITPathFinder:

Collaboration diagram for G4ITPathFinder:

Public Member Functions
G4double	ComputeStep (const G4FieldTrack &pFieldTrack, G4double pCurrentProposedStepLength, G4int navigatorId, G4int stepNo, G4double &pNewSafety, ELimited &limitedStep, G4FieldTrack &EndState, G4VPhysicalVolume *currentVolume)

void	Locate (const G4ThreeVector &position, const G4ThreeVector &direction, G4bool relativeSearch=true)

void	ReLocate (const G4ThreeVector &position)

void	PrepareNewTrack (const G4ThreeVector &position, const G4ThreeVector &direction, G4VPhysicalVolume *massStartVol=0)

G4TouchableHandle	CreateTouchableHandle (G4int navId) const

G4VPhysicalVolume *	GetLocatedVolume (G4int navId) const

G4bool	IsParticleLooping () const

G4double	GetCurrentSafety () const

G4double	GetMinimumStep () const

unsigned int	GetNumberGeometriesLimitingStep () const

G4double	ComputeSafety (const G4ThreeVector &globalPoint)

G4double	ObtainSafety (G4int navId, G4ThreeVector &globalCenterPoint)

void	EnableParallelNavigation (G4bool enableChoice=true)

G4int	SetVerboseLevel (G4int lev=-1)

G4int	GetMaxLoopCount () const

void	SetMaxLoopCount (G4int new_max)

void	MovePoint ()

G4double	LastPreSafety (G4int navId, G4ThreeVector &globalCenterPoint, G4double &minSafety)

void	PushPostSafetyToPreSafety ()

G4String &	LimitedString (ELimited lim)

Public Member Functions inherited from G4TrackStateDependent< G4ITPathFinder >
virtual	~G4TrackStateDependent ()

virtual void	SetTrackState (G4shared_ptr< StateType > state)

virtual G4VTrackStateHandle	PopTrackState ()

virtual G4VTrackStateHandle	GetTrackState () const

virtual StateTypeHandle	GetConcreteTrackState () const

virtual void	LoadTrackState (G4TrackStateManager &manager)

virtual void	SaveTrackState (G4TrackStateManager &manager)

virtual void	NewTrackState ()

virtual StateTypeHandle	CreateTrackState () const

virtual void	ResetTrackState ()

Public Member Functions inherited from G4VTrackStateDependent
	G4VTrackStateDependent ()

virtual	~G4VTrackStateDependent ()

Static Public Member Functions
static G4ITPathFinder *	GetInstance ()

Protected Member Functions
G4double	DoNextLinearStep (const G4FieldTrack &FieldTrack, G4double proposedStepLength)

G4double	DoNextCurvedStep (const G4FieldTrack &FieldTrack, G4double proposedStepLength, G4VPhysicalVolume *pCurrentPhysVolume)

void	WhichLimited ()

void	PrintLimited ()

G4bool	UseSafetyForOptimization (G4bool)

void	ReportMove (const G4ThreeVector &OldV, const G4ThreeVector &NewV, const G4String &Quantity) const

	G4ITPathFinder ()

	~G4ITPathFinder ()

G4ITNavigator *	GetNavigator (G4int n) const

Protected Member Functions inherited from G4TrackStateDependent< G4ITPathFinder >
	G4TrackStateDependent ()

Additional Inherited Members
Public Types inherited from G4TrackStateDependent< G4ITPathFinder >
typedef G4ITPathFinder	ClassType

typedef G4TrackState < G4ITPathFinder >	StateType

typedef G4shared_ptr< StateType >	StateTypeHandle

Protected Attributes inherited from G4TrackStateDependent< G4ITPathFinder >
StateTypeHandle	fpTrackState

Detailed Description

Definition at line 157 of file G4ITPathFinder.hh.

Constructor & Destructor Documentation

G4ITPathFinder::G4ITPathFinder ( )

protected

Definition at line 96 of file G4ITPathFinder.cc.

                               :
     fVerboseLevel(0)
 {
    fpMultiNavigator= new G4ITMultiNavigator();
 
    fpTransportManager= G4ITTransportationManager::GetTransportationManager();
    // fpFieldPropagator = fpTransportManager->GetPropagatorInField();
 
    kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
    fNoActiveNavigators= 0; 
    for( G4int num=0; num< G4ITNavigator::fMaxNav; ++num )
    {
       fpNavigator[num] =  0;   
    }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4ITPathFinder::~G4ITPathFinder ( )

protected

Definition at line 116 of file G4ITPathFinder.cc.

 {
    delete fpMultiNavigator;
    if (fpPathFinder)  { delete fpPathFinder; fpPathFinder=0; }
 }

Member Function Documentation

G4double G4ITPathFinder::ComputeSafety ( const G4ThreeVector & globalPoint )

Definition at line 737 of file G4ITPathFinder.cc.

 {
     // Recompute safety for the relevant point
 
    G4double minSafety= kInfinity; 
   
    std::vector<G4ITNavigator*>::iterator pNavigatorIter;
    pNavigatorIter= fpTransportManager->GetActiveNavigatorsIterator();
 
    for( G4int num=0; num<fNoActiveNavigators; ++pNavigatorIter,++num )
    {
       G4double safety = (*pNavigatorIter)->ComputeSafety( position,true );
       if( safety < minSafety ) { minSafety = safety; } 
       fNewSafetyComputed[num]= safety;
    } 
 
    fSafetyLocation= position;
    fMinSafety_atSafLocation = minSafety;
 
 #ifdef G4DEBUG_PATHFINDER
    if( fVerboseLevel > 1 )
    { 
      G4cout << " G4ITPathFinder::ComputeSafety - returns "
             << minSafety << " at location " << position << G4endl;
    }
 #endif
    return minSafety; 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4ITPathFinder::ComputeStep	(	const G4FieldTrack &	pFieldTrack,
		G4double	pCurrentProposedStepLength,
		G4int	navigatorId,
		G4int	stepNo,
		G4double &	pNewSafety,
		ELimited &	limitedStep,
		G4FieldTrack &	EndState,
		G4VPhysicalVolume *	currentVolume
	)

Definition at line 154 of file G4ITPathFinder.cc.

 {
   G4double  possibleStep= -1.0; 
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 2 )
   { 
     G4cout << " -------------------------" <<  G4endl;
     G4cout << " G4ITPathFinder::ComputeStep - entered " << G4endl;
     G4cout << "   - stepNo = "  << std::setw(4) << stepNo  << " "
            << " navigatorId = " << std::setw(2) << navigatorNo  << " "
            << " proposed step len = " << proposedStepLength << " " << G4endl;
     G4cout << " PF::ComputeStep requested step " 
            << " from " << InitialFieldTrack.GetPosition()
            << " dir  " << InitialFieldTrack.GetMomentumDirection() << G4endl;
   }
 #endif
 #ifdef G4VERBOSE
   if( navigatorNo >= fNoActiveNavigators )
   {
     std::ostringstream message;
     message << "Bad Navigator ID !" << G4endl
             << "        Requested Navigator ID = " << navigatorNo << G4endl
             << "        Number of active navigators = " << fNoActiveNavigators;
     G4Exception("G4ITPathFinder::ComputeStep()", "GeomNav0002",
                 FatalException, message); 
   }
 #endif
 
   if( fNewTrack || (stepNo != fLastStepNo)  )
   {
     // This is a new track or a new step, so we must make the step
     // ( else we can simply retrieve its results for this Navigator Id )    
 
     G4FieldTrack currentState= InitialFieldTrack;
 
     fCurrentStepNo = stepNo;
 
     // Check whether a process shifted the position 
     // since the last step -- by physics processes
     //
     G4ThreeVector newPosition = InitialFieldTrack.GetPosition();   
     G4ThreeVector moveVector= newPosition - fLastLocatedPosition;
     G4double moveLenSq= moveVector.mag2(); 
     if( moveLenSq > kCarTolerance * kCarTolerance )
     { 
        G4ThreeVector newDirection = InitialFieldTrack.GetMomentumDirection();   
 #ifdef G4DEBUG_PATHFINDER
        if( fVerboseLevel > 2 )
        { 
           G4double moveLen= std::sqrt( moveLenSq ); 
           G4cout << " G4ITPathFinder::ComputeStep : Point moved since last step "
                  << " -- at step # = " << stepNo << G4endl
                  << " by " << moveLen  << " to " << newPosition << G4endl;      
        } 
 #endif
        MovePoint();  // Unintentional changed -- ????
 
        // Relocate to cope with this move -- else could abort !?
        //
        Locate( newPosition, newDirection ); 
     }
 
     // Check whether the particle have an (EM) field force exerting upon it
     //
     /*
     G4double particleCharge=  currentState.GetCharge(); 
 
     G4FieldManager* fieldMgr=0;
     G4bool          fieldExertsForce = false ;
     if( (particleCharge != 0.0) )
     {
         fieldMgr= fpFieldPropagator->FindAndSetFieldManager( currentVolume );
 
         // Protect for case where field manager has no field (= field is zero)
         //
         fieldExertsForce = (fieldMgr != 0) 
                         && (fieldMgr->GetDetectorField() != 0);
     }
     fFieldExertedForce = fieldExertsForce;  // Store for use in later calls
                                             // referring to this 'step'.
 
     fNoGeometriesLimiting= -1;  // At start of track, no process limited step
     if( fieldExertsForce )
     {
        DoNextCurvedStep( currentState, proposedStepLength, currentVolume ); 
        //--------------
     }else{
     */
        DoNextLinearStep( currentState, proposedStepLength ); 
        //--------------
 //    }
     fLastStepNo= stepNo;
 
 #ifdef  G4DEBUG_PATHFINDER
     if ( (fNoGeometriesLimiting < 0)
       || (fNoGeometriesLimiting > fNoActiveNavigators) )
     {
       std::ostringstream message;
       message << "Number of geometries limiting the step not set." << G4endl
               << "        Number of geometries limiting step = "
               << fNoGeometriesLimiting;
       G4Exception("G4ITPathFinder::ComputeStep()",
                   "GeomNav0002", FatalException, message); 
     }
 #endif
   }
 #ifdef G4DEBUG_PATHFINDER      
   else
   {
      if( proposedStepLength < fTrueMinStep )  // For 2nd+ geometry 
      { 
        std::ostringstream message;
        message << "Problem in step size request." << G4endl
                << "        Error can be caused by incorrect process ordering."
                << "        Being requested to make a step which is shorter"
                << " than the minimum Step " << G4endl
                << "        already computed for any Navigator/geometry during"
                << " this tracking-step: " << G4endl
                << "        This can happen due to an error in process ordering."
                << G4endl
                << "        Check that all physics processes are registered"
                << G4endl
                << "        before all processes with a navigator/geometry."
                << G4endl
                << "        If using pre-packaged physics list and/or"
                << G4endl
                << "        functionality, please report this error."
                << G4endl << G4endl
                << "        Additional information for problem: "  << G4endl
                << "        Steps request/proposed = " << proposedStepLength
                << G4endl
                << "        MinimumStep (true) = " << fTrueMinStep
                << G4endl
                << "        MinimumStep (navraw)  = " << fMinStep
                << G4endl
                << "        Navigator raw return value" << G4endl
                << "        Requested step now = " << proposedStepLength
                << G4endl
                << "        Difference min-req = "
                << fTrueMinStep-proposedStepLength << G4endl
                << "     -- Step info> stepNo= " << stepNo
                << " last= " << fLastStepNo 
                << " newTr= " << fNewTrack << G4endl;
         G4Exception("G4ITPathFinder::ComputeStep()",
                     "GeomNav0003", FatalException, message);
      }
      else
      { 
         // This is neither a new track nor a new step -- just another 
         // client accessing information for the current track, step 
         // We will simply retrieve the results of the synchronous
         // stepping for this Navigator Id below.
         //
         if( fVerboseLevel > 1 )
         { 
            G4cout << " G4P::CS -> Not calling DoNextLinearStep: " 
                   << " stepNo= " << stepNo << " last= " << fLastStepNo 
                   << " new= " << fNewTrack << " Step already done" << G4endl; 
         }
      } 
   }
 #endif
 
   fNewTrack= false;
 
   // Prepare the information to return
 
   pNewSafety  = fCurrentPreStepSafety[ navigatorNo ];
   limitedStep = fLimitedStep[ navigatorNo ];
   fRelocatedPoint= false;
 
   possibleStep= std::min(proposedStepLength, fCurrentStepSize[ navigatorNo ]);
   EndState = fEndState;  //  now corrected for smaller step, if needed
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 0 )
   { 
     G4cout << " G4ITPathFinder::ComputeStep returns "
            << fCurrentStepSize[ navigatorNo ]
            << " for Navigator " << navigatorNo 
            << " Limited step = " << limitedStep 
            << " Safety(mm) = " << pNewSafety / mm 
            << G4endl; 
   }
 #endif
 
   return possibleStep;
 }

Here is the call graph for this function:

G4TouchableHandle G4ITPathFinder::CreateTouchableHandle ( G4int navId ) const

Definition at line 770 of file G4ITPathFinder.cc.

 {
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 2 )
   {
     G4cout << "G4ITPathFinder::CreateTouchableHandle : navId = "
            << navId << " -- " << GetNavigator(navId) << G4endl;
   }
 #endif
 
   G4TouchableHistory* touchHist;
   touchHist= GetNavigator(navId) -> CreateTouchableHistory(); 
 
   G4VPhysicalVolume* locatedVolume= fLocatedVolume[navId]; 
   if( locatedVolume == 0 )
   {
      // Workaround to ensure that the touchable is fixed !! // TODO: fix
 
      touchHist->UpdateYourself( locatedVolume, touchHist->GetHistory() );
   }
  
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 2 )
   {   
     G4String VolumeName("None"); 
     if( locatedVolume ) { VolumeName= locatedVolume->GetName(); }
     G4cout << " Touchable History created at address " << touchHist
            << "  volume = " << locatedVolume << " name= " << VolumeName
            << G4endl;
   }
 #endif
 
   return G4TouchableHandle(touchHist); 
 }

Here is the call graph for this function:

G4double G4ITPathFinder::DoNextCurvedStep	(	const G4FieldTrack &	FieldTrack,
		G4double	proposedStepLength,
		G4VPhysicalVolume *	pCurrentPhysVolume
	)

protected

Definition at line 1142 of file G4ITPathFinder.cc.

 {
   const G4double toleratedRelativeError= 1.0e-10; 
   G4double minStep= kInfinity, newSafety=0.0;
   G4int numNav; 
   G4FieldTrack  fieldTrack= initialState;
   G4ThreeVector startPoint= initialState.GetPosition(); 
 
 #ifdef G4DEBUG_PATHFINDER
   G4int prc= G4cout.precision(9);
   if( fVerboseLevel > 2 )
   {
     G4cout << " G4ITPathFinder::DoNextCurvedStep ****** " << G4endl;
     G4cout << " Initial value of field track is " << fieldTrack 
            << " and proposed step= " << proposedStepLength  << G4endl;
   }
 #endif
 
   fPreStepCenterRenewed= true; // Always update PreSafety with PreStep point
 
   if( fNoActiveNavigators > 1 )
   { 
      // Calculate the safety values before making the step
 
      G4double minSafety= kInfinity, safety; 
      for( numNav=0; numNav < fNoActiveNavigators; ++numNav )
      {
         safety= fpNavigator[numNav]->ComputeSafety( startPoint, false );
         fPreSafetyValues[numNav]= safety; 
         fCurrentPreStepSafety[numNav]= safety; 
         minSafety = std::min( safety, minSafety ); 
      }
 
      // Save safety value, related position
 
      fPreSafetyLocation=  startPoint;   
      fPreSafetyMinValue=  minSafety;
      fPreStepLocation=    startPoint;
      fMinSafety_PreStepPt= minSafety;
   }
 
   /*
   // Allow Propagator In Field to do the hard work, calling G4MultiNavigator
   //
   minStep=  fpFieldPropagator->ComputeStep( fieldTrack,
                                             proposedStepLength,
                                             newSafety, 
                                             pCurrentPhysicalVolume );
 */
   // fieldTrack now contains the endpoint information
   //
   fEndState= fieldTrack; 
   fMinStep=   minStep; 
   fTrueMinStep = std::min( minStep, proposedStepLength );
 
   if( fNoActiveNavigators== 1 )
   { 
      // Update the 'PreSafety' sphere - as any ComputeStep was called 
      // (must be done anyway in field)
 
      fPreSafetyValues[0]=   newSafety;
      fPreSafetyLocation= startPoint;   
      fPreSafetyMinValue= newSafety;
 
      // Update the current 'PreStep' point's values - mandatory
      //
      fCurrentPreStepSafety[0]= newSafety; 
      fPreStepLocation=  startPoint;
      fMinSafety_PreStepPt= newSafety;
   }
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 2 )
   {
     G4cout << "G4ITPathFinder::DoNextCurvedStep : " << G4endl
            << " initialState = " << initialState << G4endl
            << " and endState = " << fEndState << G4endl;
     G4cout << "G4ITPathFinder::DoNextCurvedStep : "
            << " minStep = " << minStep 
            << " proposedStepLength " << proposedStepLength 
            << " safety = " << newSafety << G4endl;
   }
 #endif
   G4double currentStepSize;   // = 0.0; 
   if( minStep < proposedStepLength ) // if == , then a boundary found at end ??
   {   
     // Recover the remaining information from MultiNavigator
     // especially regarding which Navigator limited the step
 
     G4int noLimited= 0;  //   No geometries limiting step
     for( numNav=0; numNav < fNoActiveNavigators; ++numNav )
     {
       G4double finalStep, lastPreSafety=0.0, minStepLast;
       ELimited didLimit; 
       G4bool limited; 
 
       finalStep=  fpMultiNavigator->ObtainFinalStep( numNav, lastPreSafety, 
                                                      minStepLast, didLimit );
 
       // Calculate the step for this geometry, using the 
       // final step (the only one which can differ.)
 
       currentStepSize = fTrueMinStep;  
       G4double diffStep= 0.0; 
       if( (minStepLast != kInfinity) )
       { 
         diffStep = (finalStep-minStepLast);
         if ( std::abs(diffStep) <= toleratedRelativeError * finalStep ) 
         {
           diffStep = 0.0;
         }
         currentStepSize += diffStep; 
       }
       fCurrentStepSize[numNav] = currentStepSize;  
       
       // TODO: could refine the way to obtain safeties for > 1 geometries
       //     - for pre step safety
       //        notify MultiNavigator about new set of sub-steps
       //        allow it to return this value in ObtainFinalStep 
       //        instead of lastPreSafety (or as well?)
       //     - for final step start (available)
       //        get final Step start from MultiNavigator
       //        and corresponding safety values
       // and/or ALSO calculate ComputeSafety at endpoint
       //     endSafety= fpNavigator[numNav]->ComputeSafety( endPoint ); 
 
       fLimitedStep[numNav] = didLimit; 
       fLimitTruth[numNav] = limited = (didLimit != kDoNot ); 
       if( limited ) { noLimited++; }
 
 #ifdef G4DEBUG_PATHFINDER
       G4bool StepError= (currentStepSize < 0) 
                    || ( (minStepLast != kInfinity) && (diffStep < 0) ) ; 
       if( StepError || (fVerboseLevel > 2) )
       {
         G4String  limitedString=  LimitedString( fLimitedStep[numNav] ); 
         
         G4cout << " G4ITPathFinder::ComputeStep. Geometry " << numNav
                << "  step= " << fCurrentStepSize[numNav] 
                << " from final-step= " << finalStep 
                << " fTrueMinStep= " << fTrueMinStep 
                << " minStepLast= "  << minStepLast 
                << "  limited = " << (fLimitTruth[numNav] ? "YES" : " NO")
                << " ";
         G4cout << "  status = " << limitedString << " #= " << didLimit
                << G4endl;
         
         if( StepError )
         { 
           std::ostringstream message;
           message << "Incorrect calculation of step size for one navigator"
                   << G4endl
                   << "        currentStepSize = " << currentStepSize 
                   << ", diffStep= " << diffStep << G4endl
                   << "ERROR in computing step size for this navigator.";
           G4Exception("G4ITPathFinder::DoNextCurvedStep",
                       "GeomNav0003", FatalException, message);
         }
       }
 #endif
     } // for num Navigators
 
     fNoGeometriesLimiting= noLimited;  // Save # processes limiting step
   } 
   else if ( (minStep == proposedStepLength)  
             || (minStep == kInfinity)  
             || ( std::abs(minStep-proposedStepLength)
                < toleratedRelativeError * proposedStepLength ) )
   { 
     // In case the step was not limited, use default responses
     //  --> all Navigators 
     // Also avoid problems in case of G4ITPathFinder using safety to optimise
     //  - it is possible that the Navigators were not called
     //    if the safety was already satisfactory.
     //    (In that case calling ObtainFinalStep gives invalid results.)
 
     currentStepSize= minStep;
     for( numNav=0; numNav < fNoActiveNavigators; ++numNav )
     {
       fCurrentStepSize[numNav] = minStep; 
       // Safety for endpoint ??  // Can eventuall improve it -- see TODO above
       fLimitedStep[numNav] = kDoNot; 
       fLimitTruth[numNav] = false; 
     }
     fNoGeometriesLimiting= 0;  // Save # processes limiting step
   } 
   else    //  (minStep > proposedStepLength) and not (minStep == kInfinity)
   {
     std::ostringstream message;
     message << "Incorrect calculation of step size for one navigator." << G4endl
             << "        currentStepSize = " << minStep << " is larger than "
             << " proposed StepSize = " << proposedStepLength << ".";
     G4Exception("G4ITPathFinder::DoNextCurvedStep()",
                 "GeomNav0003", FatalException, message); 
   }
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 2 )
   {
     G4cout << " Exiting G4ITPathFinder::DoNextCurvedStep " << G4endl;
     PrintLimited(); 
   }
   G4cout.precision(prc); 
 #endif
 
   return minStep; 
 }

Here is the call graph for this function:

G4double G4ITPathFinder::DoNextLinearStep	(	const G4FieldTrack &	FieldTrack,
		G4double	proposedStepLength
	)

protected

Definition at line 806 of file G4ITPathFinder.cc.

 {
   std::vector<G4ITNavigator*>::iterator pNavigatorIter;
   G4double safety= 0.0, step=0.0;
   G4double minSafety= kInfinity, minStep;
 
   const G4int IdTransport= 0;  // Id of Mass Navigator !!
   G4int num=0; 
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 2 )
   {
     G4cout << " G4ITPathFinder::DoNextLinearStep : entered " << G4endl;
     G4cout << "   Input field track= " << initialState << G4endl;
     G4cout << "   Requested step= " << proposedStepLength << G4endl;
   }
 #endif
 
   G4ThreeVector initialPosition= initialState.GetPosition(); 
   G4ThreeVector initialDirection= initialState.GetMomentumDirection();
   
   G4ThreeVector OriginShift = initialPosition - fPreSafetyLocation;
   G4double      MagSqShift  = OriginShift.mag2() ;
   G4double      MagShift;  // Only given value if it larger than minimum safety
 
   // Potential optimisation using Maximum Value of safety!
   // if( MagSqShift >= sqr(fPreSafetyMaxValue ) ){ 
   //   MagShift= kInfinity;   // Not a useful value -- all will not use/ignore
   // else
   //  MagShift= std::sqrt(MagSqShift) ;
 
   MagShift= std::sqrt(MagSqShift) ;
 
 #ifdef G4PATHFINDER_OPTIMISATION
 
   G4double fullSafety;  // For all geometries, for prestep point
 
   if( MagSqShift >= sqr(fPreSafetyMinValue ) )
   {
      fullSafety = 0.0 ;     
   }
   else
   {
      fullSafety = fPreSafetyMinValue - MagShift;
   }
   if( proposedStepLength < fullSafety ) 
   {
      // Move is smaller than all safeties
      //  -> so we do not have to move the safety center
 
      fPreStepCenterRenewed= false;
 
      for( num=0; num< fNoActiveNavigators; ++num )
      {
         fCurrentStepSize[num]= kInfinity; 
         safety = std::max( 0.0,  fPreSafetyValues[num] - MagShift); 
         minSafety= std::min( safety, minSafety ); 
         fCurrentPreStepSafety[num]= safety; 
      }
      minStep= kInfinity;
 
 #ifdef G4DEBUG_PATHFINDER
      if( fVerboseLevel > 2 )
      {
        G4cout << "G4ITPathFinder::DoNextLinearStep : Quick Stepping. " << G4endl
                << " proposedStepLength " <<  proposedStepLength
                << " < (full) safety = " << fullSafety 
                << " at " << initialPosition 
                << G4endl;
      }
 #endif
   }
   else
 #endif   // End of G4PATHFINDER_OPTIMISATION 1
   {
      // Move is larger than at least one of the safeties
      //  -> so we must move the safety center!
 
      fPreStepCenterRenewed= true;
      pNavigatorIter= fpTransportManager-> GetActiveNavigatorsIterator();
 
      minStep= kInfinity;  // Not proposedStepLength; 
 
      for( num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num ) 
      {
         safety = std::max( 0.0,  fPreSafetyValues[num] - MagShift); 
 
 #ifdef G4PATHFINDER_OPTIMISATION
         if( proposedStepLength <= safety )  // Should be just < safety ?
         {
            // The Step is guaranteed to be taken
 
            step= kInfinity;    //  ComputeStep Would return this
 
 #ifdef G4DEBUG_PATHFINDER
            G4cout.precision(8); 
            G4cout << "G4ITNavigator::ComputeStep> small proposed step = "
                   << proposedStepLength
                   << " <=  safety = " << safety << " for nav " << num 
                   << " Step fully taken. " << G4endl;
 #endif
         }
         else
 #endif   // End of G4PATHFINDER_OPTIMISATION 2
         {
 #ifdef G4DEBUG_PATHFINDER
            G4double previousSafety= safety; 
 #endif
            step= (*pNavigatorIter)->ComputeStep( initialPosition, 
                                                  initialDirection,
                                                  proposedStepLength,
                                                  safety ); 
            minStep  = std::min( step,  minStep);
 
            //  TODO: consider whether/how to reduce the proposed step 
            //        to the latest minStep value - to reduce calculations
 
 #ifdef G4DEBUG_PATHFINDER
            if( fVerboseLevel > 0)
            {
              G4cout.precision(8); 
              G4cout << "G4ITNavigator::ComputeStep> long  proposed step = "
                     << proposedStepLength
                     << "  >  safety = " << previousSafety
                     << " for nav " << num 
                     << " .  New safety = " << safety << " step= " << step
                     << G4endl;      
            } 
 #endif
         }
         fCurrentStepSize[num] = step; 
 
         // Save safety value, must be done for all geometries "together"
         // (even if not recomputed using call to ComputeStep)
         // since they share the fPreSafetyLocation
 
         fPreSafetyValues[num]= safety; 
         fCurrentPreStepSafety[num]= safety; 
 
         minSafety= std::min( safety, minSafety ); 
            
 #ifdef G4DEBUG_PATHFINDER
         if( fVerboseLevel > 2 )
         {
           G4cout << "G4ITPathFinder::DoNextLinearStep : Navigator ["
                  << num << "] -- step size " << step << G4endl;
         }
 #endif
      }
 
      // Only change these when safety is recalculated
      // it is good/relevant only for safety calculations
 
      fPreSafetyLocation=  initialPosition; 
      fPreSafetyMinValue=  minSafety;
   } // end of else for  if( proposedStepLength <= fullSafety)
 
   // For use in Relocation, need PreStep point location, min-safety
   //
   fPreStepLocation= initialPosition; 
   fMinSafety_PreStepPt= minSafety; 
 
   fMinStep=   minStep; 
 
   if( fMinStep == kInfinity )
   {
      minStep = proposedStepLength;   //  Use this below for endpoint !!
   }
   fTrueMinStep = minStep;
 
   // Set the EndState
 
   G4ThreeVector endPosition;
 
   fEndState= initialState; 
   endPosition= initialPosition + minStep * initialDirection ; 
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 1 )
   {
     G4cout << "G4ITPathFinder::DoNextLinearStep : "
            << " initialPosition = " << initialPosition 
            << " and endPosition = " << endPosition<< G4endl;
   }
 #endif
 
   fEndState.SetPosition( endPosition ); 
   fEndState.SetProperTimeOfFlight( -1.000 );   // Not defined YET
 
   if( fNoActiveNavigators == 1 )
   { 
      G4bool transportLimited = (fMinStep!= kInfinity); 
      fLimitTruth[IdTransport] = transportLimited; 
      fLimitedStep[IdTransport] = transportLimited ? kUnique : kDoNot;
 
      // Set fNoGeometriesLimiting - as WhichLimited does
      fNoGeometriesLimiting = transportLimited ? 1 : 0;  
   }
   else
   {
      WhichLimited(); 
   }
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 2 )
   {
     G4cout << " G4ITPathFinder::DoNextLinearStep : exits returning "
            << minStep << G4endl;
     G4cout << "   Endpoint values = " << fEndState << G4endl;
     G4cout << G4endl;
   }
 #endif
 
   return minStep;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ITPathFinder::EnableParallelNavigation ( G4bool enableChoice = true )

Definition at line 125 of file G4ITPathFinder.cc.

 {
 /*
    G4ITNavigator *navigatorForPropagation=0, *massNavigator=0;
 
    massNavigator= fpTransportManager->GetNavigatorForTracking(); 
 */
    if( enableChoice )
    {
      // navigatorForPropagation= fpMultiNavigator;
 
       // Enable SafetyHelper to use PF
       //
       fpTransportManager->GetSafetyHelper()->EnableParallelNavigation(true);
    }
    else
    {
      // navigatorForPropagation= massNavigator;
        
       // Disable SafetyHelper to use PF
       //
       fpTransportManager->GetSafetyHelper()->EnableParallelNavigation(false);
    }
   // fpFieldPropagator->SetNavigatorForPropagating(navigatorForPropagation);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4ITPathFinder::GetCurrentSafety ( ) const

inline

Definition at line 341 of file G4ITPathFinder.hh.

 {
     return fpTrackState->fMinSafety_PreStepPt;
 }

G4ITPathFinder * G4ITPathFinder::GetInstance ( )

static

Definition at line 84 of file G4ITPathFinder.cc.

 {
    if( ! fpPathFinder )
    {
      fpPathFinder = new G4ITPathFinder;
    }
    return fpPathFinder;
 }

Here is the call graph for this function:

G4VPhysicalVolume * G4ITPathFinder::GetLocatedVolume ( G4int navId ) const

inline

Definition at line 318 of file G4ITPathFinder.hh.

 {
     G4VPhysicalVolume* vol=0;
     if( (navId < G4ITNavigator::fMaxNav) && (navId >=0) ) { vol= fpTrackState->fLocatedVolume[navId]; }
     return vol;
 }

G4int G4ITPathFinder::GetMaxLoopCount ( ) const

inline

G4double G4ITPathFinder::GetMinimumStep ( ) const

inline

Definition at line 330 of file G4ITPathFinder.hh.

 { 
     return fpTrackState->fMinStep;
 } 

G4ITNavigator * G4ITPathFinder::GetNavigator ( G4int n ) const

inlineprotected

Definition at line 351 of file G4ITPathFinder.hh.

 { 
     if( (n>fNoActiveNavigators)||(n<0)) { n=0; }
     return fpNavigator[n];
 }

Here is the caller graph for this function:

unsigned int G4ITPathFinder::GetNumberGeometriesLimitingStep ( ) const

inline

Definition at line 335 of file G4ITPathFinder.hh.

 {
     unsigned int noGeometries=fpTrackState->fNoGeometriesLimiting;
     return noGeometries;
 }

G4bool G4ITPathFinder::IsParticleLooping ( ) const

inline

G4double G4ITPathFinder::LastPreSafety	(	G4int	navId,
		G4ThreeVector &	globalCenterPoint,
		G4double &	minSafety
	)

inline

Definition at line 364 of file G4ITPathFinder.hh.

 {
     globalCenterPoint= fpTrackState->fPreSafetyLocation;
     minSafety=         fpTrackState->fPreSafetyMinValue;
     //  navId = std::min( navId, fMaxNav-1 );
     return  fpTrackState->fPreSafetyValues[ navId ];
 }

G4String & G4ITPathFinder::LimitedString ( ELimited lim )

Definition at line 1352 of file G4ITPathFinder.cc.

 {
   static G4String StrDoNot("DoNot"),
                   StrUnique("Unique"),
                   StrUndefined("Undefined"),
                   StrSharedTransport("SharedTransport"),  
                   StrSharedOther("SharedOther");
 
   G4String* limitedStr;
   switch ( lim )
   {
      case kDoNot:  limitedStr= &StrDoNot; break;
      case kUnique: limitedStr = &StrUnique; break; 
      case kSharedTransport:  limitedStr= &StrSharedTransport; break; 
      case kSharedOther: limitedStr = &StrSharedOther; break;
      default: limitedStr = &StrUndefined; break;
   }
   return *limitedStr;
 }

Here is the caller graph for this function:

void G4ITPathFinder::Locate	(	const G4ThreeVector &	position,
		const G4ThreeVector &	direction,
		G4bool	relativeSearch = `true`
	)

Definition at line 463 of file G4ITPathFinder.cc.

 {
   // Locate the point in each geometry
 
   std::vector<G4ITNavigator*>::iterator pNavIter=
      fpTransportManager->GetActiveNavigatorsIterator(); 
 
   G4ThreeVector lastEndPosition= fEndState.GetPosition(); 
   G4ThreeVector moveVec = (position - lastEndPosition );
   G4double      moveLenSq= moveVec.mag2();
   if( (!fNewTrack) && (!fRelocatedPoint)
    && ( moveLenSq> 10*kCarTolerance*kCarTolerance ) )
   {
      ReportMove( position, lastEndPosition, "Position" ); 
   }
   fLastLocatedPosition= position; 
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 2 )
   {
     G4cout << G4endl; 
     G4cout << " G4ITPathFinder::Locate : entered " << G4endl;
     G4cout << " --------------------   -------" <<  G4endl;
     G4cout << "   Locating at position " << position
            << "  with direction " << direction 
            << "  relative= " << relative << G4endl;
     if ( (fVerboseLevel > 1) || ( moveLenSq > 0.0) )
     { 
        G4cout << "  lastEndPosition = " << lastEndPosition
               << "  moveVec = " << moveVec
               << "  newTr = " << fNewTrack 
               << "  relocated = " << fRelocatedPoint << G4endl;
     }
 
     G4cout << " Located at " << position ; 
     if( fNoActiveNavigators > 1 )  { G4cout << G4endl; }
   }
 #endif
 
   for ( G4int num=0; num< fNoActiveNavigators ; ++pNavIter,++num )
   {
      //  ... who limited the step ....
 
      if( fLimitTruth[num] ) { (*pNavIter)->SetGeometricallyLimitedStep(); }
 
      G4VPhysicalVolume *pLocated= 
      (*pNavIter)->LocateGlobalPointAndSetup( position, &direction,
                                              relative,  
                                              false);   
      // Set the state related to the location
      //
      fLocatedVolume[num] = pLocated; 
 
      // Clear state related to the step
      //
      fLimitedStep[num]   = kDoNot; 
      fCurrentStepSize[num] = 0.0;      
     
 #ifdef G4DEBUG_PATHFINDER
      if( fVerboseLevel > 2 )
      {
        G4cout << " - In world " << num << " geomLimStep= " << fLimitTruth[num]
               << "  gives volume= " << pLocated ; 
        if( pLocated )
        { 
          G4cout << "  name = '" << pLocated->GetName() << "'"; 
          G4cout << " - CopyNo= " << pLocated->GetCopyNo(); 
        } 
        G4cout  << G4endl; 
      }
 #endif
   }
 
   fRelocatedPoint= false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ITPathFinder::MovePoint ( )

inline

Definition at line 346 of file G4ITPathFinder.hh.

 {
     fpTrackState->fRelocatedPoint= true;
 }

Here is the caller graph for this function:

G4double G4ITPathFinder::ObtainSafety	(	G4int	navId,
		G4ThreeVector &	globalCenterPoint
	)

inline

Definition at line 357 of file G4ITPathFinder.hh.

 {
     globalCenterPoint= fpTrackState->fSafetyLocation;
     //  navId = std::min( navId, fMaxNav-1 );
     return  fpTrackState->fNewSafetyComputed[ navId ];
 }

void G4ITPathFinder::PrepareNewTrack	(	const G4ThreeVector &	position,
		const G4ThreeVector &	direction,
		G4VPhysicalVolume *	massStartVol = `0`
	)

Definition at line 354 of file G4ITPathFinder.cc.

 {
   // Key purposes:
   //   - Check and cache set of active navigators
   //   - Reset state for new track
 
   G4int num=0; 
 
   EnableParallelNavigation(true); 
     // Switch PropagatorInField to use MultiNavigator
 
   fpTransportManager->GetSafetyHelper()->InitialiseHelper(); 
     // Reinitialise state of safety helper -- avoid problems with overlaps
 
   fNewTrack= true;
   this->MovePoint();   // Signal further that the last status is wiped
 
   // Message the G4NavigatorPanel / Dispatcher to find active navigators
   //
   std::vector<G4ITNavigator*>::iterator pNavigatorIter;
 
   fNoActiveNavigators=  fpTransportManager-> GetNoActiveNavigators();
   if( fNoActiveNavigators > G4ITNavigator::fMaxNav )
   {
     std::ostringstream message;
     message << "Too many active Navigators / worlds." << G4endl
             << "        Transportation Manager has "
             << fNoActiveNavigators << " active navigators." << G4endl
             << "        This is more than the number allowed = "
             << G4ITNavigator::fMaxNav << " !";
     G4Exception("G4ITPathFinder::PrepareNewTrack()", "GeomNav0002",
                 FatalException, message); 
   }
 
   fpMultiNavigator->PrepareNavigators(); 
   //------------------------------------
 
   pNavigatorIter= fpTransportManager->GetActiveNavigatorsIterator();
   for( num=0; num< fNoActiveNavigators; ++pNavigatorIter,++num )
   {
      // Keep information in C-array ... for creating touchables - at least
 
      fpNavigator[num] =  *pNavigatorIter;   
      fLimitTruth[num] = false;
      fLimitedStep[num] = kDoNot;
      fCurrentStepSize[num] = 0.0;
      fLocatedVolume[num] = 0;
   }
   fNoGeometriesLimiting= 0;  // At start of track, no process limited step
 
   // In case of one geometry, the tracking will have done the locating!!
 
   if( fNoActiveNavigators > 1 )
   {
      Locate( position, direction, false );   
   }
   else
   {
      // Update state -- depending on the tracking's call to Mass Navigator
 
      fLastLocatedPosition= position; 
      fLocatedVolume[0]= massStartVol; // This information must be given
                                       // by transportation
      fLimitedStep[0]   = kDoNot; 
      fCurrentStepSize[0] = 0.0;
   }
 
   // Reset Safety Information -- as in case of overlaps this can cause
   // inconsistencies ...
   //
   fMinSafety_PreStepPt= fPreSafetyMinValue= fMinSafety_atSafLocation= 0.0; 
  
   for( num=0; num< fNoActiveNavigators; ++num )
   {
      fPreSafetyValues[num]= 0.0; 
      fNewSafetyComputed[num]= 0.0; 
      fCurrentPreStepSafety[num] = 0.0;
   }
 
   // The first location for each Navigator must be non-relative
   // or else call ResetStackAndState() for each Navigator
 
   fRelocatedPoint= false; 
 }

Here is the call graph for this function:

void G4ITPathFinder::PrintLimited ( )

protected

Definition at line 1081 of file G4ITPathFinder.cc.

 {
   // Report results -- for checking   
 
   G4cout << "G4ITPathFinder::PrintLimited reports: " ;
   G4cout << "  Minimum step (true)= " << fTrueMinStep 
          << "  reported min = " << fMinStep 
          << G4endl; 
   if(  (fCurrentStepNo <= 2) || (fVerboseLevel>=2) )
   {
     G4cout << std::setw(5) << " Step#"  << " "
            << std::setw(5) << " NavId"  << " "
            << std::setw(12) << " step-size " << " "
            << std::setw(12) << " raw-size "  << " "
            << std::setw(12) << " pre-safety " << " " 
            << std::setw(15) << " Limited / flag"  << " "
            << std::setw(15) << "  World "  << " "
            << G4endl;  
   }
   G4int num;
   for ( num= 0; num < fNoActiveNavigators; num++ )
   { 
     G4double rawStep = fCurrentStepSize[num]; 
     G4double stepLen = fCurrentStepSize[num]; 
     if( stepLen > fTrueMinStep )
     { 
       stepLen = fTrueMinStep;     // did not limit (went as far as asked)
     }
     G4int oldPrec= G4cout.precision(9); 
 
     G4cout << std::setw(5) << fCurrentStepNo  << " " 
            << std::setw(5) << num  << " "
            << std::setw(12) << stepLen << " "
            << std::setw(12) << rawStep << " "
            << std::setw(12) << fCurrentPreStepSafety[num] << " "
            << std::setw(5) << (fLimitTruth[num] ? "YES" : " NO") << " ";
     G4String limitedStr= LimitedString(fLimitedStep[num]); 
     G4cout << " " << std::setw(15) << limitedStr << " ";  
     G4cout.precision(oldPrec); 
 
     G4ITNavigator *pNav= GetNavigator( num );
     G4String  WorldName( "Not-Set" ); 
     if (pNav)
     {
        G4VPhysicalVolume *pWorld= pNav->GetWorldVolume(); 
        if( pWorld )
        {
            WorldName = pWorld->GetName(); 
        }
     }
     G4cout << " " << WorldName ; 
     G4cout << G4endl;
   }
 
   if( fVerboseLevel > 4 )
   {
     G4cout << " G4ITPathFinder::PrintLimited - exiting. " << G4endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ITPathFinder::PushPostSafetyToPreSafety ( )

Definition at line 1372 of file G4ITPathFinder.cc.

 {
   fPreSafetyLocation= fSafetyLocation;
   fPreSafetyMinValue= fMinSafety_atSafLocation;
   for( G4int nav=0; nav < fNoActiveNavigators; ++nav )
   {
      fPreSafetyValues[nav]= fNewSafetyComputed[nav];
   }
 }

void G4ITPathFinder::ReLocate ( const G4ThreeVector & position )

Definition at line 541 of file G4ITPathFinder.cc.

 {
   // Locate the point in each geometry
 
   std::vector<G4ITNavigator*>::iterator pNavIter=
     fpTransportManager->GetActiveNavigatorsIterator(); 
 
 #ifdef G4DEBUG_PATHFINDER
 
   // Check that this relocation does not violate safety
   //   - at endpoint (computed from start point) AND
   //   - at last safety location  (likely just called)
 
   G4ThreeVector lastEndPosition= fEndState.GetPosition();
 
   // Calculate end-point safety ...
   //
   G4double      DistanceStartEnd= (lastEndPosition - fPreStepLocation).mag();
   G4double      endPointSafety_raw = fMinSafety_PreStepPt - DistanceStartEnd; 
   G4double      endPointSafety_Est1 = std::max( 0.0, endPointSafety_raw ); 
 
   // ... and check move from endpoint against this endpoint safety
   //
   G4ThreeVector moveVecEndPos  = position - lastEndPosition;
   G4double      moveLenEndPosSq = moveVecEndPos.mag2(); 
 
   // Check that move from endpoint of last step is within safety
   // -- or check against last location or relocation ?? 
   //
   G4ThreeVector moveVecSafety=  position - fSafetyLocation; 
   G4double      moveLenSafSq=   moveVecSafety.mag2();
 
   G4double distCheckEnd_sq= ( moveLenEndPosSq - endPointSafety_Est1 
                                                *endPointSafety_Est1 ); 
   G4double distCheckSaf_sq=   ( moveLenSafSq -  fMinSafety_atSafLocation
                                                *fMinSafety_atSafLocation ); 
 
   G4bool longMoveEnd = distCheckEnd_sq > 0.0; 
   G4bool longMoveSaf = distCheckSaf_sq > 0.0; 
 
   G4double revisedSafety= 0.0;
 
   if( (!fNewTrack) && ( longMoveEnd && longMoveSaf ) )
   {  
      // Recompute ComputeSafety for end position
      //
      revisedSafety= ComputeSafety(lastEndPosition); 
 
      const G4double kRadTolerance =
        G4GeometryTolerance::GetInstance()->GetRadialTolerance();
      const G4double cErrorTolerance=1e-12;   
        // Maximum relative error from roundoff of arithmetic 
 
      G4double  distCheckRevisedEnd= moveLenEndPosSq-revisedSafety*revisedSafety;
 
      G4bool  longMoveRevisedEnd=  ( distCheckRevisedEnd > 0. ) ; 
 
      G4double  moveMinusSafety= 0.0; 
      G4double  moveLenEndPosition= std::sqrt( moveLenEndPosSq );
      moveMinusSafety = moveLenEndPosition - revisedSafety; 
 
      if ( longMoveRevisedEnd && (moveMinusSafety > 0.0 )
        && ( revisedSafety > 0.0 ) )
      {
         // Take into account possibility of roundoff error causing
         // this apparent move further than safety
 
         if( fVerboseLevel > 0 )
         {
            G4cout << " G4PF:Relocate> Ratio to revised safety is " 
                   << std::fabs(moveMinusSafety)/revisedSafety << G4endl;
         }
 
         G4double  absMoveMinusSafety= std::fabs(moveMinusSafety);
         G4bool smallRatio= absMoveMinusSafety < kRadTolerance * revisedSafety ; 
         G4double maxCoordPos = std::max( 
                                       std::max( std::fabs(position.x()), 
                                                 std::fabs(position.y())), 
                                       std::fabs(position.z()) );
         G4bool smallValue= absMoveMinusSafety < cErrorTolerance * maxCoordPos;
         if( ! (smallRatio || smallValue) )
         {
            G4cout << " G4PF:Relocate> Ratio to revised safety is " 
                   << std::fabs(moveMinusSafety)/revisedSafety << G4endl;
            G4cout << " Difference of move and safety is not very small."
                   << G4endl;
         }
         else
         {
           moveMinusSafety = 0.0; 
           longMoveRevisedEnd = false;   // Numerical issue -- not too long!
 
           G4cout << " Difference of move & safety is very small in magnitude, "
                  << absMoveMinusSafety << G4endl;
           if( smallRatio )
           {
             G4cout << " ratio to safety " << revisedSafety 
                    << " is " <<  absMoveMinusSafety / revisedSafety
                    << "smaller than " << kRadTolerance << " of safety ";
           }
           else
           {
             G4cout << " as fraction " << absMoveMinusSafety / maxCoordPos 
                    << " of position vector max-coord " << maxCoordPos
                    << " smaller than " << cErrorTolerance ;
           }
           G4cout << " -- reset moveMinusSafety to "
                  << moveMinusSafety << G4endl;
         }
      }
 
      if ( longMoveEnd && longMoveSaf
        && longMoveRevisedEnd && (moveMinusSafety>0.0) )
      { 
         G4int oldPrec= G4cout.precision(9); 
         std::ostringstream message;
         message << "ReLocation is further than end-safety value." << G4endl
                 << " Moved from last endpoint by " << moveLenEndPosition 
                 << " compared to end safety (from preStep point) = " 
                 << endPointSafety_Est1 << G4endl
                 << "  --> last PreSafety Location was " << fPreSafetyLocation
                 << G4endl
                 << "       safety value =  " << fPreSafetyMinValue << G4endl
                 << "  --> last PreStep Location was " << fPreStepLocation
                 << G4endl
                 << "       safety value =  " << fMinSafety_PreStepPt << G4endl
                 << "  --> last EndStep Location was " << lastEndPosition
                 << G4endl
                 << "       safety value =  " << endPointSafety_Est1 
                 << " raw-value = " << endPointSafety_raw << G4endl
                 << "  --> Calling again at this endpoint, we get "
                 <<  revisedSafety << " as safety value."  << G4endl
                 << "  --> last position for safety " << fSafetyLocation
                 << G4endl
                 << "       its safety value =  " << fMinSafety_atSafLocation
                 << G4endl
                 << "       move from safety location = "
                 << std::sqrt(moveLenSafSq) << G4endl
                 << "         again= " << moveVecSafety.mag() << G4endl
                 << "       safety - Move-from-end= " 
                 << revisedSafety - moveLenEndPosition
                 << " (negative is Bad.)" << G4endl
                 << " Debug:  distCheckRevisedEnd = "
                 << distCheckRevisedEnd;
         ReportMove( lastEndPosition, position, "Position" ); 
         G4Exception("G4ITPathFinder::ReLocate", "GeomNav0003",
                     FatalException, message); 
         G4cout.precision(oldPrec); 
     }
   }
 
   if( fVerboseLevel > 2 )
   {
     G4cout << G4endl; 
     G4cout << " G4ITPathFinder::ReLocate : entered " << G4endl;
     G4cout << " ----------------------   -------" <<  G4endl;
     G4cout << "  *Re*Locating at position " << position  << G4endl; 
       // << "  with direction " << direction 
       // << "  relative= " << relative << G4endl;
     if ( (fVerboseLevel > -1) || ( moveLenEndPosSq > 0.0) )
     {
        G4cout << "  lastEndPosition = " << lastEndPosition
               << "  moveVec from step-end = " << moveVecEndPos
               << "  is new Track = " << fNewTrack 
               << "  relocated = " << fRelocatedPoint << G4endl;
     }
   }
 #endif // G4DEBUG_PATHFINDER
 
   for ( G4int num=0; num< fNoActiveNavigators ; ++pNavIter,++num )
   {
      //  ... none limited the step
 
      (*pNavIter)->LocateGlobalPointWithinVolume( position ); 
 
      // Clear state related to the step
      //
      fLimitedStep[num]   = kDoNot; 
      fCurrentStepSize[num] = 0.0;      
      fLimitTruth[num] = false;   
   }
 
   fLastLocatedPosition= position; 
   fRelocatedPoint= false;
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 2 )
   {
     G4cout << " G4ITPathFinder::ReLocate : exiting "
            << "  at position " << fLastLocatedPosition << G4endl << G4endl;
   }
 #endif
 }

Here is the call graph for this function:

void G4ITPathFinder::ReportMove	(	const G4ThreeVector &	OldV,
		const G4ThreeVector &	NewV,
		const G4String &	Quantity
	)		const

protected

Definition at line 441 of file G4ITPathFinder.cc.

 {
     G4ThreeVector moveVec = ( NewVector - OldVector );
 
     G4int prc= G4cerr.precision(12); 
     std::ostringstream message;
     message << "Endpoint moved between value returned by ComputeStep()"
             << " and call to Locate(). " << G4endl
             << "          Change of " << Quantity << " is "
             << moveVec.mag() / mm << " mm long" << G4endl
             << "          and its vector is "
             << (1.0/mm) * moveVec << " mm " << G4endl
             << "          Endpoint of ComputeStep() was " << OldVector << G4endl
             << "          and current position to locate is " << NewVector;
     G4Exception("G4ITPathFinder::ReportMove()", "GeomNav1002",
                 JustWarning, message); 
     G4cerr.precision(prc); 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ITPathFinder::SetMaxLoopCount ( G4int new_max )

inline

G4int G4ITPathFinder::SetVerboseLevel ( G4int lev = -1 )

inline

Definition at line 325 of file G4ITPathFinder.hh.

 {
     G4int old= fVerboseLevel;  fVerboseLevel= newLevel; return old;
 }

G4bool G4ITPathFinder::UseSafetyForOptimization ( G4bool )

inlineprotected

void G4ITPathFinder::WhichLimited ( )

protected

Definition at line 1023 of file G4ITPathFinder.cc.

 {
   // Flag which processes limited the step
 
   G4int num=-1, last=-1; 
   G4int noLimited=0; 
   ELimited shared= kSharedOther; 
 
   const G4int IdTransport= 0;  // Id of Mass Navigator !!
 
   // Assume that [IdTransport] is Mass / Transport
   //
   G4bool transportLimited = (fCurrentStepSize[IdTransport] == fMinStep)
                            && ( fMinStep!= kInfinity) ; 
 
   if( transportLimited )  { 
      shared= kSharedTransport;
   }
 
   for ( num= 0; num < fNoActiveNavigators; num++ )
   { 
     G4bool limitedStep;
 
     G4double step= fCurrentStepSize[num]; 
 
     limitedStep = ( std::fabs(step - fMinStep) < kCarTolerance ) 
                  && ( step != kInfinity); 
 
     fLimitTruth[ num ] = limitedStep; 
     if( limitedStep )
     {
       noLimited++;  
       fLimitedStep[num] = shared;
       last= num; 
     }
     else
     {
       fLimitedStep[num] = kDoNot;
     }
   }
   fNoGeometriesLimiting= noLimited;  // Save # processes limiting step
 
   if( (last > -1) && (noLimited == 1 ) )
   {
     fLimitedStep[ last ] = kUnique; 
   }
 
 #ifdef G4DEBUG_PATHFINDER
   if( fVerboseLevel > 1 )
   {
     PrintLimited();   // --> for tracing 
     if( fVerboseLevel > 4 ) {
       G4cout << " G4ITPathFinder::WhichLimited - exiting. " << G4endl;
     }
   }
 #endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

geant4.10.03.p01/source/processes/electromagnetic/dna/management/include/G4ITPathFinder.hh
geant4.10.03.p01/source/processes/electromagnetic/dna/management/src/G4ITPathFinder.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation