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 step)
G4bool	IntersectChord (const G4ThreeVector &StartPointA, const G4ThreeVector &EndPointB, G4double &NewSafety, G4double &PreviousSafety, G4ThreeVector &PreviousSftOrigin, G4double &LinearStepLength, G4ThreeVector &IntersectionPoint, G4bool *calledNavigator=0)
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 ()

Protected Member Functions
G4FieldTrack	ReEstimateEndpoint (const G4FieldTrack &CurrentStateA, const G4FieldTrack &EstimtdEndStateB, G4double linearDistSq, G4double curveDist)
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)

Protected Attributes
G4double	kCarTolerance
G4int	fVerboseLevel
G4bool	fUseNormalCorrection
G4Navigator *	fiNavigator
G4ChordFinder *	fiChordFinder
G4double	fiEpsilonStep
G4double	fiDeltaIntersection
G4bool	fiUseSafety
G4Navigator *	fHelpingNavigator
G4TouchableHistory *	fpTouchable

Detailed Description

Definition at line 56 of file G4VIntersectionLocator.hh.

Constructor & Destructor Documentation

G4VIntersectionLocator::G4VIntersectionLocator

(

G4Navigator *

theNavigator

)

Definition at line 46 of file G4VIntersectionLocator.cc.

References fHelpingNavigator, fVerboseLevel, G4GeometryTolerance::GetInstance(), G4GeometryTolerance::GetSurfaceTolerance(), and kCarTolerance.

                                                                        : 
  fUseNormalCorrection(false), 
  fiNavigator( theNavigator ),
  fiChordFinder( 0 ),            // Not set - overridden at each step
  fiEpsilonStep( -1.0 ),         // Out of range - overridden at each step
  fiDeltaIntersection( -1.0 ),   // Out of range - overridden at each step
  fiUseSafety(false),            // Default - overridden at each step
  fpTouchable(0)           
{
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
  fVerboseLevel = 0;
  fHelpingNavigator = new G4Navigator();
}      

G4VIntersectionLocator::~G4VIntersectionLocator ( )

virtual

Definition at line 64 of file G4VIntersectionLocator.cc.

References fHelpingNavigator, and fpTouchable.

{
  delete fHelpingNavigator;
  delete fpTouchable;
}

Member Function Documentation

void G4VIntersectionLocator::AddAdjustementOfFoundIntersection ( G4bool  UseCorrection )

inline

void G4VIntersectionLocator::AdjustIntersections ( G4bool  UseCorrection )

inline

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 348 of file G4VIntersectionLocator.cc.

References CLHEP::Hep3Vector::dot(), fVerboseLevel, G4cerr, G4endl, GetGlobalSurfaceNormal(), GetNavigatorFor(), IntersectChord(), kCarTolerance, G4InuclParticleNames::lambda, and G4Navigator::LocateGlobalPointWithinVolume().

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

{     
  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 )
    {
      G4cerr << "WARNING - "
             << "G4VIntersectionLocator::AdjustementOfFoundIntersection()"
             << G4endl
             << "        No intersection. Parallels lines!" << G4endl;
    }
#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;
}

G4bool G4VIntersectionLocator::AreIntersectionsAdjusted ( )

inline

Definition at line 125 of file G4VIntersectionLocator.hh.

References fUseNormalCorrection.

{ return fUseNormalCorrection; }  

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 G4SimpleLocator, G4MultiLevelLocator, and G4BrentLocator.

G4bool G4VIntersectionLocator::GetAdjustementOfFoundIntersection ( )

inline

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

G4ChordFinder* G4VIntersectionLocator::GetChordFinderFor ( )

inline

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

G4double G4VIntersectionLocator::GetDeltaIntersectionFor ( )

inline

Referenced by G4BrentLocator::EstimateIntersectionPoint().

G4double G4VIntersectionLocator::GetEpsilonStepFor ( )

inline

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

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

protected

Definition at line 467 of file G4VIntersectionLocator.cc.

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

Referenced by AdjustmentOfFoundIntersection().

{
  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 << "**************************************************************"
            << G4endl;
    G4Exception("G4VIntersectionLocator::GetGlobalSurfaceNormal()",
                "GeomNav1002", JustWarning, message);
  }
#endif

  return globalNormal;
}

G4Navigator* G4VIntersectionLocator::GetNavigatorFor ( )

inline

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

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

protected

