G4MultiLevelLocator Class Reference

#include <G4MultiLevelLocator.hh>

Inheritance diagram for G4MultiLevelLocator:

Public Member Functions
void	AddAdjustementOfFoundIntersection (G4bool UseCorrection)
void	AdjustIntersections (G4bool UseCorrection)
G4bool	AreIntersectionsAdjusted ()
G4bool	EstimateIntersectionPoint (const G4FieldTrack &curveStartPointTangent, const G4FieldTrack &curveEndPointTangent, const G4ThreeVector &trialPoint, G4FieldTrack &intersectPointTangent, G4bool &recalculatedEndPoint, G4double &fPreviousSafety, G4ThreeVector &fPreviousSftOrigin)
	G4MultiLevelLocator (G4Navigator *theNavigator)
G4bool	GetAdjustementOfFoundIntersection ()
G4bool	GetCheckMode ()
G4ChordFinder *	GetChordFinderFor ()
G4double	GetDeltaIntersectionFor ()
G4double	GetEpsilonStepFor ()
G4Navigator *	GetNavigatorFor ()
G4int	GetVerboseFor ()
G4bool	IntersectChord (const G4ThreeVector &StartPointA, const G4ThreeVector &EndPointB, G4double &NewSafety, G4double &PreviousSafety, G4ThreeVector &PreviousSftOrigin, G4double &LinearStepLength, G4ThreeVector &IntersectionPoint, G4bool *calledNavigator=nullptr)
void	printStatus (const G4FieldTrack &startFT, const G4FieldTrack &currentFT, G4double requestStep, G4double safety, G4int stepNum)
void	ReportStatistics ()
void	SetCheckMode (G4bool value)
void	SetChordFinderFor (G4ChordFinder *fCFinder)
void	SetDeltaIntersectionFor (G4double deltaIntersection)
void	SetEpsilonStepFor (G4double EpsilonStep)
void	SetMaxSteps (unsigned int valMax)
void	SetNavigatorFor (G4Navigator *fNavigator)
void	SetSafetyParametersFor (G4bool UseSafety)
void	SetVerboseFor (G4int fVerbose)
void	SetWarnSteps (unsigned int valWarn)
	~G4MultiLevelLocator ()

Static Public Member Functions
static void	printStatus (const G4FieldTrack &startFT, const G4FieldTrack &currentFT, G4double requestStep, G4double safety, G4int stepNum, std::ostream &oss, G4int verboseLevel)

Protected Member Functions
G4bool	AdjustmentOfFoundIntersection (const G4ThreeVector &A, const G4ThreeVector &CurrentE_Point, const G4ThreeVector &CurrentF_Point, const G4ThreeVector &MomentumDir, const G4bool IntersectAF, G4ThreeVector &IntersectionPoint, G4double &NewSafety, G4double &fPrevSafety, G4ThreeVector &fPrevSftOrigin)
G4bool	CheckAndReEstimateEndpoint (const G4FieldTrack &CurrentStartA, const G4FieldTrack &EstimatedEndB, G4FieldTrack &RevisedEndPoint, G4int &errorCode)
G4ThreeVector	GetGlobalSurfaceNormal (const G4ThreeVector &CurrentE_Point, G4bool &validNormal)
G4ThreeVector	GetSurfaceNormal (const G4ThreeVector &CurrentInt_Point, G4bool &validNormal)
G4bool	LocateGlobalPointWithinVolumeAndCheck (const G4ThreeVector &pos)
void	LocateGlobalPointWithinVolumeCheckAndReport (const G4ThreeVector &pos, const G4String &CodeLocationInfo, G4int CheckMode)
G4FieldTrack	ReEstimateEndpoint (const G4FieldTrack &CurrentStateA, const G4FieldTrack &EstimtdEndStateB, G4double linearDistSq, G4double curveDist)
void	ReportImmediateHit (const char *MethodName, const G4ThreeVector &StartPosition, const G4ThreeVector &TrialPoint, G4double tolerance, unsigned long int numCalls)
void	ReportProgress (std::ostream &oss, const G4FieldTrack &StartPointVel, const G4FieldTrack &EndPointVel, G4int substep_no, const G4FieldTrack &A_PtVel, const G4FieldTrack &B_PtVel, G4double safetyLast, G4int depth=-1)
void	ReportReversedPoints (std::ostringstream &ossMsg, const G4FieldTrack &StartPointVel, const G4FieldTrack &EndPointVel, G4double NewSafety, G4double epsStep, const G4FieldTrack &CurrentA_PointVelocity, const G4FieldTrack &CurrentB_PointVelocity, const G4FieldTrack &SubStart_PointVelocity, const G4ThreeVector &CurrentE_Point, const G4FieldTrack &ApproxIntersecPointV, G4int sbstp_no, G4int sbstp_no_p, G4int depth)
void	ReportTrialStep (G4int step_no, const G4ThreeVector &ChordAB_v, const G4ThreeVector &ChordEF_v, const G4ThreeVector &NewMomentumDir, const G4ThreeVector &NormalAtEntry, G4bool validNormal)

Protected Attributes
G4bool	fCheckMode = false
G4Navigator *	fHelpingNavigator
G4ChordFinder *	fiChordFinder = nullptr
G4double	fiDeltaIntersection = -1.0
G4double	fiEpsilonStep = -1.0
G4Navigator *	fiNavigator
G4bool	fiUseSafety = false
G4TouchableHistory *	fpTouchable = nullptr
G4bool	fUseNormalCorrection = false
G4int	fVerboseLevel = 0
G4double	kCarTolerance

Private Member Functions
G4ThreeVector	GetLastSurfaceNormal (const G4ThreeVector &intersectPoint, G4bool &validNormal) const
G4ThreeVector	GetLocalSurfaceNormal (const G4ThreeVector &CurrentE_Point, G4bool &validNormal)
void	ReportFieldValue (const G4FieldTrack &locationPV, const char *nameLoc, const G4EquationOfMotion *equation)

Private Attributes
unsigned int	fMaxSteps = 10000
unsigned long int	fNumAdvanceFull = 0
unsigned long int	fNumAdvanceGood = 0
unsigned long int	fNumAdvanceTrials = 0
unsigned long int	fNumCalls = 0
unsigned int	fWarnSteps = 1000
G4FieldTrack *	ptrInterMedFT [max_depth+1]

Static Private Attributes
static const G4int	max_depth = 10

Detailed Description

Definition at line 47 of file G4MultiLevelLocator.hh.

Constructor & Destructor Documentation

G4MultiLevelLocator()

G4MultiLevelLocator::G4MultiLevelLocator

(

G4Navigator *

theNavigator

)

Definition at line 39 of file G4MultiLevelLocator.cc.

  : G4VIntersectionLocator(theNavigator)
{
  // In case of too slow progress in finding Intersection Point
  // intermediates Points on the Track must be stored.
  // Initialise the array of Pointers [max_depth+1] to do this  
  
  G4ThreeVector zeroV(0.0,0.0,0.0);
  for ( auto idepth=0; idepth<max_depth+1; ++idepth )
  {
    ptrInterMedFT[ idepth ] = new G4FieldTrack( zeroV, zeroV, 0., 0., 0., 0.);
  }
 
  if (fCheckMode)
  {
    //  Trial values       Loose         Medium      Tight
    //  To happen:         Infrequent    Occasional  Often
    SetMaxSteps(150);   //  300             85          25
    SetWarnSteps(80);   //  250             60          15
  }  
}      

References G4VIntersectionLocator::fCheckMode, max_depth, ptrInterMedFT, SetMaxSteps(), and SetWarnSteps().

~G4MultiLevelLocator()

G4MultiLevelLocator::~G4MultiLevelLocator

(

)

Definition at line 61 of file G4MultiLevelLocator.cc.

{
  for ( auto idepth=0; idepth<max_depth+1; ++idepth )
  {
    delete ptrInterMedFT[idepth];
  }
#ifdef G4DEBUG_FIELD
  ReportStatistics(); 
#endif  
}

References max_depth, ptrInterMedFT, and ReportStatistics().

Member Function Documentation

AddAdjustementOfFoundIntersection()

void G4VIntersectionLocator::AddAdjustementOfFoundIntersection ( G4bool  UseCorrection )

inlineinherited

AdjustIntersections()

void G4VIntersectionLocator::AdjustIntersections ( G4bool  UseCorrection )

inlineinherited

AdjustmentOfFoundIntersection()

G4bool G4VIntersectionLocator::AdjustmentOfFoundIntersection ( const G4ThreeVector &  A, const G4ThreeVector &  CurrentE_Point, const G4ThreeVector &  CurrentF_Point, const G4ThreeVector &  MomentumDir, const G4bool  IntersectAF, G4ThreeVector &  IntersectionPoint, G4double &  NewSafety, G4double &  fPrevSafety, G4ThreeVector &  fPrevSftOrigin  )

protectedinherited

Definition at line 439 of file G4VIntersectionLocator.cc.

{     
  G4double dist,lambda;
  G4ThreeVector Normal, NewPoint, Point_G;
  G4bool goodAdjust = false, Intersects_FP = false, validNormal = false;
 
  // Get SurfaceNormal of Intersecting Solid
  //
  Normal = GetGlobalSurfaceNormal(CurrentE_Point,validNormal);
  if(!validNormal) { return false; }
 
  // Intersection between Line and Plane
  //
  G4double n_d_m = Normal.dot(MomentumDir);
  if ( std::abs(n_d_m)>kCarTolerance )
  {
#ifdef G4VERBOSE
    if ( fVerboseLevel>1 )
    {
      G4Exception("G4VIntersectionLocator::AdjustmentOfFoundIntersection()",
                  "GeomNav0003", JustWarning,
                  "No intersection. Parallels lines!");
    }
#endif
    lambda =- Normal.dot(CurrentF_Point-CurrentE_Point)/n_d_m;
 
    // New candidate for Intersection
    //
    NewPoint = CurrentF_Point+lambda*MomentumDir;
 
    // Distance from CurrentF to Calculated Intersection
    //
    dist = std::abs(lambda);
 
    if ( dist<kCarTolerance*0.001 )  { return false; }
 
    // Calculation of new intersection point on the path.
    //
    if ( IntersectAF )  //  First part intersects
    {
      G4double stepLengthFP; 
      G4ThreeVector Point_P = CurrentA_Point;
      GetNavigatorFor()->LocateGlobalPointWithinVolume(Point_P);
      Intersects_FP = IntersectChord( Point_P, NewPoint, NewSafety,
                                      fPreviousSafety, fPreviousSftOrigin,
                                      stepLengthFP, Point_G );
 
    }
    else   // Second part intersects
    {      
      G4double stepLengthFP; 
      GetNavigatorFor()->LocateGlobalPointWithinVolume(CurrentF_Point );
      Intersects_FP = IntersectChord( CurrentF_Point, NewPoint, NewSafety,
                                      fPreviousSafety, fPreviousSftOrigin,
                                      stepLengthFP, Point_G );
    }
    if ( Intersects_FP )
    {
      goodAdjust = true;
      IntersectionPoint = Point_G;              
    }
  }
 
  return goodAdjust;
}

References CLHEP::Hep3Vector::dot(), fPreviousSafety, fPreviousSftOrigin, G4VIntersectionLocator::fVerboseLevel, G4Exception(), G4VIntersectionLocator::GetGlobalSurfaceNormal(), G4VIntersectionLocator::GetNavigatorFor(), G4VIntersectionLocator::IntersectChord(), JustWarning, G4VIntersectionLocator::kCarTolerance, G4InuclParticleNames::lambda, and G4Navigator::LocateGlobalPointWithinVolume().

Referenced by G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), and G4SimpleLocator::EstimateIntersectionPoint().

