G4VIntersectionLocator Class Reference

G4VIntersectionLocator is a base class for the calculation of the intersection point with a boundary when PropagationInField is used. It gives the possibility to choose the method of intersection. More...

#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
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	AdjustIntersections (G4bool UseCorrection)
G4bool	AreIntersectionsAdjusted ()
void	AddAdjustementOfFoundIntersection (G4bool UseCorrection)
G4bool	GetAdjustementOfFoundIntersection ()
void	printStatus (const G4FieldTrack &startFT, const G4FieldTrack &currentFT, G4double requestStep, G4double safety, G4int stepNum)
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

G4VIntersectionLocator is a base class for the calculation of the intersection point with a boundary when PropagationInField is used. It gives the possibility to choose the method of intersection.

Definition at line 54 of file G4VIntersectionLocator.hh.

Constructor & Destructor Documentation

G4VIntersectionLocator()

G4VIntersectionLocator::G4VIntersectionLocator

(

G4Navigator *

theNavigator

)

Constructor and virtual Destructor.

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();
  }
}      

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

~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

Adjustment flag accessor/modifier.

Deprecated

Replaced by methods above. To be removed in future releases.

AdjustIntersections()

void G4VIntersectionLocator::AdjustIntersections ( G4bool UseCorrection )

inline

Adjustment flag accessor/modifier.

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

Optional method for adjustment of located intersection point using the surface-normal.

Parameters

[in]	A	Chord starting point.
[in]	CurrentE_Point	E Chord point.
[in]	CurrentF_Point	F Chord point.
[in]	MomentumDir	Momentum direction.
[in]	IntersectAF	First part intersecting?
[in,out]	IntersectionPoint	Intersection point tangent track.
[in,out]	NewSafety	New safety distance.
[in,out]	fPrevSafety	Previous safety distance.
[in,out]	fPrevSftOrigin	Previous safety point origin.

Returns

Whether intersection exists or not.

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 144 of file G4VIntersectionLocator.hh.

{ return fUseNormalCorrection; }  

CheckAndReEstimateEndpoint()

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

protected

Checks whether EndB is too far from StartA to be reached and if, re-estimates new value for EndB (return in RevisedEndPoint). Reports error if EndB is before StartA (in curve length) In that case return errorCode = 2.

Parameters

[in]	CurrentStartA	Start point tangent track.
[in]	EstimatedEndB	Estimated end point tangent track.
[in]	RevisedEndPoint	Revised end point tangent track.
[in]	errorCode	Error code (0=OK, 1=coincident points, 2=error).

Returns

true if end point has been revised.

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

If such an intersection exists, this method calculates the intersection point of the true path of the particle with the surface of the current volume (or of one of its daughters). Should use lateral displacement as measure of convergence.

Note

Changes the safety!

Parameters

[in]	curveStartPointTangent	Start point tangent track.
[in]	curveEndPointTangent	End point tangent track.
[in]	trialPoint	Trial point.
[out]	intersectPointTangent	Intersection point tangent track.
[out]	recalculatedEndPoint	Flagging if end point was recomputed.
[in,out]	fPreviousSafety	Previous safety distance.
[in,out]	fPreviousSftOrigin	Previous safety point origin.

Returns

Whether intersection exists or not.

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 179 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

Additional inline Get/Set methods for parameters, dependent objects.

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

Returns the surface normal of the Intersecting Solid in global coordinates.

Note

This method is costlier then GetSurfaceNormal().

Parameters

[in]	CurrentInt_Point	Current point.
[in,out]	validNormal	Flagging if normal is a valid vector.

Returns

The surface normal vector in global coordinates.

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

Returns the surface normal. Position must be the intersection point from last call to G4Navigator's ComputeStep() (via IntersectChord). It tries to use cached (last) value in Navigator for speed, if it was kept and valid. The value returned is in global coordinates.

Note

It does NOT guarantee to obtain Normal. This can happen e.g. if the "Intersection" Point is not on a surface, potentially due to either inaccuracies in the transformations used, or issues with the Solid.

Parameters

[in]	CurrentInt_Point	Current point.
[in,out]	validNormal	Flagging if normal is a valid vector.

Returns

The surface normal vector in local coordinates.

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

Intersects the chord from StartPointA to EndPointB and returns whether an intersection occurred.

Note

Changes the safety!

Parameters

[in]	StartPointA	Chord starting point.
[in]	EndPointB	Chord end point.
[out]	NewSafety	New calculated safety distance.
[in,out]	PreviousSafety	Previous safety distance.
[in,out]	PreviousSftOrigin	Previous safety point origin.
[out]	LinearStepLength	Linear chord length.
[out]	IntersectionPoint	Intersection point.
[in,out]	calledNavigator	Pointer to flag indicating if the navigator has been called or not.

Returns

Whether intersection exists or not.

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

LocateGlobalPointWithinVolumeAndCheck()

G4bool G4VIntersectionLocator::LocateGlobalPointWithinVolumeAndCheck ( const G4ThreeVector & pos )

protected

Locates a point using the navigator and updates the state of Navigator. By default, it assumes that the point is inside the current volume, and returns true. In check mode, it checks whether the point is inside the volume. If it is inside, it returns true. If not, issues a warning and returns false.

