G4VIntersectionLocator Class Reference

#include <G4VIntersectionLocator.hh>

Inheritance diagram for G4VIntersectionLocator:

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

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
G4FieldTrack	ReEstimateEndpoint (const G4FieldTrack &CurrentStateA, const G4FieldTrack &EstimtdEndStateB, G4double linearDistSq, G4double curveDist)
G4bool	CheckAndReEstimateEndpoint (const G4FieldTrack &CurrentStartA, const G4FieldTrack &EstimatedEndB, G4FieldTrack &RevisedEndPoint, G4int &errorCode)
G4ThreeVector	GetSurfaceNormal (const G4ThreeVector &CurrentInt_Point, G4bool &validNormal)
G4ThreeVector	GetGlobalSurfaceNormal (const G4ThreeVector &CurrentE_Point, G4bool &validNormal)
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)
void	ReportTrialStep (G4int step_no, const G4ThreeVector &ChordAB_v, const G4ThreeVector &ChordEF_v, const G4ThreeVector &NewMomentumDir, const G4ThreeVector &NormalAtEntry, G4bool validNormal)
G4bool	LocateGlobalPointWithinVolumeAndCheck (const G4ThreeVector &pos)
void	LocateGlobalPointWithinVolumeCheckAndReport (const G4ThreeVector &pos, const G4String &CodeLocationInfo, G4int CheckMode)
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	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	ReportImmediateHit (const char *MethodName, const G4ThreeVector &StartPosition, const G4ThreeVector &TrialPoint, G4double tolerance, unsigned long int numCalls)

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

Detailed Description

Definition at line 49 of file G4VIntersectionLocator.hh.

Constructor & Destructor Documentation

G4VIntersectionLocator()

G4VIntersectionLocator::G4VIntersectionLocator

(

G4Navigator *

theNavigator

)

Definition at line 46 of file G4VIntersectionLocator.cc.

 : fiNavigator(theNavigator)
{
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
  if( fiNavigator->GetExternalNavigation() == nullptr )
  {
    fHelpingNavigator = new G4Navigator();
  }
  else // Must clone the navigator, together with External Navigation
  {
    fHelpingNavigator = fiNavigator->Clone();
  }
}      

~G4VIntersectionLocator()

G4VIntersectionLocator::~G4VIntersectionLocator ( )

virtual

Definition at line 65 of file G4VIntersectionLocator.cc.

{
  delete fHelpingNavigator;
  delete fpTouchable;
}

Member Function Documentation

AddAdjustementOfFoundIntersection()

void G4VIntersectionLocator::AddAdjustementOfFoundIntersection ( G4bool UseCorrection )

inline

AdjustIntersections()

void G4VIntersectionLocator::AdjustIntersections ( G4bool UseCorrection )

inline

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 )

protected

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

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

AreIntersectionsAdjusted()

G4bool G4VIntersectionLocator::AreIntersectionsAdjusted ( )

inline

Definition at line 118 of file G4VIntersectionLocator.hh.

{ return fUseNormalCorrection; }  

CheckAndReEstimateEndpoint()

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

protected

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

Referenced by G4MultiLevelLocator::EstimateIntersectionPoint().

EstimateIntersectionPoint()

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

pure virtual

Implemented in G4BrentLocator, G4MultiLevelLocator, and G4SimpleLocator.

GetAdjustementOfFoundIntersection()

G4bool G4VIntersectionLocator::GetAdjustementOfFoundIntersection ( )

inline

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

GetCheckMode()

G4bool G4VIntersectionLocator::GetCheckMode ( )

inline

Definition at line 131 of file G4VIntersectionLocator.hh.

{ return fCheckMode; }

Referenced by LocateGlobalPointWithinVolumeCheckAndReport().

GetChordFinderFor()

G4ChordFinder * G4VIntersectionLocator::GetChordFinderFor ( )

inline

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

GetDeltaIntersectionFor()

G4double G4VIntersectionLocator::GetDeltaIntersectionFor ( )

inline

Referenced by G4BrentLocator::EstimateIntersectionPoint().

GetEpsilonStepFor()

G4double G4VIntersectionLocator::GetEpsilonStepFor ( )

inline

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

GetGlobalSurfaceNormal()

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

protected

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

Referenced by AdjustmentOfFoundIntersection().