AreIntersectionsAdjusted()

G4bool G4VIntersectionLocator::AreIntersectionsAdjusted ( )

inlineinherited

Definition at line 118 of file G4VIntersectionLocator.hh.

{ return fUseNormalCorrection; }  

References G4VIntersectionLocator::fUseNormalCorrection.

CheckAndReEstimateEndpoint()

G4bool G4VIntersectionLocator::CheckAndReEstimateEndpoint ( const G4FieldTrack &  CurrentStartA, const G4FieldTrack &  EstimatedEndB, G4FieldTrack &  RevisedEndPoint, G4int &  errorCode  )

protectedinherited

Definition at line 329 of file G4VIntersectionLocator.cc.

{
  G4double linDistSq, curveDist; 
 
  G4bool recalculated = false;
  curveError= 0;
 
  linDistSq = ( EstimatedEndB.GetPosition() 
              - CurrentStartA.GetPosition() ).mag2(); 
  curveDist = EstimatedEndB.GetCurveLength()
            - CurrentStartA.GetCurveLength();
  if(  (curveDist>=0.0) 
     && (curveDist*curveDist *(1.0+2.0*fiEpsilonStep ) < linDistSq ) )
  {
    G4FieldTrack newEndPointFT = EstimatedEndB;  // Unused
 
    if (curveDist>0.0) 
    {
       // Re-integrate to obtain a new B
       RevisedEndPoint = ReEstimateEndpoint( CurrentStartA,
                                             EstimatedEndB,
                                             linDistSq,    
                                             curveDist );
       recalculated = true;
    }
    else
    {
       // Zero length -> no advance!
       newEndPointFT = CurrentStartA;
       recalculated = true;
       curveError = 1;  // Unexpected co-incidence - milder mixup
 
       G4Exception("G4MultiLevelLocator::EstimateIntersectionPoint()",
           "GeomNav1002", JustWarning, 
           "A & B are at equal distance in 2nd half. A & B will coincide." );
    }
  }
 
  // Sanity check
  //
  if( curveDist < 0.0 )
  {
    curveError = 2;  //  Real mixup
  }
  return recalculated;
}

References G4VIntersectionLocator::fiEpsilonStep, G4Exception(), G4FieldTrack::GetCurveLength(), G4FieldTrack::GetPosition(), JustWarning, and G4VIntersectionLocator::ReEstimateEndpoint().

Referenced by EstimateIntersectionPoint().

EstimateIntersectionPoint()

G4bool G4MultiLevelLocator::EstimateIntersectionPoint ( const G4FieldTrack &  curveStartPointTangent, const G4FieldTrack &  curveEndPointTangent, const G4ThreeVector &  trialPoint, G4FieldTrack &  intersectPointTangent, G4bool &  recalculatedEndPoint, G4double &  fPreviousSafety, G4ThreeVector &  fPreviousSftOrigin  )

virtual

Implements G4VIntersectionLocator.

Definition at line 115 of file G4MultiLevelLocator.cc.

