G4ITPathFinder Class Reference

#include <G4ITPathFinder.hh>

Inheritance diagram for G4ITPathFinder:

Public Types
typedef G4ITPathFinder	ClassType
typedef G4TrackState< G4ITPathFinder >	StateType
typedef G4shared_ptr< StateType >	StateTypeHandle

Public Member Functions
G4double	ComputeSafety (const G4ThreeVector &globalPoint)
G4double	ComputeStep (const G4FieldTrack &pFieldTrack, G4double pCurrentProposedStepLength, G4int navigatorId, G4int stepNo, G4double &pNewSafety, ELimited &limitedStep, G4FieldTrack &EndState, G4VPhysicalVolume *currentVolume)
G4TouchableHandle	CreateTouchableHandle (G4int navId) const
virtual StateTypeHandle	CreateTrackState () const
void	EnableParallelNavigation (G4bool enableChoice=true)
virtual StateTypeHandle	GetConcreteTrackState () const
G4double	GetCurrentSafety () const
G4VPhysicalVolume *	GetLocatedVolume (G4int navId) const
G4int	GetMaxLoopCount () const
G4double	GetMinimumStep () const
unsigned int	GetNumberGeometriesLimitingStep () const
virtual G4VTrackStateHandle	GetTrackState () const
G4bool	IsParticleLooping () const
G4double	LastPreSafety (G4int navId, G4ThreeVector &globalCenterPoint, G4double &minSafety)
G4String &	LimitedString (ELimited lim)
virtual void	LoadTrackState (G4TrackStateManager &manager)
void	Locate (const G4ThreeVector &position, const G4ThreeVector &direction, G4bool relativeSearch=true)
void	MovePoint ()
virtual void	NewTrackState ()
G4double	ObtainSafety (G4int navId, G4ThreeVector &globalCenterPoint)
virtual G4VTrackStateHandle	PopTrackState ()
void	PrepareNewTrack (const G4ThreeVector &position, const G4ThreeVector &direction, G4VPhysicalVolume *massStartVol=0)
void	PushPostSafetyToPreSafety ()
void	ReLocate (const G4ThreeVector &position)
virtual void	ResetTrackState ()
virtual void	SaveTrackState (G4TrackStateManager &manager)
void	SetMaxLoopCount (G4int new_max)
virtual void	SetTrackState (G4shared_ptr< StateType > state)
G4int	SetVerboseLevel (G4int lev=-1)

Static Public Member Functions
static G4ITPathFinder *	GetInstance ()

Protected Member Functions
G4double	DoNextCurvedStep (const G4FieldTrack &FieldTrack, G4double proposedStepLength, G4VPhysicalVolume *pCurrentPhysVolume)
G4double	DoNextLinearStep (const G4FieldTrack &FieldTrack, G4double proposedStepLength)
	G4ITPathFinder ()
G4ITNavigator *	GetNavigator (G4int n) const
void	PrintLimited ()
void	ReportMove (const G4ThreeVector &OldV, const G4ThreeVector &NewV, const G4String &Quantity) const
G4bool	UseSafetyForOptimization (G4bool)
void	WhichLimited ()
	~G4ITPathFinder ()

Protected Attributes
StateTypeHandle	fpTrackState

Private Attributes
G4int	fNoActiveNavigators
G4ITMultiNavigator *	fpMultiNavigator
G4ITNavigator *	fpNavigator [G4ITNavigator::fMaxNav]
G4ITTransportationManager *	fpTransportManager
G4int	fVerboseLevel
G4double	kCarTolerance

Static Private Attributes
static G4ThreadLocal G4ITPathFinder *	fpPathFinder =0

Detailed Description

Definition at line 156 of file G4ITPathFinder.hh.

Member Typedef Documentation

ClassType

typedef G4ITPathFinder G4TrackStateDependent< G4ITPathFinder >::ClassType

inherited

Definition at line 238 of file G4TrackState.hh.

StateType

typedef G4TrackState<G4ITPathFinder > G4TrackStateDependent< G4ITPathFinder >::StateType

inherited

Definition at line 239 of file G4TrackState.hh.

StateTypeHandle

typedef G4shared_ptr<StateType> G4TrackStateDependent< G4ITPathFinder >::StateTypeHandle

inherited

Definition at line 240 of file G4TrackState.hh.