Definition at line 424 of file G4VIntersectionLocator.cc.

References G4endl, G4Exception(), JustWarning, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), and python.hepunit::perThousand.

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

{
  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 << "G4VIntersectionLocator::GetSurfaceNormal -- identified problem."
            << G4endl;
    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." << G4endl; 
    G4Exception("G4VIntersectionLocator::GetGlobalSurfaceNormal()",
                "GeomNav1002", JustWarning, message);
  }
#endif

  if( validNormalLast ) 
  {
    NormalAtEntry=NormalAtEntryLast;  
  }
  validNormal  = validNormalLast;

  return NormalAtEntry;
}

G4int G4VIntersectionLocator::GetVerboseFor ( )

inline

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

inline

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

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

Definition at line 75 of file G4VIntersectionLocator.cc.

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

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

{
  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 = G4cout.precision(4);
    G4cout << std::setw( 6)  << " " 
           << std::setw( 25) << " Current Position  and  Direction" << " "
           << G4endl; 
    G4cout << 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 " << " " ;
    G4cout << std::setw( 7) << " Delta|N|" << " "
           << std::setw( 9) << "StepLen" << " "  
           << std::setw(12) << "StartSafety" << " "  
           << std::setw( 9) << "PhsStep" << " ";  
    G4cout << G4endl;
    G4cout.precision(oldprc);
  }
  if((stepNo == 0) && (verboseLevel <=3))
  {
    // Recurse to print the start values
    //
    printStatus( StartFT, StartFT, -1.0, safety, -1);
  }
  if( verboseLevel <= 3 )
  {
    if( stepNo >= 0)
    {
       G4cout << std::setw( 4) << stepNo << " ";
    }
    else
    {
       G4cout << std::setw( 5) << "Start" ;
    }
    oldprc = G4cout.precision(8);
    G4cout << std::setw(10) << CurrentFT.GetCurveLength() << " "; 
    G4cout << std::setw(10) << CurrentPosition.x() << " "
           << std::setw(10) << CurrentPosition.y() << " "
           << std::setw(10) << CurrentPosition.z() << " ";
    G4cout.precision(4);
    G4cout << std::setw( 7) << CurrentUnitVelocity.x() << " "
           << std::setw( 7) << CurrentUnitVelocity.y() << " "
           << std::setw( 7) << CurrentUnitVelocity.z() << " ";
    G4cout.precision(3); 
    G4cout << std::setw( 7)
           << CurrentFT.GetMomentum().mag()- StartFT.GetMomentum().mag()
           << " "; 
    G4cout << std::setw( 9) << step_len << " "; 
    G4cout << std::setw(12) << safety << " ";
    if( requestStep != -1.0 )
    {
      G4cout << std::setw( 9) << requestStep << " ";
    }
    else
    {
      G4cout << std::setw( 9) << "Init/NotKnown" << " "; 
    }
    G4cout << G4endl;
    G4cout.precision(oldprc);
  }
  else // if( verboseLevel > 3 )
  {
    //  Multi-line output
       
    G4cout << "Step taken was " << step_len  
           << " out of PhysicalStep= " <<  requestStep << G4endl;
    G4cout << "Final safety is: " << safety << G4endl;
    G4cout << "Chord length = " << (CurrentPosition-StartPosition).mag()
           << G4endl;
    G4cout << G4endl; 
  }
}

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

protected

Definition at line 171 of file G4VIntersectionLocator.cc.

References G4MagInt_Driver::AccurateAdvance(), fVerboseLevel, G4cerr, G4cout, G4endl, G4ThreadLocal, GetChordFinderFor(), G4FieldTrack::GetCurveLength(), GetEpsilonStepFor(), G4ChordFinder::GetIntegrationDriver(), G4FieldTrack::GetPosition(), and kCarTolerance.

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