{
  // Find Intersection Point ( A, B, E )  of true path AB - start at E.
  const char* MethodName= "G4MultiLevelLocator::EstimateIntersectionPoint()";
  
  G4bool found_approximate_intersection = false;
  G4bool there_is_no_intersection       = false;
 
  G4FieldTrack  CurrentA_PointVelocity = CurveStartPointVelocity; 
  G4FieldTrack  CurrentB_PointVelocity = CurveEndPointVelocity;
  G4ThreeVector CurrentE_Point = TrialPoint;
  G4bool        validNormalAtE = false;
  G4ThreeVector NormalAtEntry;
 
  G4FieldTrack  ApproxIntersecPointV(CurveEndPointVelocity); // FT-Def-Construct
  G4bool        validIntersectP= true;   // Is it current ?
  G4double      NewSafety = 0.0;
  G4bool        last_AF_intersection = false;   
 
  auto    integrDriver = GetChordFinderFor()->GetIntegrationDriver();
  G4bool  driverReIntegrates = integrDriver->DoesReIntegrate();
  
  G4bool first_section = true;
  recalculatedEndPoint = false; 
  G4bool restoredFullEndpoint = false;
 
  unsigned int substep_no = 0;
 
  // Statistics for substeps
  static G4ThreadLocal unsigned int max_no_seen= 0;
 
#ifdef G4DEBUG_FIELD
  unsigned int trigger_substepno_print = 0;
  const G4double tolerance = 1.0e-8 * CLHEP::mm;
  unsigned int biggest_depth = 0;
    // using kInitialisingCL = G4LocatorChangeRecord::kInitialisingCL;
#endif
 
  // Log the location, iteration of changes in A,B 
  //----------------------------------------------
  static G4ThreadLocal G4LocatorChangeLogger endChangeA("StartPointA"),
    endChangeB("EndPointB"), recApproxPoint("ApproxPoint"),
    pointH_logger("Trial points 'E': position, normal");
  unsigned int eventCount = 0;
 
  if (fCheckMode)
  {
    // Clear previous call's data
    endChangeA.clear();
    endChangeB.clear();
    recApproxPoint.clear();
    pointH_logger.clear();
 
    // Record the initialisation
    ++eventCount;
    endChangeA.AddRecord( G4LocatorChangeRecord::kInitialisingCL, substep_no,
                          eventCount, CurrentA_PointVelocity );
    endChangeB.AddRecord( G4LocatorChangeRecord::kInitialisingCL, substep_no,
                          eventCount, CurrentB_PointVelocity );
  }
 
  //--------------------------------------------------------------------------  
  //  Algorithm for the case if progress in founding intersection is too slow.
  //  Process is defined too slow if after N=param_substeps advances on the
  //  path, it will be only 'fraction_done' of the total length.
  //  In this case the remaining length is divided in two half and 
  //  the loop is restarted for each half.  
  //  If progress is still too slow, the division in two halfs continue
  //  until 'max_depth'.
  //--------------------------------------------------------------------------
 
  const G4int param_substeps = 5;  // Test value for the maximum number
                                   // of substeps
  const G4double fraction_done = 0.3;
 
  G4bool Second_half = false;    // First half or second half of divided step
 
  // We need to know this for the 'final_section':
  // real 'final_section' or first half 'final_section'
  // In algorithm it is considered that the 'Second_half' is true
  // and it becomes false only if we are in the first-half of level
  // depthness or if we are in the first section
 
  unsigned int depth = 0; // Depth counts subdivisions of initial step made
  ++fNumCalls;
  
  NormalAtEntry = GetSurfaceNormal(CurrentE_Point, validNormalAtE);
 
  if (fCheckMode)
  {
    pointH_logger.AddRecord( G4LocatorChangeRecord::kInitialisingCL,
                             substep_no, eventCount,
                             G4FieldTrack( CurrentE_Point,0.,NormalAtEntry,0.,
                                           0., 1.,G4ThreeVector(0.),0.,0.) );
  #if (G4DEBUG_FIELD>1) 
    G4ThreeVector  StartPosition = CurveStartPointVelocity.GetPosition(); 
    if( (TrialPoint - StartPosition).mag2() < sqr(tolerance)) 
    {
       ReportImmediateHit( MethodName, StartPosition, TrialPoint,
                           tolerance, fNumCalls); 
    }
  #endif
  }
 
  // Intermediates Points on the Track = Subdivided Points must be stored.
  // Give the initial values to 'InterMedFt'
  // Important is 'ptrInterMedFT[0]', it saves the 'EndCurvePoint'
  //
  *ptrInterMedFT[0] = CurveEndPointVelocity;
  for ( auto idepth=1; idepth<max_depth+1; ++idepth )
  {
    *ptrInterMedFT[idepth] = CurveStartPointVelocity;
  }
 
  // Final_section boolean store
  //
  G4bool fin_section_depth[max_depth];
  for ( auto idepth=0; idepth<max_depth; ++idepth )
  {
    fin_section_depth[idepth] = true;
  }
  // 'SubStartPoint' is needed to calculate the length of the divided step
  //
  G4FieldTrack SubStart_PointVelocity = CurveStartPointVelocity;
   
  do  // Loop checking, 07.10.2016, J.Apostolakis
  {
    unsigned int substep_no_p = 0;
    G4bool sub_final_section = false; // the same as final_section,
                                      // but for 'sub_section'
    SubStart_PointVelocity = CurrentA_PointVelocity;
 
    do // Loop checking, 07.10.2016, J.Apostolakis
    { // REPEAT param
 
#ifdef G4DEBUG_FIELD       
      if( CurrentA_PointVelocity.GetCurveLength() >=
          CurrentB_PointVelocity.GetCurveLength() )
      {
        G4cerr << "ERROR> (Start) Point A coincides with or has gone past (end) point B"           
               << "MLL: iters = " << substep_no << G4endl;
     // G4LocatorChangeRecord::ReportVector(G4cerr, "endPointB", endChangeB );
     // G4cerr<<"EndPoints A(start) and B(end): combined changes " << G4endl;
        G4LocatorChangeLogger::ReportEndChanges(G4cerr, endChangeA, endChangeB);
      }
#endif    
      G4ThreeVector Point_A = CurrentA_PointVelocity.GetPosition();  
      G4ThreeVector Point_B = CurrentB_PointVelocity.GetPosition();
 
      // F = a point on true AB path close to point E 
      // (the closest if possible)
      //
      ApproxIntersecPointV = GetChordFinderFor()
                             ->ApproxCurvePointV( CurrentA_PointVelocity, 
                                                  CurrentB_PointVelocity, 
                                                  CurrentE_Point,
                                                  GetEpsilonStepFor() );
        // The above method is the key & most intuitive part ...
 
#ifdef G4DEBUG_FIELD      
      recApproxPoint.push_back(G4LocatorChangeRecord(G4LocatorChangeRecord::kInvalidCL,
                                                  substep_no, eventCount, ApproxIntersecPointV ) );
      G4double lenIntsc= ApproxIntersecPointV.GetCurveLength();
      G4double lenB    = CurrentB_PointVelocity.GetCurveLength();
      G4double checkVsEnd= lenB - lenIntsc;
 
      if( lenIntsc > lenB ) 
      {
         std::ostringstream errmsg;
         errmsg.precision(17);
         G4double ratio    = checkVsEnd / lenB;         
         G4double ratioTol = std::fabs(ratio) / tolerance;
         errmsg << "Intermediate F point is past end B point" << G4endl
                << "   l( intersection ) = " << lenIntsc << G4endl
                << "   l( endpoint     ) = " << lenB     << G4endl;
         errmsg.precision(8);
         errmsg << "   l_end - l_inters  = " << checkVsEnd << G4endl
                << "          / l_end      = " << ratio << G4endl
                << "   ratio  / tolerance  = " << ratioTol  << G4endl;
         if( ratioTol < 1.0 ) 
            G4Exception(MethodName, "GeomNav0003", JustWarning, errmsg );
         else
            G4Exception(MethodName, "GeomNav0003", FatalException, errmsg );
      }
#endif
 
      G4ThreeVector CurrentF_Point= ApproxIntersecPointV.GetPosition();
 
      // First check whether EF is small - then F is a good approx. point 
      // Calculate the length and direction of the chord AF
      //
      G4ThreeVector  ChordEF_Vector = CurrentF_Point - CurrentE_Point;
 
      G4ThreeVector  NewMomentumDir = ApproxIntersecPointV.GetMomentumDir(); 
      G4double       MomDir_dot_Norm = NewMomentumDir.dot( NormalAtEntry );
 
#ifdef G4DEBUG_FIELD
      if( fVerboseLevel > 3 )
      { 
         G4ThreeVector  ChordAB           = Point_B - Point_A;
         G4double       ABchord_length    = ChordAB.mag(); 
         G4double       MomDir_dot_ABchord;
         MomDir_dot_ABchord = (1.0 / ABchord_length)
                            * NewMomentumDir.dot( ChordAB );
         G4VIntersectionLocator::ReportTrialStep( substep_no, ChordAB,
              ChordEF_Vector, NewMomentumDir, NormalAtEntry, validNormalAtE ); 
         G4cout << " dot( MomentumDir, ABchord_unit ) = "
                << MomDir_dot_ABchord << G4endl;
      }
#endif
      G4bool adequate_angle =
             ( MomDir_dot_Norm >= 0.0 ) // Can use ( > -epsilon) instead
          || (! validNormalAtE );       // Invalid, cannot use this criterion
      G4double EF_dist2 = ChordEF_Vector.mag2();
      if ( ( EF_dist2 <= sqr(fiDeltaIntersection) && ( adequate_angle ) )
        || ( EF_dist2 <= kCarTolerance*kCarTolerance ) )
      { 
        found_approximate_intersection = true;
 
        // Create the "point" return value
        //
        IntersectedOrRecalculatedFT = ApproxIntersecPointV;
        IntersectedOrRecalculatedFT.SetPosition( CurrentE_Point );
 
        if ( GetAdjustementOfFoundIntersection() )
        {
          // Try to Get Correction of IntersectionPoint using SurfaceNormal()
          //  
          G4ThreeVector IP;
          G4ThreeVector MomentumDir=ApproxIntersecPointV.GetMomentumDirection();
          G4bool goodCorrection = AdjustmentOfFoundIntersection(Point_A,
                                    CurrentE_Point, CurrentF_Point, MomentumDir,
                                    last_AF_intersection, IP, NewSafety,
                                    previousSafety, previousSftOrigin );
          if ( goodCorrection )
          {
            IntersectedOrRecalculatedFT = ApproxIntersecPointV;
            IntersectedOrRecalculatedFT.SetPosition(IP);
          }
        }
        // Note: in order to return a point on the boundary, 
        //       we must return E. But it is F on the curve.
        //       So we must "cheat": we are using the position at point E
        //       and the velocity at point F !!!
        //
        // This must limit the length we can allow for displacement!
      }
      else  // E is NOT close enough to the curve (ie point F)
      {
        // Check whether any volumes are encountered by the chord AF
        // ---------------------------------------------------------
        // First relocate to restore any Voxel etc information
        // in the Navigator before calling ComputeStep()
        //
        GetNavigatorFor()->LocateGlobalPointWithinVolume( Point_A );
 
        G4ThreeVector PointG;   // Candidate intersection point
        G4double stepLengthAF; 
        G4bool Intersects_FB = false;
        G4bool Intersects_AF = IntersectChord( Point_A,   CurrentF_Point,
                                               NewSafety, previousSafety,
                                               previousSftOrigin,
                                               stepLengthAF,
                                               PointG );
        last_AF_intersection = Intersects_AF;
        if( Intersects_AF )
        {
          // G is our new Candidate for the intersection point.
          // It replaces  "E" and we will see if it's good enough.
          CurrentB_PointVelocity = ApproxIntersecPointV;  // B  <- F
          CurrentE_Point = PointG;                        // E  <- G
 
          validIntersectP = true;    // 'E' has been updated.
 
          G4bool validNormalLast; 
          NormalAtEntry  = GetSurfaceNormal( PointG, validNormalLast ); 
          validNormalAtE = validNormalLast; 
 
          // As we move point B, must take care in case the current
          // AF has no intersection to try current FB!!
          fin_section_depth[depth] = false;
 
          if (fCheckMode)
          {
            ++eventCount;
            endChangeB.push_back(
              G4LocatorChangeRecord(G4LocatorChangeRecord::kIntersectsAF,
                             substep_no, eventCount, CurrentB_PointVelocity) );
          }
#ifdef G4VERBOSE
          if( fVerboseLevel > 3 )
          {
            G4cout << "G4PiF::LI> Investigating intermediate point"
                   << " at s=" << ApproxIntersecPointV.GetCurveLength()
                   << " on way to full s="
                   << CurveEndPointVelocity.GetCurveLength() << G4endl;
          }
#endif
        }
        else  // not Intersects_AF
        {  
          // In this case:
          // There is NO intersection of AF with a volume boundary.
          // We must continue the search in the segment FB!
          //
          GetNavigatorFor()->LocateGlobalPointWithinVolume( CurrentF_Point );
 
          G4double stepLengthFB;
          G4ThreeVector PointH;
 
          // Check whether any volumes are encountered by the chord FB
          // ---------------------------------------------------------
 
          Intersects_FB = IntersectChord( CurrentF_Point, Point_B, 
                                          NewSafety, previousSafety,
                                          previousSftOrigin,
                                          stepLengthFB,
                                          PointH );
          if( Intersects_FB )
          {
            // There is an intersection of FB with a volume boundary
            // H <- First Intersection of Chord FB 
 
            // H is our new Candidate for the intersection point.
            // It replaces  "E" and we will repeat the test to see if
            // it is a good enough approximate point for us.
 
            // Note that F must be in volume volA  (the same as A)
            // (otherwise AF would meet a volume boundary!)
            //   A    <- F 
            //   E    <- H
            //
            CurrentA_PointVelocity = ApproxIntersecPointV;
            CurrentE_Point = PointH;
 
            validIntersectP = true;    // 'E' has been updated.
 
            G4bool validNormalH;
            NormalAtEntry  = GetSurfaceNormal( PointH, validNormalH ); 
            validNormalAtE = validNormalH;
 
            if (fCheckMode)
            {
              ++eventCount;
              endChangeA.push_back( 
                 G4LocatorChangeRecord(G4LocatorChangeRecord::kIntersectsFB,
                             substep_no, eventCount, CurrentA_PointVelocity) );
              G4FieldTrack intersectH_pn('0');  // Point and normal
                                                // nothing else will be valid
              intersectH_pn.SetPosition( PointH );
              intersectH_pn.SetMomentum( NormalAtEntry ); 
              pointH_logger.AddRecord(G4LocatorChangeRecord::kIntersectsFB,
                                    substep_no, eventCount, intersectH_pn );
            }
          }
          else  // not Intersects_FB
          {
            if( fin_section_depth[depth] )
            {
              // If B is the original endpoint, this means that whatever
              // volume(s) intersected the original chord, none touch the
              // smaller chords we have used.
              // The value of 'IntersectedOrRecalculatedFT' returned is
              // likely not valid 
 
              // Check on real final_section or SubEndSection
              //
              if( ((Second_half)&&(depth==0)) || (first_section) )
              {
                there_is_no_intersection = true;   // real final_section
              }
              else
              {
                // end of subsection, not real final section 
                // exit from the and go to the depth-1 level 
                substep_no_p = param_substeps+2;  // exit from the loop
 
                // but 'Second_half' is still true because we need to find
                // the 'CurrentE_point' for the next loop
                Second_half = true; 
                sub_final_section = true;
              }
            }
            else
            {
              CurrentA_PointVelocity = CurrentB_PointVelocity;  // Got to B
              CurrentB_PointVelocity = (depth==0) ? CurveEndPointVelocity 
                                                  : *ptrInterMedFT[depth] ;
              SubStart_PointVelocity = CurrentA_PointVelocity;
              restoredFullEndpoint = true;
 
              validIntersectP = false;  // 'E' has NOT been updated.
 
              if (fCheckMode)
              {
                ++eventCount;
                endChangeA.push_back(
                  G4LocatorChangeRecord(
                    G4LocatorChangeRecord::kNoIntersectAForFB,
                             substep_no, eventCount, CurrentA_PointVelocity) ); 
                endChangeB.push_back(
                  G4LocatorChangeRecord (
                    G4LocatorChangeRecord::kNoIntersectAForFB,
                             substep_no, eventCount, CurrentB_PointVelocity) );
              }
            }
          } // Endif (Intersects_FB)
        } // Endif (Intersects_AF)
 
        G4int errorEndPt = 0; // Default: no error (if not calling CheckAnd...
 
        G4bool recalculatedB= false;
        if( driverReIntegrates )
        {
          G4FieldTrack RevisedB_FT = CurrentB_PointVelocity;
          recalculatedB= CheckAndReEstimateEndpoint(CurrentA_PointVelocity,
                                                    CurrentB_PointVelocity,
                                                    RevisedB_FT,
                                                    errorEndPt );
          if( recalculatedB )
          {
            CurrentB_PointVelocity = RevisedB_FT;  // Use it !
            // Do not invalidate intersection F -- it is still roughly OK.
            //
            // The best course would be to invalidate (reset validIntersectP)
            // BUT if we invalidate it, we must re-estimate it somewhere! E.g.
            //   validIntersectP = false;  // 'E' has NOT been updated.
 
            if ( (fin_section_depth[depth])           // real final section
               &&( first_section || ((Second_half)&&(depth==0)) ) )
            {
              recalculatedEndPoint = true;
              IntersectedOrRecalculatedFT = RevisedB_FT;
              // So that we can return it, if it is the endpoint!
            }
            // else
            //  Move forward the other points 
            //   - or better flag it, so that they are re-computed when next used
            //     [ Implementation: a counter for # of recomputations
            //       => avoids extra work]
          }
          // else
          //  Move forward the other points 
          //   - or better flag it, so that they are re-computed when next used
          //     [ Implementation: a counter for # of recomputations
          //       => avoids extra work]
          if (fCheckMode)
          {
            ++eventCount;
            endChangeB.push_back(
              G4LocatorChangeRecord( G4LocatorChangeRecord::kRecalculatedB,
                                     substep_no, eventCount, RevisedB_FT ) );
          }
        }
        else
        {
          if( CurrentB_PointVelocity.GetCurveLength() < CurrentA_PointVelocity.GetCurveLength() )
            errorEndPt = 2;
        }
        
        if( errorEndPt > 1 )  // errorEndPt = 1 is milder, just: len(B)=len(A)
        {
           std::ostringstream errmsg; 
           ReportReversedPoints(errmsg, 
                     CurveStartPointVelocity, CurveEndPointVelocity,
                     NewSafety, fiEpsilonStep, 
                     CurrentA_PointVelocity, CurrentB_PointVelocity,
                     SubStart_PointVelocity, CurrentE_Point,
                     ApproxIntersecPointV, substep_no, substep_no_p, depth);
           errmsg << G4endl << " * Location: " << MethodName
                  << "- After EndIf(Intersects_AF)" << G4endl;
           errmsg << " * Bool flags:  Recalculated = " << recalculatedB
                  << "   Intersects_AF = " << Intersects_AF
                  << "   Intersects_FB = " << Intersects_FB << G4endl;
           errmsg << " * Number of calls to MLL:EIP= " << fNumCalls << G4endl;
           G4Exception(MethodName, "GeomNav0003", FatalException, errmsg); 
        }
        if( restoredFullEndpoint )
        {
          fin_section_depth[depth] = restoredFullEndpoint;
          restoredFullEndpoint = false;
        }
      } // EndIf ( E is close enough to the curve, ie point F. )
        // tests ChordAF_Vector.mag() <= maximum_lateral_displacement 
 
#ifdef G4DEBUG_FIELD
      if( trigger_substepno_print == 0)
      {
        trigger_substepno_print= fWarnSteps - 20;
      }
 
      if( substep_no >= trigger_substepno_print )
      {
        G4cout << "Difficulty in converging in " << MethodName
               << "    Substep no = " << substep_no << G4endl;
        if( substep_no == trigger_substepno_print )
        {
          G4cout << " Start:   ";
          printStatus( CurveStartPointVelocity, CurveEndPointVelocity,
                       -1.0, NewSafety, 0 );
 
          G4cout << " ** Change records: " << G4endl;
          G4cout <<  "endPoints  A (start) and B (end): combined changes of AB intervals" << G4endl;          
          G4LocatorChangeRecord::ReportEndChanges(G4cout, endChangeA, endChangeB );
        }
        G4cout << " Point A: "; 
        printStatus( CurrentA_PointVelocity, CurrentA_PointVelocity,
                     -1.0, NewSafety, substep_no-1 );
        G4cout << " Point B: ";
        printStatus( CurrentA_PointVelocity, CurrentB_PointVelocity,
                     -1.0, NewSafety, substep_no );
      }
#endif
      ++substep_no; 
      ++substep_no_p;
 
    } while (  ( ! found_approximate_intersection )
            && ( ! there_is_no_intersection )     
            && ( substep_no_p <= param_substeps) );  // UNTIL found or
                                                     // failed param substep
 
    if( (!found_approximate_intersection) && (!there_is_no_intersection) )
    {
      G4double did_len = std::abs( CurrentA_PointVelocity.GetCurveLength()
                       - SubStart_PointVelocity.GetCurveLength()); 
      G4double all_len = std::abs( CurrentB_PointVelocity.GetCurveLength()
                       - SubStart_PointVelocity.GetCurveLength());
   
      G4double distAB = -1;
      //
      // Is progress is too slow, and is it possible to go deeper?
      // If so, then *halve the step*
      //              ==============
      if(   (did_len < fraction_done*all_len)
         && (depth<max_depth) && (!sub_final_section) )
      {
#ifdef G4DEBUG_FIELD         
        static G4ThreadLocal unsigned int numSplits=0;   // For debugging only 
        biggest_depth = std::max(depth, biggest_depth);
        ++numSplits;
#endif
        Second_half = false;
        ++depth;
        first_section = false;
 
        G4double Sub_len = (all_len-did_len)/(2.);
        G4FieldTrack midPoint = CurrentA_PointVelocity;
        G4bool fullAdvance=              
           integrDriver->AccurateAdvance(midPoint, Sub_len, fiEpsilonStep);
                         
        ++fNumAdvanceTrials;
        if( fullAdvance )  { ++fNumAdvanceFull; }
 
        G4double lenAchieved=
           midPoint.GetCurveLength()-CurrentA_PointVelocity.GetCurveLength();
        
        const G4double adequateFraction = (1.0-CLHEP::perThousand);
        G4bool goodAdvance = (lenAchieved >= adequateFraction * Sub_len);
        if ( goodAdvance )  { ++fNumAdvanceGood; }
 
#ifdef G4DEBUG_FIELD
        else  //  !goodAdvance
        {
           G4cout << "MLL> AdvanceChordLimited not full at depth=" << depth 
                  << "  total length achieved = " << lenAchieved << " of "
                  << Sub_len << "  fraction= ";
           if (Sub_len != 0.0 ) { G4cout << lenAchieved / Sub_len; }
           else                 { G4cout << "DivByZero"; }
           G4cout << "  Good-enough fraction = " << adequateFraction;
           G4cout << "  Number of call to mll = " << fNumCalls
                  << "   iteration " << substep_no
                  << "  inner =  " << substep_no_p << G4endl;
           G4cout << "  Epsilon of integration = " << fiEpsilonStep << G4endl;
           G4cout << "  State at start is      = " << CurrentA_PointVelocity
                  << G4endl
                  << "        at end (midpoint)= " << midPoint << G4endl;
           G4cout << "  Particle mass = " << midPoint.GetRestMass() << G4endl;
 
           G4EquationOfMotion *equation = integrDriver->GetEquationOfMotion();
           ReportFieldValue( CurrentA_PointVelocity, "start", equation );
           ReportFieldValue( midPoint, "midPoint", equation );            
           G4cout << "  Original Start = "
                  << CurveStartPointVelocity << G4endl;
           G4cout << "  Original   End = "
                  << CurveEndPointVelocity << G4endl;
           G4cout << "  Original TrialPoint = "
                  << TrialPoint << G4endl;
           G4cout << "  (this is STRICT mode) "
                  << "  num Splits= " << numSplits;           
           G4cout << G4endl;
        }
#endif
 
        *ptrInterMedFT[depth] =  midPoint;
        CurrentB_PointVelocity = midPoint; 
 
        if (fCheckMode)
        {
          ++eventCount;
          endChangeB.push_back(
            G4LocatorChangeRecord( G4LocatorChangeRecord::kInsertingMidPoint,
                                   substep_no, eventCount, midPoint) );
        }        
        
        // Adjust 'SubStartPoint' to calculate the 'did_length' in next loop
        //
        SubStart_PointVelocity = CurrentA_PointVelocity;
 
        // Find new trial intersection point needed at start of the loop
        //
        G4ThreeVector Point_A = CurrentA_PointVelocity.GetPosition();
        G4ThreeVector Point_B = CurrentB_PointVelocity.GetPosition();   
 
        G4ThreeVector PointGe;
        GetNavigatorFor()->LocateGlobalPointWithinVolume(Point_A);
        G4bool Intersects_AB = IntersectChord(Point_A, Point_B,
                                              NewSafety, previousSafety,
                                              previousSftOrigin, distAB,
                                              PointGe);
        if( Intersects_AB )
        {
          last_AF_intersection = Intersects_AB;
          CurrentE_Point = PointGe;
          fin_section_depth[depth] = true;
 
          validIntersectP = true;  // 'E' has been updated.
 
          G4bool validNormalAB; 
          NormalAtEntry  = GetSurfaceNormal( PointGe, validNormalAB ); 
          validNormalAtE = validNormalAB;
        }
        else
        {
          // No intersection found for first part of curve
          // (CurrentA,InterMedPoint[depth]). Go to the second part
          //
          Second_half = true;
 
          validIntersectP=  false;  // No new 'E' chord intersection found
        }
      } // if did_len
 
      unsigned int levelPops = 0;
      
      G4bool unfinished = Second_half;
      while ( unfinished && (depth>0) )  // Loop checking, 07.10.2016, JA
      {
        // Second part of curve (InterMed[depth],Intermed[depth-1])) 
        // On the depth-1 level normally we are on the 'second_half'
 
        ++levelPops;
 
        //  Find new trial intersection point needed at start of the loop
        //
        SubStart_PointVelocity = *ptrInterMedFT[depth];
        CurrentA_PointVelocity = *ptrInterMedFT[depth];
        CurrentB_PointVelocity = *ptrInterMedFT[depth-1];
 
        if (fCheckMode)
        {
          ++eventCount;
          G4LocatorChangeRecord chngPop_a( G4LocatorChangeRecord::kLevelPop,
                              substep_no, eventCount, CurrentA_PointVelocity);
          endChangeA.push_back( chngPop_a );
          G4LocatorChangeRecord chngPop_b( G4LocatorChangeRecord::kLevelPop,
                              substep_no, eventCount, CurrentB_PointVelocity);
          endChangeB.push_back( chngPop_b );
        }
        
        // Ensure that the new endpoints are not further apart in space
        // than on the curve due to different errors in the integration
        //
        G4int  errorEndPt = -1;
        G4bool recalculatedB= false;
        if( driverReIntegrates )
        {
          // Ensure that the new endpoints are not further apart in space
          // than on the curve due to different errors in the integration
          //
          G4FieldTrack RevisedEndPointFT = CurrentB_PointVelocity;
          recalculatedB = 
             CheckAndReEstimateEndpoint( CurrentA_PointVelocity,  
                                         CurrentB_PointVelocity,
                                         RevisedEndPointFT,
                                         errorEndPt );
          if( recalculatedB )
          {
            CurrentB_PointVelocity = RevisedEndPointFT;  // Use it !
            
            if ( depth == 1 )
            {
               recalculatedEndPoint = true;
               IntersectedOrRecalculatedFT = RevisedEndPointFT;
               // So that we can return it, if it is the endpoint!
            }
          }
          else
          {          
            if( CurrentB_PointVelocity.GetCurveLength() < CurrentA_PointVelocity.GetCurveLength() )
              errorEndPt = 2;
          }
          
          if (fCheckMode)
          {
            ++eventCount;
            endChangeB.push_back(
              G4LocatorChangeRecord(G4LocatorChangeRecord::kRecalculatedBagn,
                                    substep_no, eventCount, RevisedEndPointFT));
          }
        }
        if( errorEndPt > 1 )  // errorEndPt = 1 is milder, just: len(B)=len(A)
        {
          std::ostringstream errmsg; 
          ReportReversedPoints(errmsg, 
                    CurveStartPointVelocity, CurveEndPointVelocity,
                    NewSafety, fiEpsilonStep, 
                    CurrentA_PointVelocity, CurrentB_PointVelocity,
                    SubStart_PointVelocity, CurrentE_Point,
                    ApproxIntersecPointV, substep_no, substep_no_p, depth);
          errmsg << " * Location:  " << MethodName << "- Second-Half" << G4endl;
          errmsg << " * Recalculated = " << recalculatedB << G4endl; // false
          G4Exception(MethodName, "GeomNav0003", FatalException, errmsg);
        }
        
        G4ThreeVector Point_A = CurrentA_PointVelocity.GetPosition();
        G4ThreeVector Point_B = CurrentB_PointVelocity.GetPosition();
        G4ThreeVector PointGi;     
        GetNavigatorFor()->LocateGlobalPointWithinVolume(Point_A);
        G4bool Intersects_AB = IntersectChord(Point_A, Point_B, NewSafety,
                                              previousSafety,
                                              previousSftOrigin, distAB,
                                              PointGi);
        if( Intersects_AB )
        {
          last_AF_intersection = Intersects_AB;
          CurrentE_Point = PointGi;
 
          validIntersectP = true;  // 'E' has been updated.
          NormalAtEntry  = GetSurfaceNormal( PointGi, validNormalAtE ); 
        }
        else
        {
          validIntersectP = false;  // No new 'E' chord intersection found
          if( depth == 1)
          {
            there_is_no_intersection = true;
          }
        }
        depth--;
        fin_section_depth[depth] = true;
        unfinished = !validIntersectP;
      }
#ifdef G4DEBUG_FIELD
      if( ! ( validIntersectP || there_is_no_intersection ) )
      {
         // What happened ??
         G4cout << "MLL - WARNING Potential FAILURE: Conditions not met!"
                << G4endl
                << " Depth = " << depth << G4endl
                << " Levels popped = " << levelPops
                << " Num Substeps= " << substep_no << G4endl;
         G4cout << " Found intersection= " << found_approximate_intersection
                << G4endl;
         G4cout << " Progress report: -- " << G4endl;
         ReportProgress(G4cout, 
                        CurveStartPointVelocity, CurveEndPointVelocity,
                        substep_no, CurrentA_PointVelocity,
                        CurrentB_PointVelocity,
                        NewSafety, depth ); 
         G4cout << G4endl; 
      }
#endif      
    }  // if(!found_aproximate_intersection)
 
    assert( validIntersectP || there_is_no_intersection
                            || found_approximate_intersection);
 
  } while ( ( ! found_approximate_intersection )
            && ( ! there_is_no_intersection )     
            && ( substep_no <= fMaxSteps) ); // UNTIL found or failed
 
  if( substep_no > max_no_seen )
  {
    max_no_seen = substep_no; 
#ifdef G4DEBUG_FIELD
    if( max_no_seen > fWarnSteps )
    {
      trigger_substepno_print = max_no_seen-20; // Want to see last 20 steps 
    } 
#endif
  }
 
  if( !there_is_no_intersection && !found_approximate_intersection )
  {
     if( substep_no >= fMaxSteps)
     {
        // Since we cannot go further (yet), we return as far as we have gone
 
        recalculatedEndPoint = true;
        IntersectedOrRecalculatedFT = CurrentA_PointVelocity;
        found_approximate_intersection = false; 
     
        std::ostringstream message;
        message << G4endl;
        message << "Convergence is requiring too many substeps: "
                << substep_no << "  ( limit = "<<  fMaxSteps << ")"
                << G4endl 
                << "  Abandoning effort to intersect. " << G4endl << G4endl;
        message << "    Number of calls to MLL: " <<   fNumCalls;
        message << "  iteration = " << substep_no <<G4endl << G4endl;
        
        message.precision( 12 ); 
        G4double done_len = CurrentA_PointVelocity.GetCurveLength(); 
        G4double full_len = CurveEndPointVelocity.GetCurveLength();
        message << "        Undertaken only length: " << done_len
                << " out of " << full_len << " required." << G4endl
                << "        Remaining length = " << full_len - done_len; 
        
        message << "     Start and end-point of requested Step:" << G4endl;
        printStatus( CurveStartPointVelocity, CurveEndPointVelocity,
                     -1.0, NewSafety, 0,     message, -1 );
        message << "        Start and end-point of current Sub-Step:" << G4endl;
        printStatus( CurrentA_PointVelocity, CurrentA_PointVelocity,
                     -1.0, NewSafety, substep_no-1, message, -1 );
        printStatus( CurrentA_PointVelocity, CurrentB_PointVelocity,
                     -1.0, NewSafety, substep_no, message, -1 );
        
        G4Exception(MethodName, "GeomNav0003", JustWarning, message);
     }
     else if( substep_no >= fWarnSteps)
     {  
        std::ostringstream message;
        message << "Many substeps while trying to locate intersection."
                << G4endl
                << "          Undertaken length: "  
                << CurrentB_PointVelocity.GetCurveLength()
                << " - Needed: "  << substep_no << " substeps." << G4endl
                << "          Warning number = " << fWarnSteps
                << " and maximum substeps = " << fMaxSteps;
        G4Exception(MethodName, "GeomNav1002", JustWarning, message);
     }
  }
  
  return  (!there_is_no_intersection) && found_approximate_intersection;
    //  Success or failure
}