Constructor & Destructor Documentation

G4ITPathFinder()

G4ITPathFinder::G4ITPathFinder ( )

protected

Definition at line 95 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;   
   }
}

References fNoActiveNavigators, fpMultiNavigator, fpNavigator, fpTransportManager, G4GeometryTolerance::GetInstance(), G4GeometryTolerance::GetSurfaceTolerance(), G4ITTransportationManager::GetTransportationManager(), and kCarTolerance.

Referenced by GetInstance().

~G4ITPathFinder()

G4ITPathFinder::~G4ITPathFinder ( )

protected

Definition at line 115 of file G4ITPathFinder.cc.

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

References fpMultiNavigator, and fpPathFinder.

Member Function Documentation

ComputeSafety()

G4double G4ITPathFinder::ComputeSafety

(

const G4ThreeVector &

globalPoint

)

Definition at line 736 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; 
}

References fMinSafety_atSafLocation, fNewSafetyComputed, fNoActiveNavigators, fpTransportManager, fSafetyLocation, fVerboseLevel, G4cout, G4endl, G4ITTransportationManager::GetActiveNavigatorsIterator(), kInfinity, and position.

Referenced by ReLocate().

ComputeStep()

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

Definition at line 153 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;
}

References DoNextLinearStep(), FatalException, fCurrentPreStepSafety, fCurrentStepNo, fCurrentStepSize, fEndState, fLastLocatedPosition, fLastStepNo, fLimitedStep, fMinStep, fNewTrack, fNoActiveNavigators, fNoGeometriesLimiting, fRelocatedPoint, fTrueMinStep, fVerboseLevel, G4cout, G4endl, G4Exception(), G4FieldTrack::GetMomentumDirection(), G4FieldTrack::GetPosition(), kCarTolerance, Locate(), CLHEP::Hep3Vector::mag2(), G4INCL::Math::min(), mm, and MovePoint().

CreateTouchableHandle()

G4TouchableHandle G4ITPathFinder::CreateTouchableHandle

(

G4int

navId

)

const

Definition at line 769 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); 
}

References fLocatedVolume, fVerboseLevel, G4cout, G4endl, G4TouchableHistory::GetHistory(), G4VPhysicalVolume::GetName(), GetNavigator(), and G4TouchableHistory::UpdateYourself().

CreateTrackState()

virtual StateTypeHandle G4TrackStateDependent< G4ITPathFinder >::CreateTrackState ( ) const

inlinevirtualinherited

Definition at line 290 of file G4TrackState.hh.

  {
    return StateTypeHandle(new StateType());
  }

DoNextCurvedStep()

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

protected

Definition at line 1141 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; 
}

References FatalException, fCurrentPreStepSafety, fCurrentStepSize, fEndState, fLimitedStep, fLimitTruth, fMinSafety_PreStepPt, fMinStep, fNoActiveNavigators, fNoGeometriesLimiting, fpMultiNavigator, fpNavigator, fPreSafetyLocation, fPreSafetyMinValue, fPreSafetyValues, fPreStepCenterRenewed, fPreStepLocation, fTrueMinStep, fVerboseLevel, G4cout, G4endl, G4Exception(), G4FieldTrack::GetPosition(), kDoNot, kInfinity, LimitedString(), G4INCL::Math::min(), G4ITMultiNavigator::ObtainFinalStep(), and PrintLimited().

DoNextLinearStep()

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

protected

Definition at line 805 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;
}

References fCurrentPreStepSafety, fCurrentStepSize, fEndState, fLimitedStep, fLimitTruth, fMinSafety_PreStepPt, fMinStep, fNoActiveNavigators, fNoGeometriesLimiting, fPreSafetyLocation, fPreSafetyMinValue, fPreSafetyValues, fPreStepCenterRenewed, fPreStepLocation, fpTransportManager, fTrueMinStep, fVerboseLevel, G4cout, G4endl, G4FieldTrack::GetMomentumDirection(), G4FieldTrack::GetPosition(), kDoNot, kInfinity, kUnique, CLHEP::Hep3Vector::mag2(), G4INCL::Math::max(), G4INCL::Math::min(), sqr(), and WhichLimited().

Referenced by ComputeStep().

EnableParallelNavigation()

void G4ITPathFinder::EnableParallelNavigation

(

G4bool

enableChoice = true

)