Parameters

[in]

pos

The point to locate.

Returns

If a point is inside the volume or not.

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

Locates a point using the navigator and updates the state of Navigator, but report information about code location. If CheckMode > 1, report extra information.

Parameters

[in]	pos	The point to locate.
[in]	CodeLocationInfo	String for code location info.
[in]	CheckMode	Not used.

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 )

Dumps status of propagator to cout, useful mostly for debugging.

Definition at line 76 of file G4VIntersectionLocator.cc.

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

printStatus() [2/2]

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

static

Dumps status of propagator to any ostream.

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; 
  }
}

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

ReEstimateEndpoint()

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

protected

Returns new estimate for state after curveDist starting from CurrentStateA, to replace EstimtdEndStateB, and reports displacement (if field is compiled verbose).

Parameters

[in]	CurrentStateA	Start point tangent track.
[in]	EstimtdEndStateB	Estimated end point tangent track.
[in]	linearDistSq	Not used.
[in]	curveDist	Not used.

Returns

New estimate for state.

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

Report case: trial point is 'close' to start, within tolerance.

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

Reports the current status / progress in finding the first intersection.

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

Builds error message (in ossMsg) to report that point 'B' has gone past 'A'.

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

Prints a three-line report on the current "sub-step", i.e. trial intersection.

Parameters

[in]	step_no	Step number.
[in]	ChordAB_v	AB chord.
[in]	ChordEF_v	EF chord.
[in]	NewMomentumDir	Momentum direction.
[in]	NormalAtEntry	Normal vector at entry.
[in]	validNormal	Validity flag for normal vector at E.

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

Sets/gets check mode. When enabled, uses additional verifications and stricter condictions for ensuring correctness. Effective only when G4VERBOSE is enabled.

Definition at line 178 of file G4VIntersectionLocator.hh.

{ fCheckMode = value; }

Referenced by LocateGlobalPointWithinVolumeCheckAndReport().

SetChordFinderFor()

void G4VIntersectionLocator::SetChordFinderFor ( G4ChordFinder * fCFinder )

inline

SetDeltaIntersectionFor()

void G4VIntersectionLocator::SetDeltaIntersectionFor ( G4double deltaIntersection )

inline

SetEpsilonStepFor()

void G4VIntersectionLocator::SetEpsilonStepFor ( G4double EpsilonStep )

inline

Setters for parameters which must be set at each step, in case they are changed.

Note

This simple approach ensures that all scenarios are considered. Future refinement may identify which are invariant during a track, run or event.

SetNavigatorFor()

void G4VIntersectionLocator::SetNavigatorFor ( G4Navigator * fNavigator )

inline

SetSafetyParametersFor()

void G4VIntersectionLocator::SetSafetyParametersFor ( G4bool UseSafety )

inline

SetVerboseFor()

void G4VIntersectionLocator::SetVerboseFor ( G4int fVerbose )

inline

Verbosity control. Controlling verbosity enables checking of the locating of intersections.

Member Data Documentation

fCheckMode

G4bool G4VIntersectionLocator::fCheckMode = false

protected

Definition at line 364 of file G4VIntersectionLocator.hh.

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

fHelpingNavigator

G4Navigator* G4VIntersectionLocator::fHelpingNavigator

protected

Helper for location.

Definition at line 377 of file G4VIntersectionLocator.hh.

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

fiChordFinder

G4ChordFinder* G4VIntersectionLocator::fiChordFinder = nullptr

protected

Parameters set at each physical step by G4PropagatorInField.

Definition at line 372 of file G4VIntersectionLocator.hh.

fiDeltaIntersection

G4double G4VIntersectionLocator::fiDeltaIntersection = -1.0

protected

Definition at line 374 of file G4VIntersectionLocator.hh.

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

fiEpsilonStep

G4double G4VIntersectionLocator::fiEpsilonStep = -1.0

protected

Definition at line 373 of file G4VIntersectionLocator.hh.

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

fiNavigator

G4Navigator* G4VIntersectionLocator::fiNavigator

protected

Definition at line 367 of file G4VIntersectionLocator.hh.

Referenced by G4VIntersectionLocator().

fiUseSafety

G4bool G4VIntersectionLocator::fiUseSafety = false

protected

Definition at line 365 of file G4VIntersectionLocator.hh.

fpTouchable

G4TouchableHistory* G4VIntersectionLocator::fpTouchable = nullptr

protected

Touchable history hook.

Definition at line 380 of file G4VIntersectionLocator.hh.

Referenced by ~G4VIntersectionLocator().

fUseNormalCorrection

G4bool G4VIntersectionLocator::fUseNormalCorrection = false

protected

Definition at line 363 of file G4VIntersectionLocator.hh.

Referenced by AreIntersectionsAdjusted().

fVerboseLevel

G4int G4VIntersectionLocator::fVerboseLevel = 0

protected

Definition at line 362 of file G4VIntersectionLocator.hh.

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

kCarTolerance

G4double G4VIntersectionLocator::kCarTolerance

protected

Definition at line 360 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