References G4VIntersectionLocator::AdjustmentOfFoundIntersection(), G4ChordFinder::ApproxCurvePointV(), G4VIntersectionLocator::CheckAndReEstimateEndpoint(), G4VIntegrationDriver::DoesReIntegrate(), CLHEP::Hep3Vector::dot(), FatalException, G4VIntersectionLocator::fCheckMode, G4VIntersectionLocator::fiDeltaIntersection, G4VIntersectionLocator::fiEpsilonStep, fMaxSteps, fNumAdvanceFull, fNumAdvanceGood, fNumAdvanceTrials, fNumCalls, G4VIntersectionLocator::fVerboseLevel, fWarnSteps, G4cerr, G4cout, G4endl, G4Exception(), G4ThreadLocal, G4VIntersectionLocator::GetAdjustementOfFoundIntersection(), G4VIntersectionLocator::GetChordFinderFor(), G4FieldTrack::GetCurveLength(), G4VIntersectionLocator::GetEpsilonStepFor(), G4ChordFinder::GetIntegrationDriver(), G4FieldTrack::GetMomentumDir(), G4FieldTrack::GetMomentumDirection(), G4VIntersectionLocator::GetNavigatorFor(), G4FieldTrack::GetPosition(), G4FieldTrack::GetRestMass(), G4VIntersectionLocator::GetSurfaceNormal(), G4VIntersectionLocator::IntersectChord(), JustWarning, G4VIntersectionLocator::kCarTolerance, G4LocatorChangeRecord::kInitialisingCL, G4LocatorChangeRecord::kInsertingMidPoint, G4LocatorChangeRecord::kIntersectsAF, G4LocatorChangeRecord::kIntersectsFB, G4LocatorChangeRecord::kInvalidCL, G4LocatorChangeRecord::kLevelPop, G4LocatorChangeRecord::kNoIntersectAForFB, G4LocatorChangeRecord::kRecalculatedB, G4LocatorChangeRecord::kRecalculatedBagn, G4Navigator::LocateGlobalPointWithinVolume(), CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), G4INCL::Math::max(), max_depth, CLHEP::mm, CLHEP::perThousand, G4VIntersectionLocator::printStatus(), ptrInterMedFT, G4LocatorChangeLogger::ReportEndChanges(), G4LocatorChangeRecord::ReportEndChanges(), ReportFieldValue(), G4VIntersectionLocator::ReportImmediateHit(), G4VIntersectionLocator::ReportProgress(), G4VIntersectionLocator::ReportReversedPoints(), G4VIntersectionLocator::ReportTrialStep(), G4FieldTrack::SetMomentum(), G4FieldTrack::SetPosition(), and sqr().