Definition at line 124 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);
}

References G4ITSafetyHelper::EnableParallelNavigation(), fpTransportManager, and G4ITTransportationManager::GetSafetyHelper().

Referenced by PrepareNewTrack().

GetConcreteTrackState()

virtual StateTypeHandle G4TrackStateDependent< G4ITPathFinder >::GetConcreteTrackState ( ) const

inlinevirtualinherited

Definition at line 264 of file G4TrackState.hh.

  {
    return fpTrackState;
  }

GetCurrentSafety()

G4double G4ITPathFinder::GetCurrentSafety ( ) const

inline

Definition at line 340 of file G4ITPathFinder.hh.

{
    return fpTrackState->fMinSafety_PreStepPt;
}

References G4TrackStateDependent< G4ITPathFinder >::fpTrackState.

GetInstance()

G4ITPathFinder * G4ITPathFinder::GetInstance ( )

static

Definition at line 83 of file G4ITPathFinder.cc.

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

References fpPathFinder, and G4ITPathFinder().

GetLocatedVolume()

G4VPhysicalVolume * G4ITPathFinder::GetLocatedVolume ( G4int  navId ) const

inline

Definition at line 317 of file G4ITPathFinder.hh.

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

References G4TrackStateDependent< G4ITPathFinder >::fpTrackState.

GetMaxLoopCount()

G4int G4ITPathFinder::GetMaxLoopCount ( ) const

inline

GetMinimumStep()

G4double G4ITPathFinder::GetMinimumStep ( ) const

inline

Definition at line 329 of file G4ITPathFinder.hh.

{ 
    return fpTrackState->fMinStep;
} 

References G4TrackStateDependent< G4ITPathFinder >::fpTrackState.

GetNavigator()

G4ITNavigator * G4ITPathFinder::GetNavigator ( G4int  n ) const

inlineprotected

Definition at line 350 of file G4ITPathFinder.hh.

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

References fNoActiveNavigators, fpNavigator, and CLHEP::detail::n.

Referenced by CreateTouchableHandle(), and PrintLimited().

GetNumberGeometriesLimitingStep()

unsigned int G4ITPathFinder::GetNumberGeometriesLimitingStep ( ) const

inline

Definition at line 334 of file G4ITPathFinder.hh.

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

References G4TrackStateDependent< G4ITPathFinder >::fpTrackState.

GetTrackState()

virtual G4VTrackStateHandle G4TrackStateDependent< G4ITPathFinder >::GetTrackState ( ) const

inlinevirtualinherited

Implements G4VTrackStateDependent.

Definition at line 257 of file G4TrackState.hh.

  {
    G4VTrackStateHandle output =
      G4dynamic_pointer_cast<G4VTrackState>(fpTrackState);
    return output;
  }

IsParticleLooping()

G4bool G4ITPathFinder::IsParticleLooping ( ) const

inline

LastPreSafety()

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

inline

Definition at line 363 of file G4ITPathFinder.hh.

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

References G4TrackStateDependent< G4ITPathFinder >::fpTrackState.

LimitedString()

G4String & G4ITPathFinder::LimitedString

(

ELimited

lim

)

Definition at line 1351 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;
}

References kDoNot, kSharedOther, kSharedTransport, and kUnique.

Referenced by DoNextCurvedStep(), and PrintLimited().

LoadTrackState()

virtual void G4TrackStateDependent< G4ITPathFinder >::LoadTrackState ( G4TrackStateManager &  manager )

inlinevirtualinherited

Implements G4VTrackStateDependent.

Definition at line 269 of file G4TrackState.hh.

  {
    fpTrackState =
      ConvertToConcreteTrackState<ClassType>(manager.GetTrackState(this));
    if (fpTrackState == nullptr)
    {
      NewTrackState();
      SaveTrackState(manager);
    }
  }

Locate()

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

Definition at line 462 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;
}

References fCurrentStepSize, fEndState, fLastLocatedPosition, fLimitedStep, fLimitTruth, fLocatedVolume, fNewTrack, fNoActiveNavigators, fpTransportManager, fRelocatedPoint, fVerboseLevel, G4cout, G4endl, G4ITTransportationManager::GetActiveNavigatorsIterator(), kCarTolerance, kDoNot, CLHEP::Hep3Vector::mag2(), position, and ReportMove().