GetNavigatorFor()

G4Navigator * G4VIntersectionLocator::GetNavigatorFor ( )

inline

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

GetSurfaceNormal()

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

protected

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

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

GetVerboseFor()

G4int G4VIntersectionLocator::GetVerboseFor ( )

inline

IntersectChord()

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

inline

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

LocateGlobalPointWithinVolumeAndCheck()

G4bool G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck ( const G4ThreeVector & pos )

protected

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

Referenced by LocateGlobalPointWithinVolumeCheckAndReport().

LocateGlobalPointWithinVolumeCheckAndReport()

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

protected

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

printStatus() [1/2]

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

Definition at line 76 of file G4VIntersectionLocator.cc.

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

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

printStatus() [2/2]

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

static

Definition at line 92 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();
  G4long 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; 
  }
}

ReEstimateEndpoint()

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

protected

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

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

ReportImmediateHit()

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

protected

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

Referenced by G4MultiLevelLocator::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 )

protected

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

Referenced by G4MultiLevelLocator::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 )

protected

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

Referenced by G4MultiLevelLocator::EstimateIntersectionPoint().

ReportTrialStep()

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

protected

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

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

SetCheckMode()

void G4VIntersectionLocator::SetCheckMode ( G4bool value )

inline

Definition at line 130 of file G4VIntersectionLocator.hh.

{ fCheckMode = value; }

Referenced by LocateGlobalPointWithinVolumeCheckAndReport().

SetChordFinderFor()

void G4VIntersectionLocator::SetChordFinderFor ( G4ChordFinder * fCFinder )

inline

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

SetDeltaIntersectionFor()

void G4VIntersectionLocator::SetDeltaIntersectionFor ( G4double deltaIntersection )

inline

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

SetEpsilonStepFor()

void G4VIntersectionLocator::SetEpsilonStepFor ( G4double EpsilonStep )

inline

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

SetNavigatorFor()

void G4VIntersectionLocator::SetNavigatorFor ( G4Navigator * fNavigator )

inline

SetSafetyParametersFor()

void G4VIntersectionLocator::SetSafetyParametersFor ( G4bool UseSafety )

inline

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

SetVerboseFor()

void G4VIntersectionLocator::SetVerboseFor ( G4int fVerbose )

inline

Member Data Documentation

fCheckMode

G4bool G4VIntersectionLocator::fCheckMode = false

protected

Definition at line 256 of file G4VIntersectionLocator.hh.

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

fHelpingNavigator

G4Navigator* G4VIntersectionLocator::fHelpingNavigator

protected

Definition at line 267 of file G4VIntersectionLocator.hh.

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

fiChordFinder

G4ChordFinder* G4VIntersectionLocator::fiChordFinder = nullptr

protected

Definition at line 261 of file G4VIntersectionLocator.hh.

fiDeltaIntersection

G4double G4VIntersectionLocator::fiDeltaIntersection = -1.0

protected

Definition at line 263 of file G4VIntersectionLocator.hh.

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

fiEpsilonStep

G4double G4VIntersectionLocator::fiEpsilonStep = -1.0

protected

Definition at line 262 of file G4VIntersectionLocator.hh.

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

fiNavigator

G4Navigator* G4VIntersectionLocator::fiNavigator

protected

Definition at line 259 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator().

fiUseSafety

G4bool G4VIntersectionLocator::fiUseSafety = false

protected

Definition at line 257 of file G4VIntersectionLocator.hh.

fpTouchable

G4TouchableHistory* G4VIntersectionLocator::fpTouchable = nullptr

protected

Definition at line 270 of file G4VIntersectionLocator.hh.

Referenced by ~G4VIntersectionLocator().

fUseNormalCorrection

G4bool G4VIntersectionLocator::fUseNormalCorrection = false

protected

Definition at line 255 of file G4VIntersectionLocator.hh.

Referenced by AreIntersectionsAdjusted().

fVerboseLevel

G4int G4VIntersectionLocator::fVerboseLevel = 0

protected

Definition at line 254 of file G4VIntersectionLocator.hh.

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

kCarTolerance

G4double G4VIntersectionLocator::kCarTolerance

protected

Definition at line 252 of file G4VIntersectionLocator.hh.

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

---

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

• G4VIntersectionLocator.hh
• G4VIntersectionLocator.cc