GetAdjustementOfFoundIntersection()

G4bool G4VIntersectionLocator::GetAdjustementOfFoundIntersection ( )

inlineinherited

Referenced by G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), and G4SimpleLocator::EstimateIntersectionPoint().

GetCheckMode()

G4bool G4VIntersectionLocator::GetCheckMode ( )

inlineinherited

Definition at line 131 of file G4VIntersectionLocator.hh.

{ return fCheckMode; }

References G4VIntersectionLocator::fCheckMode.

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeCheckAndReport().

GetChordFinderFor()

G4ChordFinder * G4VIntersectionLocator::GetChordFinderFor ( )

inlineinherited

Referenced by G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), G4SimpleLocator::EstimateIntersectionPoint(), and G4VIntersectionLocator::ReEstimateEndpoint().

GetDeltaIntersectionFor()

G4double G4VIntersectionLocator::GetDeltaIntersectionFor ( )

inlineinherited

Referenced by G4BrentLocator::EstimateIntersectionPoint().

GetEpsilonStepFor()

G4double G4VIntersectionLocator::GetEpsilonStepFor ( )

inlineinherited

Referenced by G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), G4SimpleLocator::EstimateIntersectionPoint(), and G4VIntersectionLocator::ReEstimateEndpoint().

GetGlobalSurfaceNormal()

G4ThreeVector G4VIntersectionLocator::GetGlobalSurfaceNormal ( const G4ThreeVector &  CurrentE_Point, G4bool &  validNormal  )

protectedinherited

Definition at line 563 of file G4VIntersectionLocator.cc.

{
  G4ThreeVector localNormal = GetLocalSurfaceNormal(CurrentE_Point,validNormal);
  G4AffineTransform localToGlobal =          //  Must use the same Navigator !!
      fHelpingNavigator->GetLocalToGlobalTransform();
  G4ThreeVector globalNormal = localToGlobal.TransformAxis( localNormal );
 
#ifdef G4DEBUG_FIELD
  if( validNormal && ( std::fabs(globalNormal.mag2() - 1.0) > perThousand ) ) 
  {
    std::ostringstream message; 
    message << "**************************************************************"
            << G4endl;
    message << " Bad Normal in G4VIntersectionLocator::GetGlobalSurfaceNormal "
            << G4endl;
    message << "  * Constituents: " << G4endl;
    message << "    Local  Normal= " << localNormal << G4endl;
    message << "    Transform: " << G4endl
            << "      Net Translation= " << localToGlobal.NetTranslation()
            << G4endl
            << "      Net Rotation   = " << localToGlobal.NetRotation()
            << G4endl;
    message << "  * Result: " << G4endl;
    message << "     Global Normal= " << localNormal << G4endl;
    message << "**************************************************************";
    G4Exception("G4VIntersectionLocator::GetGlobalSurfaceNormal()",
                "GeomNav1002", JustWarning, message);
  }
#endif
 
  return globalNormal;
}

References G4VIntersectionLocator::fHelpingNavigator, G4endl, G4Exception(), G4VIntersectionLocator::GetLocalSurfaceNormal(), G4Navigator::GetLocalToGlobalTransform(), JustWarning, CLHEP::Hep3Vector::mag2(), G4AffineTransform::NetRotation(), G4AffineTransform::NetTranslation(), perThousand, and G4AffineTransform::TransformAxis().

Referenced by G4VIntersectionLocator::AdjustmentOfFoundIntersection().

GetLastSurfaceNormal()

G4ThreeVector G4VIntersectionLocator::GetLastSurfaceNormal ( const G4ThreeVector &  intersectPoint, G4bool &  validNormal  ) const

privateinherited

Definition at line 602 of file G4VIntersectionLocator.cc.

{
  G4ThreeVector normalVec;
  G4bool validNorm;
  normalVec = fiNavigator->GetGlobalExitNormal( intersectPoint, &validNorm ); 
  normalIsValid = validNorm;
 
  return normalVec;
}

References G4VIntersectionLocator::fiNavigator, and G4Navigator::GetGlobalExitNormal().

Referenced by G4VIntersectionLocator::GetSurfaceNormal().

GetLocalSurfaceNormal()

G4ThreeVector G4VIntersectionLocator::GetLocalSurfaceNormal ( const G4ThreeVector &  CurrentE_Point, G4bool &  validNormal  )

privateinherited

Definition at line 384 of file G4VIntersectionLocator.cc.

{
  G4ThreeVector Normal(G4ThreeVector(0.0,0.0,0.0));
  G4VPhysicalVolume* located;
 
  validNormal = false;
  fHelpingNavigator->SetWorldVolume(GetNavigatorFor()->GetWorldVolume());
  located = fHelpingNavigator->LocateGlobalPointAndSetup( CurrentE_Point );
 
  delete fpTouchable;
  fpTouchable = fHelpingNavigator->CreateTouchableHistory();
 
  // To check if we can use GetGlobalExitNormal() 
  //
  G4ThreeVector localPosition = fpTouchable->GetHistory()
                ->GetTopTransform().TransformPoint(CurrentE_Point);
 
  // Issue: in the case of coincident surfaces, this version does not recognise 
  //        which side you are located onto (can return vector with wrong sign.)
  // TO-DO: use direction (of chord) to identify volume we will be "entering"
 
  if( located != 0)
  { 
    G4LogicalVolume* pLogical= located->GetLogicalVolume(); 
    G4VSolid*        pSolid; 
 
    if( (pLogical != nullptr) && ( (pSolid=pLogical->GetSolid()) != nullptr ) )
    {
      if ( ( pSolid->Inside(localPosition)==kSurface )
        || ( pSolid->DistanceToOut(localPosition) < 1000.0 * kCarTolerance ) )
      {
        Normal = pSolid->SurfaceNormal(localPosition);
        validNormal = true;
 
#ifdef G4DEBUG_FIELD
        if( std::fabs(Normal.mag2() - 1.0 ) > CLHEP::perThousand) 
        {
          G4cerr << "PROBLEM in G4VIntersectionLocator::GetLocalSurfaceNormal."
                 << G4endl;
          G4cerr << "  Normal is not unit - mag=" << Normal.mag() << G4endl; 
          G4cerr << "  at trial local point " << CurrentE_Point << G4endl;
          G4cerr <<  "  Solid is " << *pSolid << G4endl;
        }
#endif
      }
    }
  }
  return Normal;
}

References G4Navigator::CreateTouchableHistory(), G4VSolid::DistanceToOut(), G4VIntersectionLocator::fHelpingNavigator, G4VIntersectionLocator::fpTouchable, G4cerr, G4endl, G4TouchableHistory::GetHistory(), G4VPhysicalVolume::GetLogicalVolume(), G4VIntersectionLocator::GetNavigatorFor(), G4LogicalVolume::GetSolid(), G4NavigationHistory::GetTopTransform(), G4VSolid::Inside(), G4VIntersectionLocator::kCarTolerance, kSurface, G4Navigator::LocateGlobalPointAndSetup(), CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), CLHEP::perThousand, G4Navigator::SetWorldVolume(), G4VSolid::SurfaceNormal(), and G4AffineTransform::TransformPoint().