Referenced by ComputeStep(), and PrepareNewTrack().

MovePoint()

void G4ITPathFinder::MovePoint ( )

inline

Definition at line 345 of file G4ITPathFinder.hh.

{
    fpTrackState->fRelocatedPoint= true;
}

References G4TrackStateDependent< G4ITPathFinder >::fpTrackState.

Referenced by ComputeStep(), and PrepareNewTrack().

NewTrackState()

virtual void G4TrackStateDependent< G4ITPathFinder >::NewTrackState ( )

inlinevirtualinherited

Implements G4VTrackStateDependent.

Definition at line 285 of file G4TrackState.hh.

  {
    fpTrackState = StateTypeHandle(new StateType());
  }

ObtainSafety()

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

inline

Definition at line 356 of file G4ITPathFinder.hh.

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

References G4TrackStateDependent< G4ITPathFinder >::fpTrackState.

PopTrackState()

virtual G4VTrackStateHandle G4TrackStateDependent< G4ITPathFinder >::PopTrackState ( )

inlinevirtualinherited

Implements G4VTrackStateDependent.

Definition at line 249 of file G4TrackState.hh.

  {
    G4VTrackStateHandle output =
      G4dynamic_pointer_cast<G4VTrackState>(fpTrackState);
    fpTrackState.reset();
    return output;
  }

PrepareNewTrack()

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

Definition at line 353 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; 
}

References EnableParallelNavigation(), FatalException, fCurrentPreStepSafety, fCurrentStepSize, fLastLocatedPosition, fLimitedStep, fLimitTruth, fLocatedVolume, fMinSafety_atSafLocation, fMinSafety_PreStepPt, fNewSafetyComputed, fNewTrack, fNoActiveNavigators, fNoGeometriesLimiting, fpMultiNavigator, fpNavigator, fPreSafetyMinValue, fPreSafetyValues, fpTransportManager, fRelocatedPoint, G4endl, G4Exception(), G4ITTransportationManager::GetActiveNavigatorsIterator(), G4ITTransportationManager::GetSafetyHelper(), G4ITSafetyHelper::InitialiseHelper(), kDoNot, Locate(), MovePoint(), position, and G4ITMultiNavigator::PrepareNavigators().

PrintLimited()

void G4ITPathFinder::PrintLimited ( )

protected

Definition at line 1080 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;
  }
}

References fCurrentPreStepSafety, fCurrentStepNo, fCurrentStepSize, fLimitedStep, fLimitTruth, fMinStep, fNoActiveNavigators, fTrueMinStep, fVerboseLevel, G4cout, G4endl, G4VPhysicalVolume::GetName(), GetNavigator(), and LimitedString().

Referenced by DoNextCurvedStep(), and WhichLimited().

PushPostSafetyToPreSafety()

void G4ITPathFinder::PushPostSafetyToPreSafety

(

)

Definition at line 1371 of file G4ITPathFinder.cc.

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

References fMinSafety_atSafLocation, fNewSafetyComputed, fNoActiveNavigators, fPreSafetyLocation, fPreSafetyMinValue, fPreSafetyValues, and fSafetyLocation.

ReLocate()

void G4ITPathFinder::ReLocate

(

const G4ThreeVector &

position

)

Definition at line 540 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
}

References ComputeSafety(), FatalException, fCurrentStepSize, fEndState, fLastLocatedPosition, fLimitedStep, fLimitTruth, fMinSafety_atSafLocation, fMinSafety_PreStepPt, fNewTrack, fNoActiveNavigators, fPreSafetyLocation, fPreSafetyMinValue, fPreStepLocation, fpTransportManager, fRelocatedPoint, fSafetyLocation, fVerboseLevel, G4cout, G4endl, G4Exception(), G4ITTransportationManager::GetActiveNavigatorsIterator(), G4GeometryTolerance::GetInstance(), G4GeometryTolerance::GetRadialTolerance(), kDoNot, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), G4INCL::Math::max(), position, and ReportMove().

ReportMove()

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

protected

Definition at line 440 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); 
}

References G4cerr, G4endl, G4Exception(), JustWarning, CLHEP::Hep3Vector::mag(), and mm.

Referenced by Locate(), and ReLocate().

ResetTrackState()

virtual void G4TrackStateDependent< G4ITPathFinder >::ResetTrackState ( )

inlinevirtualinherited