{  
  G4FieldTrack newEndPoint( CurrentStateA );
  G4MagInt_Driver* integrDriver= GetChordFinderFor()->GetIntegrationDriver(); 

  G4FieldTrack retEndPoint( CurrentStateA );
  G4bool goodAdvance;
  G4int  itrial=0;
  const G4int no_trials= 20;

  G4double endCurveLen= EstimatedEndStateB.GetCurveLength();
  do
  {
     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!
  // 
  static 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;
    }
  }

  static G4int noInaccuracyWarnings = 0; 
  G4int maxNoWarnings = 10;
  if (  (noInaccuracyWarnings < maxNoWarnings ) 
       || (fVerboseLevel > 1) )
    {
      G4cerr << "G4PropagatorInField::LocateIntersectionPoint():"
             << G4endl
             << " Warning: Integration inaccuracy requires" 
             <<   " an adjustment in the step's endpoint."  << G4endl
             << "   Two mid-points are further apart than their"
             <<   " curve length difference"                << G4endl 
             << "   Dist = "       << std::sqrt(linearDistSq)
             << " curve length = " << curveDist             << G4endl; 
      G4cerr << " Correction applied is " 
             << (newEndPoint.GetPosition()-EstimatedEndStateB.GetPosition()).mag()
             << G4endl;
    }
#else
  // Statistics on the RMS value of the corrections

  static G4ThreadLocal G4int    noCorrections=0;
  static G4ThreadLocal G4double sumCorrectionsSq = 0;
  noCorrections++; 
  if( goodAdvance )
  {
    sumCorrectionsSq += (EstimatedEndStateB.GetPosition() - 
                         newEndPoint.GetPosition()).mag2();
  }
  linearDistSq -= curveDist; // To use linearDistSq ... !
#endif

  return retEndPoint;
}

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 516 of file G4VIntersectionLocator.cc.

References CLHEP::Hep3Vector::dot(), G4cerr, G4cout, G4endl, CLHEP::Hep3Vector::mag(), CLHEP::Hep3Vector::mag2(), and python.hepunit::perThousand.

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

{
  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 // G4cout 
    << 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  // G4cout 
    << " " << 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  // G4cout
    << " MomentumDir= " << " " << NewMomentumDir 
    << " Normal at Entry E= " << NormalAtEntry
    << " AB chord =   " << ChordAB_v
    << G4endl;
  G4cout << outStream.str();  // ostr_verbose;

  if( ( std::fabs(NormalAtEntry.mag2() - 1.0) > perThousand ) ) 
  {
    G4cerr << " PROBLEM in G4VIntersectionLocator::ReportTrialStep " << G4endl
           << "         Normal is not unit - mag=" <<  NormalAtEntry.mag() 
           << "         ValidNormalAtE = " << validNormal
           << G4endl; 
  }
  return; 
}

void G4VIntersectionLocator::SetChordFinderFor ( G4ChordFinder *  fCFinder )

inline

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

void G4VIntersectionLocator::SetDeltaIntersectionFor ( G4double  deltaIntersection )

inline

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

void G4VIntersectionLocator::SetEpsilonStepFor ( G4double  EpsilonStep )

inline

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

void G4VIntersectionLocator::SetNavigatorFor ( G4Navigator *  fNavigator )

inline

void G4VIntersectionLocator::SetSafetyParametersFor ( G4bool  UseSafety )

inline

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

void G4VIntersectionLocator::SetVerboseFor ( G4int  fVerbose )

inline

Field Documentation

G4Navigator* G4VIntersectionLocator::fHelpingNavigator

protected

Definition at line 203 of file G4VIntersectionLocator.hh.

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

G4ChordFinder* G4VIntersectionLocator::fiChordFinder

protected

Definition at line 196 of file G4VIntersectionLocator.hh.

G4double G4VIntersectionLocator::fiDeltaIntersection

protected

Definition at line 198 of file G4VIntersectionLocator.hh.

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

G4double G4VIntersectionLocator::fiEpsilonStep

protected

Definition at line 197 of file G4VIntersectionLocator.hh.

G4Navigator* G4VIntersectionLocator::fiNavigator

protected

Definition at line 194 of file G4VIntersectionLocator.hh.

G4bool G4VIntersectionLocator::fiUseSafety

protected

Definition at line 199 of file G4VIntersectionLocator.hh.

G4TouchableHistory* G4VIntersectionLocator::fpTouchable

protected

Definition at line 206 of file G4VIntersectionLocator.hh.

Referenced by ~G4VIntersectionLocator().

G4bool G4VIntersectionLocator::fUseNormalCorrection

protected

Definition at line 192 of file G4VIntersectionLocator.hh.

Referenced by AreIntersectionsAdjusted().

G4int G4VIntersectionLocator::fVerboseLevel

protected

Definition at line 191 of file G4VIntersectionLocator.hh.

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

G4double G4VIntersectionLocator::kCarTolerance

protected

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