Referenced by G4VIntersectionLocator::GetGlobalSurfaceNormal().

GetNavigatorFor()

G4Navigator * G4VIntersectionLocator::GetNavigatorFor ( )

inlineinherited

Referenced by G4VIntersectionLocator::AdjustmentOfFoundIntersection(), G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), G4SimpleLocator::EstimateIntersectionPoint(), G4VIntersectionLocator::GetLocalSurfaceNormal(), and G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck().

GetSurfaceNormal()

G4ThreeVector G4VIntersectionLocator::GetSurfaceNormal ( const G4ThreeVector &  CurrentInt_Point, G4bool &  validNormal  )

protectedinherited

Definition at line 518 of file G4VIntersectionLocator.cc.

{
  G4ThreeVector NormalAtEntry; // ( -10. , -10., -10. ); 
 
  G4ThreeVector NormalAtEntryLast, NormalAtEntryGlobal, diffNormals;
  G4bool validNormalLast; 
 
  // Relies on a call to Navigator::ComputeStep in IntersectChord before
  // this call
  //
  NormalAtEntryLast = GetLastSurfaceNormal( CurrentInt_Point, validNormalLast );
    // May return valid=false in cases, including
    //  - if the candidate volume was not found (eg exiting world), or
    //  - a replica was involved -- determined the step size.
    // (This list is not complete.) 
 
#ifdef G4DEBUG_FIELD
  if  ( validNormalLast
   && ( std::fabs(NormalAtEntryLast.mag2() - 1.0) > perThousand ) )
  {
    std::ostringstream message; 
    message << "PROBLEM: Normal is not unit - magnitude = "
            << NormalAtEntryLast.mag() << G4endl; 
    message << "   at trial intersection point " << CurrentInt_Point << G4endl;
    message << "   Obtained from Get *Last* Surface Normal."; 
    G4Exception("G4VIntersectionLocator::GetSurfaceNormal()",
                "GeomNav1002", JustWarning, message);
  }
#endif
 
  if( validNormalLast ) 
  {
    NormalAtEntry = NormalAtEntryLast;  
  }
  validNormal = validNormalLast;
 
  return NormalAtEntry;
}

References G4endl, G4Exception(), G4VIntersectionLocator::GetLastSurfaceNormal(), JustWarning, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), and perThousand.

Referenced by G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), and G4SimpleLocator::EstimateIntersectionPoint().

GetVerboseFor()

G4int G4VIntersectionLocator::GetVerboseFor ( )

inlineinherited

IntersectChord()

G4bool G4VIntersectionLocator::IntersectChord ( const G4ThreeVector &  StartPointA, const G4ThreeVector &  EndPointB, G4double &  NewSafety, G4double &  PreviousSafety, G4ThreeVector &  PreviousSftOrigin, G4double &  LinearStepLength, G4ThreeVector &  IntersectionPoint, G4bool *  calledNavigator = nullptr  )

inlineinherited

Referenced by G4VIntersectionLocator::AdjustmentOfFoundIntersection(), G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), and G4SimpleLocator::EstimateIntersectionPoint().

LocateGlobalPointWithinVolumeAndCheck()

G4bool G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck ( const G4ThreeVector &  pos )

protectedinherited

Definition at line 674 of file G4VIntersectionLocator.cc.

{
  G4bool good = true;
  G4Navigator* nav = GetNavigatorFor();
  const G4String
  MethodName("G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck()");
 
  if( fCheckMode )
  {
    G4bool navCheck= nav->IsCheckModeActive();  // Recover original value
    nav->CheckMode(true);
 
    // Identify the current volume
    
    G4TouchableHistoryHandle startTH= nav->CreateTouchableHistoryHandle();
    G4VPhysicalVolume* motherPhys = startTH->GetVolume();
    G4VSolid*          motherSolid = startTH->GetSolid();
    G4AffineTransform transform = nav->GetGlobalToLocalTransform();
    G4int motherCopyNo = motherPhys->GetCopyNo();
    
    // Let's check that the point is inside the current solid
    G4ThreeVector  localPosition = transform.TransformPoint(position);
    EInside        inMother = motherSolid->Inside( localPosition );
    if( inMother != kInside )
    {
      std::ostringstream message; 
      message << "Position located "
              << ( inMother == kSurface ? " on Surface " : " outside " )
              << "expected volume" << G4endl
              << "  Safety (from Outside) = "
              << motherSolid->DistanceToIn(localPosition);
      G4Exception("G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck()",
                  "GeomNav1002", JustWarning, message);
    }
    
    // 1. Simple next step - quick relocation and check result.
    // nav->LocateGlobalPointWithinVolume( position );
    
    // 2. Full relocation - to cross-check answer !
    G4VPhysicalVolume* nextPhysical= nav->LocateGlobalPointAndSetup(position);
    if(    (nextPhysical != motherPhys)
        || (nextPhysical->GetCopyNo() != motherCopyNo )
       )
    {
      G4Exception("G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck()",
                  "GeomNav1002", JustWarning,
                  "Position located outside expected volume.");
    }
    nav->CheckMode(navCheck);  // Recover original value
  }
  else
  {
    nav->LocateGlobalPointWithinVolume( position );
  }
  return good;
}

References G4Navigator::CheckMode(), G4Navigator::CreateTouchableHistoryHandle(), G4VSolid::DistanceToIn(), G4VIntersectionLocator::fCheckMode, G4endl, G4Exception(), G4VPhysicalVolume::GetCopyNo(), G4Navigator::GetGlobalToLocalTransform(), G4VIntersectionLocator::GetNavigatorFor(), G4VSolid::Inside(), G4Navigator::IsCheckModeActive(), JustWarning, kInside, kSurface, G4Navigator::LocateGlobalPointAndSetup(), G4Navigator::LocateGlobalPointWithinVolume(), and G4coutFormatters::anonymous_namespace{G4coutFormatters.cc}::transform().

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeCheckAndReport().

LocateGlobalPointWithinVolumeCheckAndReport()

void G4VIntersectionLocator::LocateGlobalPointWithinVolumeCheckAndReport ( const G4ThreeVector &  pos, const G4String &  CodeLocationInfo, G4int  CheckMode  )

protectedinherited

Definition at line 736 of file G4VIntersectionLocator.cc.

{
  // Save value of Check mode first
  G4bool oldCheck = GetCheckMode();
  
  G4bool ok = LocateGlobalPointWithinVolumeAndCheck( position );
  if( !ok )
  {
    std::ostringstream message; 
    message << "Failed point location." << G4endl
            << "   Code Location info: " << CodeLocationInfo;
    G4Exception("G4VIntersectionLocator::LocateGlobalPointWithinVolumeCheckAndReport()",
                "GeomNav1002", JustWarning, message);
  }
  
  SetCheckMode( oldCheck );
}

References G4endl, G4Exception(), G4VIntersectionLocator::GetCheckMode(), JustWarning, G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck(), and G4VIntersectionLocator::SetCheckMode().

printStatus() [1/2]

void G4VIntersectionLocator::printStatus ( const G4FieldTrack &  startFT, const G4FieldTrack &  currentFT, G4double  requestStep, G4double  safety, G4int  stepNum  )

inherited

Definition at line 75 of file G4VIntersectionLocator.cc.

{
  std::ostringstream os; 
  printStatus( StartFT,CurrentFT,requestStep,safety,stepNo,os,fVerboseLevel);
  G4cout << os.str();
}

References G4VIntersectionLocator::fVerboseLevel, G4cout, and G4VIntersectionLocator::printStatus().

Referenced by G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), G4SimpleLocator::EstimateIntersectionPoint(), G4VIntersectionLocator::printStatus(), G4VIntersectionLocator::ReportProgress(), and G4VIntersectionLocator::ReportReversedPoints().

printStatus() [2/2]

void G4VIntersectionLocator::printStatus ( const G4FieldTrack &  startFT, const G4FieldTrack &  currentFT, G4double  requestStep, G4double  safety, G4int  stepNum, std::ostream &  oss, G4int  verboseLevel  )

staticinherited

Definition at line 91 of file G4VIntersectionLocator.cc.

{
  // const G4int verboseLevel= fVerboseLevel;
  const G4ThreeVector StartPosition       = StartFT.GetPosition();
  const G4ThreeVector StartUnitVelocity   = StartFT.GetMomentumDir();
  const G4ThreeVector CurrentPosition     = CurrentFT.GetPosition();
  const G4ThreeVector CurrentUnitVelocity = CurrentFT.GetMomentumDir();
 
  G4double step_len = CurrentFT.GetCurveLength() - StartFT.GetCurveLength();
  G4int oldprc;  // cout/cerr precision settings
 
  if( ((stepNo == 0) && (verboseLevel <3)) || (verboseLevel >= 3) )
  {
    oldprc = os.precision(4);
    os << std::setw( 6)  << " " 
           << std::setw( 25) << " Current Position  and  Direction" << " "
           << G4endl; 
    os << std::setw( 5) << "Step#" 
           << std::setw(10) << "  s  " << " "
           << std::setw(10) << "X(mm)" << " "
           << std::setw(10) << "Y(mm)" << " "  
           << std::setw(10) << "Z(mm)" << " "
           << std::setw( 7) << " N_x " << " "
           << std::setw( 7) << " N_y " << " "
           << std::setw( 7) << " N_z " << " " ;
    os << std::setw( 7) << " Delta|N|" << " "
           << std::setw( 9) << "StepLen" << " "  
           << std::setw(12) << "StartSafety" << " "  
           << std::setw( 9) << "PhsStep" << " ";  
    os << G4endl;
    os.precision(oldprc);
  }
  if((stepNo == 0) && (verboseLevel <=3))
  {
    // Recurse to print the start values
    //
    printStatus( StartFT, StartFT, -1.0, safety, -1, os, verboseLevel);
  }
  if( verboseLevel <= 3 )
  {
    if( stepNo >= 0)
    {
       os << std::setw( 4) << stepNo << " ";
    }
    else
    {
       os << std::setw( 5) << "Start" ;
    }
    oldprc = os.precision(8);
    os << std::setw(10) << CurrentFT.GetCurveLength() << " "; 
    os << std::setw(10) << CurrentPosition.x() << " "
           << std::setw(10) << CurrentPosition.y() << " "
           << std::setw(10) << CurrentPosition.z() << " ";
    os.precision(4);
    os << std::setw( 7) << CurrentUnitVelocity.x() << " "
           << std::setw( 7) << CurrentUnitVelocity.y() << " "
           << std::setw( 7) << CurrentUnitVelocity.z() << " ";
    os.precision(3); 
    os << std::setw( 7)
           << CurrentFT.GetMomentum().mag()- StartFT.GetMomentum().mag()
           << " "; 
    os << std::setw( 9) << step_len << " "; 
    os << std::setw(12) << safety << " ";
    if( requestStep != -1.0 )
    {
      os << std::setw( 9) << requestStep << " ";
    }
    else
    {
      os << std::setw( 9) << "Init/NotKnown" << " "; 
    }
    os << G4endl;
    os.precision(oldprc);
  }
  else // if( verboseLevel > 3 )
  {
    //  Multi-line output
       
    os << "Step taken was " << step_len  
           << " out of PhysicalStep= " <<  requestStep << G4endl;
    os << "Final safety is: " << safety << G4endl;
    os << "Chord length = " << (CurrentPosition-StartPosition).mag()
           << G4endl;
    os << G4endl; 
  }
}