Implements G4VTrackStateDependent.

Definition at line 295 of file G4TrackState.hh.

  {
    fpTrackState.reset();
  }

SaveTrackState()

virtual void G4TrackStateDependent< G4ITPathFinder >::SaveTrackState ( G4TrackStateManager &  manager )

inlinevirtualinherited

Implements G4VTrackStateDependent.

Definition at line 280 of file G4TrackState.hh.

  {
    manager.SetTrackState(this, ConvertToAbstractTrackState(fpTrackState));
  }

SetMaxLoopCount()

void G4ITPathFinder::SetMaxLoopCount ( G4int  new_max )

inline

SetTrackState()

virtual void G4TrackStateDependent< G4ITPathFinder >::SetTrackState ( G4shared_ptr< StateType >  state )

inlinevirtualinherited

Definition at line 244 of file G4TrackState.hh.

  {
    fpTrackState = state;
  }

SetVerboseLevel()

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

inline

Definition at line 324 of file G4ITPathFinder.hh.

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

References fVerboseLevel.

UseSafetyForOptimization()

G4bool G4ITPathFinder::UseSafetyForOptimization ( G4bool  )

inlineprotected

WhichLimited()

void G4ITPathFinder::WhichLimited ( )

protected

Definition at line 1022 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
}

References fCurrentStepSize, fLimitedStep, fLimitTruth, fMinStep, fNoActiveNavigators, fNoGeometriesLimiting, fVerboseLevel, G4cout, G4endl, kCarTolerance, kDoNot, kInfinity, kSharedOther, kSharedTransport, kUnique, and PrintLimited().

Referenced by DoNextLinearStep().

Field Documentation

fNoActiveNavigators

G4int G4ITPathFinder::fNoActiveNavigators

private

Definition at line 298 of file G4ITPathFinder.hh.

Referenced by ComputeSafety(), ComputeStep(), DoNextCurvedStep(), DoNextLinearStep(), G4ITPathFinder(), GetNavigator(), Locate(), PrepareNewTrack(), PrintLimited(), PushPostSafetyToPreSafety(), ReLocate(), and WhichLimited().

fpMultiNavigator

G4ITMultiNavigator* G4ITPathFinder::fpMultiNavigator

private

Definition at line 294 of file G4ITPathFinder.hh.

Referenced by DoNextCurvedStep(), G4ITPathFinder(), PrepareNewTrack(), and ~G4ITPathFinder().

fpNavigator

G4ITNavigator* G4ITPathFinder::fpNavigator[G4ITNavigator::fMaxNav]

private

Definition at line 300 of file G4ITPathFinder.hh.

Referenced by DoNextCurvedStep(), G4ITPathFinder(), GetNavigator(), and PrepareNewTrack().

fpPathFinder

G4ThreadLocal G4ITPathFinder * G4ITPathFinder::fpPathFinder =0

staticprivate

Definition at line 309 of file G4ITPathFinder.hh.

Referenced by GetInstance(), and ~G4ITPathFinder().

fpTrackState

StateTypeHandle G4TrackStateDependent< G4ITPathFinder >::fpTrackState

protectedinherited

Definition at line 305 of file G4TrackState.hh.

fpTransportManager

G4ITTransportationManager* G4ITPathFinder::fpTransportManager

private

Definition at line 304 of file G4ITPathFinder.hh.

Referenced by ComputeSafety(), DoNextLinearStep(), EnableParallelNavigation(), G4ITPathFinder(), Locate(), PrepareNewTrack(), and ReLocate().

fVerboseLevel

G4int G4ITPathFinder::fVerboseLevel

private

Definition at line 302 of file G4ITPathFinder.hh.

Referenced by ComputeSafety(), ComputeStep(), CreateTouchableHandle(), DoNextCurvedStep(), DoNextLinearStep(), Locate(), PrintLimited(), ReLocate(), SetVerboseLevel(), and WhichLimited().

kCarTolerance

G4double G4ITPathFinder::kCarTolerance

private

Definition at line 307 of file G4ITPathFinder.hh.

Referenced by ComputeStep(), G4ITPathFinder(), Locate(), and WhichLimited().

---

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

• source/processes/electromagnetic/dna/management/include/G4ITPathFinder.hh
• source/processes/electromagnetic/dna/management/src/G4ITPathFinder.cc