References G4endl, G4FieldTrack::GetCurveLength(), G4FieldTrack::GetMomentum(), G4FieldTrack::GetMomentumDir(), G4FieldTrack::GetPosition(), CLHEP::Hep3Vector::mag(), G4VIntersectionLocator::printStatus(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

ReEstimateEndpoint()

G4FieldTrack G4VIntersectionLocator::ReEstimateEndpoint ( const G4FieldTrack &  CurrentStateA, const G4FieldTrack &  EstimtdEndStateB, G4double  linearDistSq, G4double  curveDist  )

protectedinherited

Definition at line 188 of file G4VIntersectionLocator.cc.

{  
  G4FieldTrack newEndPoint( CurrentStateA );
  auto integrDriver = GetChordFinderFor()->GetIntegrationDriver(); 
 
  G4FieldTrack retEndPoint( CurrentStateA );
  G4bool goodAdvance;
  G4int  itrial = 0;
  const G4int no_trials = 20;
 
 
  G4double endCurveLen= EstimatedEndStateB.GetCurveLength();
 
  do  // Loop checking, 07.10.2016, JA
  {
    G4double currentCurveLen = newEndPoint.GetCurveLength();
    G4double advanceLength = endCurveLen - currentCurveLen ; 
    if (std::abs(advanceLength)<kCarTolerance)
    {
      goodAdvance=true;
    }
    else
    {
      goodAdvance = integrDriver->AccurateAdvance(newEndPoint, advanceLength,
                                                  GetEpsilonStepFor());
    }
  }
  while( !goodAdvance && (++itrial < no_trials) );
 
  if( goodAdvance )
  {
    retEndPoint = newEndPoint; 
  }
  else
  {
    retEndPoint = EstimatedEndStateB; // Could not improve without major work !!
  }
 
  //  All the work is done
  //  below are some diagnostics only -- before the return!
  // 
  const G4String MethodName("G4VIntersectionLocator::ReEstimateEndpoint()");
 
#ifdef G4VERBOSE
  G4int  latest_good_trials = 0;
  if( itrial > 1)
  {
    if( fVerboseLevel > 0 )
    {
      G4cout << MethodName << " called - goodAdv= " << goodAdvance
             << " trials = " << itrial
             << " previous good= " << latest_good_trials
             << G4endl;
    }
    latest_good_trials = 0; 
  }
  else
  {   
    ++latest_good_trials; 
  }
#endif
 
#ifdef G4DEBUG_FIELD
  G4double lengthDone = newEndPoint.GetCurveLength() 
                      - CurrentStateA.GetCurveLength(); 
  if( !goodAdvance )
  {
    if( fVerboseLevel >= 3 )
    {
      G4cout << MethodName << "> AccurateAdvance failed " ;
      G4cout << " in " << itrial << " integration trials/steps. " << G4endl;
      G4cout << " It went only " << lengthDone << " instead of " << curveDist
             << " -- a difference of " << curveDist - lengthDone  << G4endl;
      G4cout << " ReEstimateEndpoint> Reset endPoint to original value!"
             << G4endl;
    }
  }
  G4double linearDist = ( EstimatedEndStateB.GetPosition() 
                      - CurrentStateA.GetPosition() ).mag(); 
  static G4int noInaccuracyWarnings = 0; 
  G4int maxNoWarnings = 10;
  if (  (noInaccuracyWarnings < maxNoWarnings ) 
       || (fVerboseLevel > 1) )
    {
      G4ThreeVector move = newEndPoint.GetPosition()
                         - EstimatedEndStateB.GetPosition();
      std::ostringstream message;
      message.precision(12);
      message << " Integration inaccuracy requires" 
              << " an adjustment in the step's endpoint."  << G4endl
              << "   Two mid-points are further apart than their"
              << " curve length difference"                << G4endl 
              << "   Dist = "       << linearDist
              << " curve length = " << curveDist             << G4endl; 
      message << " Correction applied is " << move.mag() << G4endl
              << "  Old Estimated B position= "
              << EstimatedEndStateB.GetPosition() << G4endl
              << "  Recalculated    Position= "
              << newEndPoint.GetPosition() << G4endl
              << "   Change ( new - old )   = " << move;
      G4Exception("G4VIntersectionLocator::ReEstimateEndpoint()",
                  "GeomNav1002", JustWarning, message);
    }
/*
#else
  // Statistics on the RMS value of the corrections
 
  static G4ThreadLocal G4int noCorrections = 0;
  ++noCorrections; 
  if( goodAdvance )
  {
    static G4ThreadLocal G4double sumCorrectionsSq;
    sumCorrectionsSq += (EstimatedEndStateB.GetPosition() - 
                         newEndPoint.GetPosition()).mag2();
  }
*/
#endif
 
  return retEndPoint;
}

References G4VIntersectionLocator::fVerboseLevel, G4cout, G4endl, G4Exception(), G4VIntersectionLocator::GetChordFinderFor(), G4FieldTrack::GetCurveLength(), G4VIntersectionLocator::GetEpsilonStepFor(), G4ChordFinder::GetIntegrationDriver(), G4FieldTrack::GetPosition(), JustWarning, G4VIntersectionLocator::kCarTolerance, and CLHEP::Hep3Vector::mag().

Referenced by G4VIntersectionLocator::CheckAndReEstimateEndpoint(), G4BrentLocator::EstimateIntersectionPoint(), and G4SimpleLocator::EstimateIntersectionPoint().

ReportFieldValue()

void G4MultiLevelLocator::ReportFieldValue ( const G4FieldTrack &  locationPV, const char *  nameLoc, const G4EquationOfMotion *  equation  )

private

Definition at line 980 of file G4MultiLevelLocator.cc.

{
   enum { maxNumFieldComp = 24 };
 
   G4ThreeVector position = locationPV.GetPosition();   
   G4double startPoint[4] = { position.x(), position.y(), position.z(),
                              locationPV.GetLabTimeOfFlight() };
   G4double FieldVec[maxNumFieldComp]; // 24 ;
   for (auto i=0; i<maxNumFieldComp; ++i )
   {
     FieldVec[i] = 0.0;
   }
   equation->GetFieldValue( startPoint, FieldVec);
   G4cout << "  B-field value (" << nameLoc << ")=   "
          << FieldVec[0] << " " << FieldVec[1] << " " << FieldVec[2];
   G4double Emag2= G4ThreeVector( FieldVec[3],
                                  FieldVec[4],
                                  FieldVec[5] ).mag2(); 
   if( Emag2 > 0.0 )
   {
      G4cout << " Electric = " << FieldVec[3] << " "
                               << FieldVec[4] << " "
                               << FieldVec[5]<< G4endl;
   }
   return;
}

References G4cout, G4endl, G4EquationOfMotion::GetFieldValue(), G4FieldTrack::GetLabTimeOfFlight(), G4FieldTrack::GetPosition(), and CLHEP::Hep3Vector::mag2().

Referenced by EstimateIntersectionPoint().

ReportImmediateHit()

void G4VIntersectionLocator::ReportImmediateHit ( const char *  MethodName, const G4ThreeVector &  StartPosition, const G4ThreeVector &  TrialPoint, G4double  tolerance, unsigned long int  numCalls  )

protectedinherited

Definition at line 845 of file G4VIntersectionLocator.cc.

{
  static G4ThreadLocal unsigned int occurredOnTop= 0;
  static G4ThreadLocal G4ThreeVector* ptrLast = nullptr;
  if( ptrLast == nullptr )
  {
     ptrLast= new G4ThreeVector( DBL_MAX, DBL_MAX, DBL_MAX );
     G4AutoDelete::Register(ptrLast);
  }
  G4ThreeVector &lastStart= *ptrLast;
 
  if( (TrialPoint - StartPosition).mag2() < tolerance*tolerance) 
  {
     static G4ThreadLocal unsigned int numUnmoved = 0;
     static G4ThreadLocal unsigned int numStill = 0;    // Still at same point
 
     G4cout << "Intersection F == start A in " << MethodName;
     G4cout << "Start Point: " << StartPosition << G4endl;
     G4cout << " Start-Trial: " << TrialPoint - StartPosition;
     G4cout << " Start-last: " << StartPosition - lastStart;
 
     if( (StartPosition - lastStart).mag() < tolerance )
     {
        // We are at position of last 'Start' position - ie unmoved
        ++numUnmoved;
        ++numStill; 
        G4cout << " { Unmoved: "  << " still#= " << numStill
               << " total # = " << numUnmoved << " } - ";
     }
     else
     {
        numStill = 0; 
     }
     G4cout << " Occurred: " << ++occurredOnTop;  
     G4cout <<  " out of total calls= " << numCalls;
     G4cout << G4endl;
     lastStart = StartPosition;
  }
}  // End of ReportImmediateHit() 

References DBL_MAX, G4cout, G4endl, G4ThreadLocal, and G4AutoDelete::Register().

Referenced by EstimateIntersectionPoint().

ReportProgress()

void G4VIntersectionLocator::ReportProgress ( std::ostream &  oss, const G4FieldTrack &  StartPointVel, const G4FieldTrack &  EndPointVel, G4int  substep_no, const G4FieldTrack &  A_PtVel, const G4FieldTrack &  B_PtVel, G4double  safetyLast, G4int  depth = -1  )

protectedinherited

Definition at line 813 of file G4VIntersectionLocator.cc.

{
  oss << "ReportProgress: Current status of intersection search: " << G4endl;
  if( depth > 0 ) oss << " Depth= " << depth;
  oss << " Substep no = " << substep_no << G4endl;
  G4int  verboseLevel = 5; 
  G4double safetyPrev = -1.0;  // Add as argument ?
 
  printStatus( StartPointVel, EndPointVel, -1.0, -1.0, -1, 
              oss, verboseLevel);  
  oss << " * Start and end-point of requested Step:" << G4endl;
  oss << " ** State of point A: "; 
  printStatus( A_PtVel, A_PtVel, -1.0, safetyPrev, substep_no-1,
               oss, verboseLevel);  
  oss << " ** State of point B: "; 
  printStatus( A_PtVel, B_PtVel, -1.0, safetyLast, substep_no, 
               oss, verboseLevel);
}

References G4endl, and G4VIntersectionLocator::printStatus().

Referenced by EstimateIntersectionPoint().

ReportReversedPoints()

void G4VIntersectionLocator::ReportReversedPoints ( std::ostringstream &  ossMsg, const G4FieldTrack &  StartPointVel, const G4FieldTrack &  EndPointVel, G4double  NewSafety, G4double  epsStep, const G4FieldTrack &  CurrentA_PointVelocity, const G4FieldTrack &  CurrentB_PointVelocity, const G4FieldTrack &  SubStart_PointVelocity, const G4ThreeVector &  CurrentE_Point, const G4FieldTrack &  ApproxIntersecPointV, G4int  sbstp_no, G4int  sbstp_no_p, G4int  depth  )

protectedinherited

Definition at line 761 of file G4VIntersectionLocator.cc.

{
   // Expect that 'msg' can hold the name of the calling method
 
   // FieldTrack 'points' A and B have been tangled
   // Whereas A should be before B, it is found that curveLen(B) < curveLen(A)
   G4int verboseLevel= 5; 
   G4double curveDist = B_PtVel.GetCurveLength() - A_PtVel.GetCurveLength();
   G4VIntersectionLocator::printStatus( A_PtVel,  B_PtVel,
                           -1.0, NewSafety,  substep_no, msg, verboseLevel );
   msg << "Error in advancing propagation." << G4endl
       << "   The final curve point is NOT further along"
       << "  than the original!" << G4endl
       << "   Going *backwards* from len(A) = " << A_PtVel.GetCurveLength()
       << "  to len(B) = " << B_PtVel.GetCurveLength() << G4endl
       << "      Curve distance is " << curveDist / CLHEP::millimeter << " mm "
       << G4endl
       << "      Point A' (start) is " << A_PtVel  << G4endl
       << "      Point B' (end)   is " << B_PtVel << G4endl;
   msg << "      fEpsStep= " << epsStep << G4endl << G4endl;
 
   G4int oldprc = msg.precision(20);
   msg << " In full precision, the position, momentum, E_kin, length, rest mass "
       << " ... are: " << G4endl;
   msg << " Point A[0] (Curve   start) is " << StartPointVel << G4endl
       << " Point S    (Sub     start) is " << SubStart_PtVel
       << " Point A'   (Current start) is " << A_PtVel << G4endl
       << " Point E    (Trial Point)   is " << E_Point << G4endl
       << " Point F    (Intersection)  is " << ApproxIntersecPointV << G4endl
       << " Point B'   (Current end)   is " << B_PtVel << G4endl
       << " Point B[0] (Curve   end)   is " << EndPointVel << G4endl
       << G4endl
       << " LocateIntersection parameters are : " << G4endl
       << "      Substep no (total) = "  << substep_no << G4endl
       << "      Substep no         = "  << substep_no_p << " at depth= " << depth;
   msg.precision(oldprc);
}

References G4endl, G4FieldTrack::GetCurveLength(), CLHEP::millimeter, and G4VIntersectionLocator::printStatus().

Referenced by EstimateIntersectionPoint().

ReportStatistics()

void G4MultiLevelLocator::ReportStatistics

(

)

Definition at line 969 of file G4MultiLevelLocator.cc.

{
   G4cout << " Number of calls = " << fNumCalls << G4endl;
   G4cout << " Number of split level ('advances'):  "
          << fNumAdvanceTrials << G4endl;
   G4cout << " Number of full advances:             "
          << fNumAdvanceGood << G4endl;
   G4cout << " Number of good advances:             "
          << fNumAdvanceFull << G4endl;
}

References fNumAdvanceFull, fNumAdvanceGood, fNumAdvanceTrials, fNumCalls, G4cout, and G4endl.

Referenced by ~G4MultiLevelLocator().

ReportTrialStep()

void G4VIntersectionLocator::ReportTrialStep ( G4int  step_no, const G4ThreeVector &  ChordAB_v, const G4ThreeVector &  ChordEF_v, const G4ThreeVector &  NewMomentumDir, const G4ThreeVector &  NormalAtEntry, G4bool  validNormal  )

protectedinherited

Definition at line 618 of file G4VIntersectionLocator.cc.

{
  G4double ABchord_length  = ChordAB_v.mag(); 
  G4double MomDir_dot_Norm = NewMomentumDir.dot( NormalAtEntry );
  G4double MomDir_dot_ABchord;
  MomDir_dot_ABchord = (1.0 / ABchord_length) * NewMomentumDir.dot( ChordAB_v );
 
  std::ostringstream  outStream; 
  outStream << std::setw(6)  << " Step# "
    << std::setw(17) << " |ChordEF|(mag)" << "  "
    << std::setw(18) << " uMomentum.Normal" << "  "
    << std::setw(18) << " uMomentum.ABdir " << "  " 
    << std::setw(16) << " AB-dist         " << " " 
    << " Chord Vector (EF) " 
    << G4endl;
  outStream.precision(7); 
  outStream << " " << std::setw(5) << step_no           
    << " " << std::setw(18) << ChordEF_v.mag() 
    << " " << std::setw(18) << MomDir_dot_Norm    
    << " " << std::setw(18) << MomDir_dot_ABchord 
    << " " << std::setw(12) << ABchord_length     
    << " " << ChordEF_v
    << G4endl;
  outStream << " MomentumDir= " << " " << NewMomentumDir 
    << " Normal at Entry E= " << NormalAtEntry
    << " AB chord =   " << ChordAB_v
    << G4endl;
  G4cout << outStream.str();
 
  if( ( std::fabs(NormalAtEntry.mag2() - 1.0) > perThousand ) ) 
  {
    std::ostringstream message; 
    message << "Normal is not unit - mag= " << NormalAtEntry.mag() << G4endl
            << "         ValidNormalAtE = " << validNormal;
    G4Exception("G4VIntersectionLocator::ReportTrialStep()",
                "GeomNav1002", JustWarning, message);
  }
  return; 
}

References CLHEP::Hep3Vector::dot(), G4cout, G4endl, G4Exception(), JustWarning, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), and perThousand.

Referenced by G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), and G4SimpleLocator::EstimateIntersectionPoint().

SetCheckMode()

void G4VIntersectionLocator::SetCheckMode ( G4bool  value )

inlineinherited

Definition at line 130 of file G4VIntersectionLocator.hh.

{ fCheckMode = value; }

References G4VIntersectionLocator::fCheckMode.

Referenced by G4VIntersectionLocator::LocateGlobalPointWithinVolumeCheckAndReport().

SetChordFinderFor()

void G4VIntersectionLocator::SetChordFinderFor ( G4ChordFinder *  fCFinder )

inlineinherited

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

SetDeltaIntersectionFor()

void G4VIntersectionLocator::SetDeltaIntersectionFor ( G4double  deltaIntersection )

inlineinherited

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

SetEpsilonStepFor()

void G4VIntersectionLocator::SetEpsilonStepFor ( G4double  EpsilonStep )

inlineinherited

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

SetMaxSteps()

void G4MultiLevelLocator::SetMaxSteps ( unsigned int  valMax )

inline

Definition at line 71 of file G4MultiLevelLocator.hh.

{ fMaxSteps= valMax; }

References fMaxSteps.

Referenced by G4MultiLevelLocator().

SetNavigatorFor()

void G4VIntersectionLocator::SetNavigatorFor ( G4Navigator *  fNavigator )

inlineinherited

Referenced by G4ErrorPropagatorManager::StartNavigator().

SetSafetyParametersFor()

void G4VIntersectionLocator::SetSafetyParametersFor ( G4bool  UseSafety )

inlineinherited

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

SetVerboseFor()

void G4VIntersectionLocator::SetVerboseFor ( G4int  fVerbose )

inlineinherited

SetWarnSteps()

void G4MultiLevelLocator::SetWarnSteps ( unsigned int  valWarn )

inline

Definition at line 72 of file G4MultiLevelLocator.hh.

{ fWarnSteps= valWarn; }

References fWarnSteps.

Referenced by G4MultiLevelLocator().

Field Documentation

fCheckMode

G4bool G4VIntersectionLocator::fCheckMode = false

protectedinherited

Definition at line 256 of file G4VIntersectionLocator.hh.

Referenced by EstimateIntersectionPoint(), G4MultiLevelLocator(), G4VIntersectionLocator::GetCheckMode(), G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck(), and G4VIntersectionLocator::SetCheckMode().

fHelpingNavigator

G4Navigator* G4VIntersectionLocator::fHelpingNavigator

protectedinherited

Definition at line 267 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator::G4VIntersectionLocator(), G4VIntersectionLocator::GetGlobalSurfaceNormal(), G4VIntersectionLocator::GetLocalSurfaceNormal(), and G4VIntersectionLocator::~G4VIntersectionLocator().

fiChordFinder

G4ChordFinder* G4VIntersectionLocator::fiChordFinder = nullptr

protectedinherited

Definition at line 261 of file G4VIntersectionLocator.hh.

fiDeltaIntersection

G4double G4VIntersectionLocator::fiDeltaIntersection = -1.0

protectedinherited

Definition at line 263 of file G4VIntersectionLocator.hh.

Referenced by G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), and G4SimpleLocator::EstimateIntersectionPoint().

fiEpsilonStep

G4double G4VIntersectionLocator::fiEpsilonStep = -1.0

protectedinherited

Definition at line 262 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator::CheckAndReEstimateEndpoint(), and EstimateIntersectionPoint().

fiNavigator

G4Navigator* G4VIntersectionLocator::fiNavigator

protectedinherited

Definition at line 259 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator::G4VIntersectionLocator(), and G4VIntersectionLocator::GetLastSurfaceNormal().

fiUseSafety

G4bool G4VIntersectionLocator::fiUseSafety = false

protectedinherited

Definition at line 257 of file G4VIntersectionLocator.hh.

fMaxSteps

unsigned int G4MultiLevelLocator::fMaxSteps = 10000

private

Definition at line 83 of file G4MultiLevelLocator.hh.

Referenced by EstimateIntersectionPoint(), and SetMaxSteps().

fNumAdvanceFull

unsigned long int G4MultiLevelLocator::fNumAdvanceFull = 0

private

Definition at line 92 of file G4MultiLevelLocator.hh.

Referenced by EstimateIntersectionPoint(), and ReportStatistics().

fNumAdvanceGood

unsigned long int G4MultiLevelLocator::fNumAdvanceGood = 0

private

Definition at line 93 of file G4MultiLevelLocator.hh.

Referenced by EstimateIntersectionPoint(), and ReportStatistics().

fNumAdvanceTrials

unsigned long int G4MultiLevelLocator::fNumAdvanceTrials = 0

private

Definition at line 94 of file G4MultiLevelLocator.hh.

Referenced by EstimateIntersectionPoint(), and ReportStatistics().

fNumCalls

unsigned long int G4MultiLevelLocator::fNumCalls = 0

private

Definition at line 91 of file G4MultiLevelLocator.hh.

Referenced by EstimateIntersectionPoint(), and ReportStatistics().

fpTouchable

G4TouchableHistory* G4VIntersectionLocator::fpTouchable = nullptr

protectedinherited

Definition at line 270 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator::GetLocalSurfaceNormal(), and G4VIntersectionLocator::~G4VIntersectionLocator().

fUseNormalCorrection

G4bool G4VIntersectionLocator::fUseNormalCorrection = false

protectedinherited

Definition at line 255 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator::AreIntersectionsAdjusted().

fVerboseLevel

G4int G4VIntersectionLocator::fVerboseLevel = 0

protectedinherited

Definition at line 254 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator::AdjustmentOfFoundIntersection(), G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), G4SimpleLocator::EstimateIntersectionPoint(), G4VIntersectionLocator::printStatus(), and G4VIntersectionLocator::ReEstimateEndpoint().

fWarnSteps

unsigned int G4MultiLevelLocator::fWarnSteps = 1000

private

Definition at line 84 of file G4MultiLevelLocator.hh.

Referenced by EstimateIntersectionPoint(), and SetWarnSteps().

kCarTolerance

G4double G4VIntersectionLocator::kCarTolerance

protectedinherited

Definition at line 252 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator::AdjustmentOfFoundIntersection(), G4BrentLocator::EstimateIntersectionPoint(), EstimateIntersectionPoint(), G4SimpleLocator::EstimateIntersectionPoint(), G4VIntersectionLocator::G4VIntersectionLocator(), G4VIntersectionLocator::GetLocalSurfaceNormal(), and G4VIntersectionLocator::ReEstimateEndpoint().

max_depth

const G4int G4MultiLevelLocator::max_depth = 10

staticprivate

Definition at line 82 of file G4MultiLevelLocator.hh.

Referenced by EstimateIntersectionPoint(), G4MultiLevelLocator(), and ~G4MultiLevelLocator().

ptrInterMedFT

G4FieldTrack* G4MultiLevelLocator::ptrInterMedFT[max_depth+1]

private

Definition at line 88 of file G4MultiLevelLocator.hh.

Referenced by EstimateIntersectionPoint(), G4MultiLevelLocator(), and ~G4MultiLevelLocator().

---

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

• source/geometry/navigation/include/G4MultiLevelLocator.hh
• source/geometry/navigation/src/G4MultiLevelLocator.cc