G4ChordFinder Class Reference

G4ChordFinder is a class that provides Runge-Kutta integration of motion ODE and also has a method that returns an approximate point on the curve near to a (chord) point. More...

#include <G4ChordFinder.hh>

Public Types
enum	kIntegrationType {   kDefaultDriverType =0 , kFSALStepperType =1 , kTemplatedStepperType , kRegularStepperType ,   kBfieldDriverType , kQss2DriverType , kQss3DriverType }

Public Member Functions
	G4ChordFinder (G4VIntegrationDriver *pIntegrationDriver)
	G4ChordFinder (G4MagneticField *itsMagField, G4double stepMinimum=G4FieldDefaults::kMinimumStep, G4MagIntegratorStepper *pItsStepper=nullptr, G4int stepperDriverChoice=kTemplatedStepperType)
	~G4ChordFinder ()
	G4ChordFinder (const G4ChordFinder &)=delete
G4ChordFinder &	operator= (const G4ChordFinder &)=delete
G4double	AdvanceChordLimited (G4FieldTrack &yCurrent, G4double stepInitial, G4double epsStep_Relative, const G4ThreeVector &latestSafetyOrigin, G4double lasestSafetyRadius)
G4FieldTrack	ApproxCurvePointS (const G4FieldTrack &curveAPointVelocity, const G4FieldTrack &curveBPointVelocity, const G4FieldTrack &ApproxCurveV, const G4ThreeVector &currentEPoint, const G4ThreeVector &currentFPoint, const G4ThreeVector &PointG, G4bool first, G4double epsStep)
G4FieldTrack	ApproxCurvePointV (const G4FieldTrack &curveAPointVelocity, const G4FieldTrack &curveBPointVelocity, const G4ThreeVector &currentEPoint, G4double epsStep)
G4double	InvParabolic (const G4double xa, const G4double ya, const G4double xb, const G4double yb, const G4double xc, const G4double yc)
G4double	GetDeltaChord () const
void	SetDeltaChord (G4double newval)
void	SetIntegrationDriver (G4VIntegrationDriver *IntegrationDriver)
G4VIntegrationDriver *	GetIntegrationDriver ()
void	ResetStepEstimate ()
G4int	SetVerbose (G4int newvalue=1)
void	OnComputeStep (const G4FieldTrack *track)

Static Public Member Functions
static void	SetVerboseConstruction (G4bool v=true)

Friends
std::ostream &	operator<< (std::ostream &os, const G4ChordFinder &cf)

Detailed Description

G4ChordFinder is a class that provides Runge-Kutta integration of motion ODE and also has a method that returns an approximate point on the curve near to a (chord) point.

Definition at line 58 of file G4ChordFinder.hh.

Member Enumeration Documentation

kIntegrationType

enum G4ChordFinder::kIntegrationType

Enumerator
kDefaultDriverType
kFSALStepperType
kTemplatedStepperType
kRegularStepperType
kBfieldDriverType
kQss2DriverType
kQss3DriverType

Definition at line 62 of file G4ChordFinder.hh.

                          {kDefaultDriverType=0, kFSALStepperType=1, 
                           kTemplatedStepperType, kRegularStepperType,
                           kBfieldDriverType, kQss2DriverType, kQss3DriverType};

Constructor & Destructor Documentation

G4ChordFinder() [1/3]

G4ChordFinder::G4ChordFinder ( G4VIntegrationDriver * pIntegrationDriver )

explicit

The most flexible constructor, which allows the user to specify any type of field, equation, stepper and integration driver.

Parameters

[in]

pIntegrationDriver

Pointer to the integrator driver to use.

Definition at line 78 of file G4ChordFinder.cc.

  : fIntgrDriver(pIntegrationDriver)
{
  // Simple constructor -- it does not create equation
 
  if( gVerboseCtor )
  {
    G4cout << "G4ChordFinder: Simple constructor -- it uses pre-existing driver." << G4endl;
  }
   
  fDeltaChord = fDefaultDeltaChord;       // Parameters
}

Referenced by G4ChordFinder(), OnComputeStep(), operator<<, and operator=().

G4ChordFinder() [2/3]

G4ChordFinder::G4ChordFinder	(	G4MagneticField *	itsMagField,
		G4double	stepMinimum = G4FieldDefaults::kMinimumStep,
		G4MagIntegratorStepper *	pItsStepper = nullptr,
		G4int	stepperDriverChoice = kTemplatedStepperType )

Constructor that creates defaults for all "children" classes. The type of equation of motion is fixed. A default type of stepper (Dormand Prince since release 10.4) is used, and the corresponding integration driver.

Parameters

[in]	itsMagField	Pointer to the magnetic field.
[in]	stepMinimum	Pointer to the magnetic field.
[in]	pItsStepper	Optional pointer to the stepper algorithm.
[in]	stepperDriverChoice	Type of stepper driver.

Definition at line 93 of file G4ChordFinder.cc.

{
  // Construct the Chord Finder
  // by creating in inverse order the Driver, the Stepper and EqRhs ...
  constexpr G4int nVar6 = 6;   // Components integrated in Usual Equation of motion
  
  fDeltaChord = fDefaultDeltaChord;       // Parameters
 
  G4cout << " G4ChordFinder: stepperDriverId: " << stepperDriverId  << G4endl;
 
  G4bool useFSALstepper     = (stepperDriverId == kFSALStepperType);       // Was 1
  G4bool useTemplatedStepper= (stepperDriverId == kTemplatedStepperType);  // Was 2 
  G4bool useRegularStepper  = (stepperDriverId == kRegularStepperType);    // Was 3
  G4bool useBfieldDriver    = (stepperDriverId == kBfieldDriverType);      // Was 4 
  G4bool useG4QSSDriver     = (stepperDriverId == kQss2DriverType) 
                           || (stepperDriverId == kQss3DriverType);
 
  if( stepperDriverId == kQss3DriverType )
  {
    G4QSSMessenger::instance()->SetQssOrder(3);
  }
 
  using EquationType = G4Mag_UsualEqRhs;
  
  using TemplatedStepperType =
         G4TDormandPrince45<EquationType,nVar6>; // 5th order embedded method. High efficiency.
  const char* TemplatedStepperName = 
      "G4TDormandPrince745 (templated Dormand-Prince45, aka DoPri5): 5th/4th Order 7-stage embedded";
  
  using RegularStepperType =
         G4DormandPrince745; // 5th order embedded method. High efficiency.     
         // G4ClassicalRK4;        // The old default
         // G4CashKarpRKF45;       // First embedded method in G4
         // G4BogackiShampine45;   // High efficiency 5th order embedded method
         // G4NystromRK4;          // Nystrom stepper 4th order 
         // G4RK547FEq1;  // or 2 or 3 
  const char* RegularStepperName = 
      "G4DormandPrince745 (aka DOPRI5): 5th/4th Order 7-stage embedded";
      // "BogackiShampine 45 (Embedded 5th/4th Order, 7-stage)";
      // "Nystrom stepper 4th order";
 
  using NewFsalStepperType = G4DormandPrince745; // Now works -- 2020.10.08
                                                 //  Was G4RK547FEq1; // or 2 or 3
  const char* NewFSALStepperName =
      "G4RK574FEq1> FSAL 4th/5th order 7-stage 'Equilibrium-type' #1.";
  
#ifdef G4DEBUG_FIELD
  static G4bool verboseDebug = true;
  if( verboseDebug )
  {
     G4cout << "G4ChordFinder 2nd Constructor called. " << G4endl;
     G4cout << " Arguments: " << G4endl
            << " - min step = " << stepMinimum << G4endl
            << " - stepper ptr provided : "
            << ( pItsStepper==nullptr ? " no  " : " yes " ) << G4endl;
     if( pItsStepper==nullptr )
     {
        G4cout << " - stepper/driver Id = " << stepperDriverId << " i.e. "
               << "  useFSAL = " << useFSALstepper
               << "  , useTemplated = " << useTemplatedStepper
               << "  , useRegular = " << useRegularStepper
               << "  , useFSAL = " << useFSALstepper        
               << G4endl;
     }
  }
#endif
 
  // useHigherStepper = forceHigherEffiencyStepper || useHigherStepper;
 
  auto  pEquation = new G4Mag_UsualEqRhs(theMagField);
  fEquation = pEquation;                            
 
  // G4MagIntegratorStepper* regularStepper = nullptr;
  // G4VFSALIntegrationStepper* fsalStepper = nullptr; // for FSAL steppers only
  // G4MagIntegratorStepper* oldFSALStepper = nullptr;
 
  G4bool errorInStepperCreation = false;
 
  std::ostringstream message;  // In case of failure, load with description !
 
  if( pItsStepper != nullptr )
  {
     if( gVerboseCtor )
     {
       G4cout << " G4ChordFinder: Creating G4IntegrationDriver<G4MagIntegratorStepper> with "
              << " stepMinimum = " << stepMinimum
              << " numVar= " << pItsStepper->GetNumberOfVariables() << G4endl;
     }
 
     // Stepper type is not known - so must use base class G4MagIntegratorStepper
      if(pItsStepper->isQSS())
      {
         // fIntgrDriver = pItsStepper->build_driver(stepMinimum, true);
         G4Exception("G4ChordFinder::G4ChordFinder()",
                      "GeomField1001", FatalException,
                      "Cannot provide  QSS stepper in constructor. User c-tor with Driver instead.");
      }
      else
      {
         fIntgrDriver = new G4IntegrationDriver<G4MagIntegratorStepper>( stepMinimum,
                                  pItsStepper, pItsStepper->GetNumberOfVariables() );
         // Stepper type is not known - so must use base class G4MagIntegratorStepper      
         // Non-interpolating driver used by default.
         // WAS:  fIntgrDriver = pItsStepper->build_driver(stepMinimum);  // QSS introduction -- axed
      }
     // -- Older:
     // G4cout << " G4ChordFinder: Creating G4MagInt_Driver with " ...
     // Type is not known - so must use old class     
     // fIntgrDriver = new G4MagInt_Driver( stepMinimum, pItsStepper,
     //                                 pItsStepper->GetNumberOfVariables());
  }
  else if ( useTemplatedStepper )
  {
     if( gVerboseCtor )
     {
        G4cout << " G4ChordFinder: Creating Templated Stepper of type> "
               << TemplatedStepperName << G4endl;
     }
     // RegularStepperType* regularStepper = nullptr; // To check the exception
     auto templatedStepper = new TemplatedStepperType(pEquation);
     //                    *** ******************
     //
     // Alternative - for G4NystromRK4:
     // = new G4NystromRK4(pEquation, 0.1*mm );
     fRegularStepperOwned = templatedStepper;
     if( templatedStepper == nullptr )
     {
        message << "Templated Stepper instantiation FAILED." << G4endl;        
        message << "G4ChordFinder: Attempted to instantiate "
                << TemplatedStepperName << " type stepper " << G4endl;
        errorInStepperCreation = true;
     }
     else
     {
        fIntgrDriver = new G4IntegrationDriver<TemplatedStepperType>(
           stepMinimum, templatedStepper, nVar6 );
        if( gVerboseCtor )
        {
           G4cout << " G4ChordFinder: Using G4IntegrationDriver. " << G4endl;
        }
     }
     
  }
  else if ( useRegularStepper   )  // Plain stepper -- not double ...
  {
     auto regularStepper = new RegularStepperType(pEquation);
     //                    *** ******************     
     fRegularStepperOwned = regularStepper;
 
     if( gVerboseCtor )
     {
        G4cout << " G4ChordFinder: Creating Driver for regular stepper.";
     }
     
     if( regularStepper == nullptr )
     {
        message << "Regular Stepper instantiation FAILED." << G4endl;        
        message << "G4ChordFinder: Attempted to instantiate "
                << RegularStepperName << " type stepper " << G4endl;
        errorInStepperCreation = true;
     }
     else
     {
        auto dp5= dynamic_cast<G4DormandPrince745*>(regularStepper);
        if( dp5 != nullptr )
        {
           fIntgrDriver = new G4InterpolationDriver<G4DormandPrince745>(
                                  stepMinimum, dp5, nVar6 );           
           if( gVerboseCtor )
           {
              G4cout << " Using InterpolationDriver<DoPri5> " << G4endl;
           }
        }
        else
        {
           fIntgrDriver = new G4IntegrationDriver<RegularStepperType>(
                                  stepMinimum, regularStepper, nVar6 );
           if( gVerboseCtor )
           {
              G4cout << " Using IntegrationDriver<DoPri5> " << G4endl;
           }
        }
     }
  }
  else if ( useBfieldDriver )
  {
     auto regularStepper = new G4DormandPrince745(pEquation);
     //                    *** ******************
     //
     fRegularStepperOwned = regularStepper;
     
     {        
        using SmallStepDriver = G4InterpolationDriver<G4DormandPrince745>;
        using LargeStepDriver = G4IntegrationDriver<G4HelixHeum>;
 
        fLongStepper = std::make_unique<G4HelixHeum>(pEquation);
        
        fIntgrDriver = new G4BFieldIntegrationDriver(
          std::make_unique<SmallStepDriver>(stepMinimum,
              regularStepper, regularStepper->GetNumberOfVariables()),
          std::make_unique<LargeStepDriver>(stepMinimum,
              fLongStepper.get(), regularStepper->GetNumberOfVariables()) );
        
        if( fIntgrDriver == nullptr)
        {        
           message << "Using G4BFieldIntegrationDriver with "
                   << RegularStepperName << " type stepper " << G4endl;
           message << "Driver instantiation FAILED." << G4endl;
           G4Exception("G4ChordFinder::G4ChordFinder()",
                       "GeomField1001", JustWarning, message);
        }
     }
  }
  else if( useG4QSSDriver )
  {
     G4int qssOrder= -1;
     if ((stepperDriverId == kQss2DriverType) || (stepperDriverId == kQss3DriverType))
     {
        qssOrder= (stepperDriverId == kQss2DriverType) ? 2 : 3;
        G4QSSMessenger::instance()->SetQssOrder(qssOrder);
     }
     // Else we will use the default value, which can be steered interactively
 
     fQssStepperOwned= new G4QSStepper(pEquation, 6);
     auto qss_driver = new G4QSSDriver<G4QSStepper>(fQssStepperOwned);
     fIntgrDriver = qss_driver;
 
     if( gVerboseCtor )
     {
        G4cout << "-- Created QSS-" << G4QSSMessenger::instance()->GetQssOrder() << " stepper" << G4endl;
        G4cout << "-- G4ChordFinder: Using QSS Driver." << G4endl;
     }
  }
  else
  {
     auto fsalStepper=  new NewFsalStepperType(pEquation);
     //                 *** ******************
     fNewFSALStepperOwned = fsalStepper;
 
     if( fsalStepper == nullptr )
     {
        message << "Stepper instantiation FAILED." << G4endl;        
        message << "Attempted to instantiate "
                << NewFSALStepperName << " type stepper " << G4endl;
        G4Exception("G4ChordFinder::G4ChordFinder()",
                    "GeomField1001", JustWarning, message);
        errorInStepperCreation = true;
     }
     else
     {
        fIntgrDriver = new
           G4FSALIntegrationDriver<NewFsalStepperType>(stepMinimum, fsalStepper,
                                          fsalStepper->GetNumberOfVariables() );
           //  ====  Create the driver which knows the class type
        
        if( fIntgrDriver == nullptr )
        {
           message << "Using G4FSALIntegrationDriver with stepper type: "
                   << NewFSALStepperName << G4endl;
           message << "Integration Driver instantiation FAILED." << G4endl;
           G4Exception("G4ChordFinder::G4ChordFinder()",
                       "GeomField1001", JustWarning, message);
        }
     }
  }
 
  // -- Main work is now done
  
  //    Now check that no error occured, and report it if one did.
  
  // To test failure to create driver
  // delete fIntgrDriver;
  // fIntgrDriver = nullptr;
 
  // Detect and report Error conditions
  //
  if( errorInStepperCreation || (fIntgrDriver == nullptr ))
  {
     std::ostringstream errmsg;
     
     if( errorInStepperCreation )
     {
        errmsg  << "ERROR> Failure to create Stepper object." << G4endl
                << "       --------------------------------" << G4endl;
     }
     if (fIntgrDriver == nullptr )
     {
        errmsg  << "ERROR> Failure to create Integration-Driver object."
                << G4endl
                << "       -------------------------------------------"
                << G4endl;
     }
     const std::string BoolName[2]= { "False", "True" }; 
     errmsg << "  Configuration:  (constructor arguments) " << G4endl        
            << "    provided Stepper = " << pItsStepper << G4endl
            << " stepper/driver Id = " << stepperDriverId << " i.e. "
            << "   useTemplated = " << BoolName[useTemplatedStepper]
            << "   useRegular = " << BoolName[useRegularStepper]
            << "   useFSAL = " << BoolName[useFSALstepper]
            << "   using combo BField Driver = " <<
                   BoolName[ ! (useFSALstepper||useTemplatedStepper
                               || useRegularStepper ) ] 
            << G4endl;
     errmsg << message.str(); 
     errmsg << "Aborting.";
     G4Exception("G4ChordFinder::G4ChordFinder() - constructor 2",
                 "GeomField0003", FatalException, errmsg);     
  }
 
  assert(    ( pItsStepper != nullptr ) 
          || ( fRegularStepperOwned != nullptr )
          || ( fNewFSALStepperOwned != nullptr )
          || useG4QSSDriver
     );
  assert( fIntgrDriver != nullptr );
}

~G4ChordFinder()

G4ChordFinder::~G4ChordFinder

(

)

Destructor.

Definition at line 415 of file G4ChordFinder.cc.

{
  delete fEquation;
  delete fRegularStepperOwned;
  delete fNewFSALStepperOwned;
  delete fQssStepperOwned;
  delete fCachedField;
  delete fIntgrDriver;
}

G4ChordFinder() [3/3]

G4ChordFinder::G4ChordFinder ( const G4ChordFinder & )

delete

Copy constructor and assignment operator not allowed.

Member Function Documentation

AdvanceChordLimited()

G4double G4ChordFinder::AdvanceChordLimited ( G4FieldTrack & yCurrent, G4double stepInitial, G4double epsStep_Relative, const G4ThreeVector & latestSafetyOrigin, G4double lasestSafetyRadius )

inline

Computes the step to take, based on chord limits. Uses ODE solver's driver to find the endpoint that satisfies the chord criterion that: d_chord < delta_chord.

Parameters

[in,out]	yCurrent	The current track in field.
[in]	stepInitial	Proposed initial step length.
[in]	epsStep_Relative	Requested accuracy.
[in]	latestSafetyOrigin	Last safety origin point. Unused.
[in]	lasestSafetyRadius	Last safety distance. Unused.

Returns

The length of step taken.

Referenced by G4PropagatorInField::ComputeStep().

ApproxCurvePointS()

G4FieldTrack G4ChordFinder::ApproxCurvePointS	(	const G4FieldTrack &	curveAPointVelocity,
		const G4FieldTrack &	curveBPointVelocity,
		const G4FieldTrack &	ApproxCurveV,
		const G4ThreeVector &	currentEPoint,
		const G4ThreeVector &	currentFPoint,
		const G4ThreeVector &	PointG,
		G4bool	first,
		G4double	epsStep )

Uses the Brent algorithm when possible, to determine the closest point on the curve. Given a starting curve point A (CurveA_PointVelocity), curve point B (CurveB_PointVelocity), a point E which is (generally) not on the curve and a point F which is on the curve (first approximation), find new point S on the curve closer to point E. While advancing towards S utilise 'eps_step' as a measure of the relative accuracy of each Step.

Returns

The end point on the curve closer to the given point E.

Definition at line 428 of file G4ChordFinder.cc.

{
  // ApproxCurvePointS is 2nd implementation of ApproxCurvePoint.
  // Use Brent Algorithm (or InvParabolic) when possible.
  // Given a starting curve point A (CurveA_PointVelocity), curve point B
  // (CurveB_PointVelocity), a point E which is (generally) not on the curve
  // and  a point F which is on the curve (first approximation), find new
  // point S on the curve closer to point E. 
  // While advancing towards S utilise 'eps_step' as a measure of the
  // relative accuracy of each Step.
 
  G4FieldTrack EndPoint(CurveA_PointVelocity);
  if(!first) { EndPoint = ApproxCurveV; }
 
  G4ThreeVector Point_A,Point_B;
  Point_A=CurveA_PointVelocity.GetPosition();
  Point_B=CurveB_PointVelocity.GetPosition();
 
  G4double xa,xb,xc,ya,yb,yc;
 
  // InverseParabolic. AF Intersects (First Part of Curve) 
 
  if(first)
  {
    xa=0.;
    ya=(PointG-Point_A).mag();
    xb=(Point_A-CurrentF_Point).mag();
    yb=-(PointG-CurrentF_Point).mag();
    xc=(Point_A-Point_B).mag();
    yc=-(CurrentE_Point-Point_B).mag();
  }    
  else
  {
    xa=0.;
    ya=(Point_A-CurrentE_Point).mag();
    xb=(Point_A-CurrentF_Point).mag();
    yb=(PointG-CurrentF_Point).mag();
    xc=(Point_A-Point_B).mag();
    yc=-(Point_B-PointG).mag();
    if(xb==0.)
    {
      EndPoint = ApproxCurvePointV(CurveA_PointVelocity, CurveB_PointVelocity,
                                   CurrentE_Point, eps_step);
      return EndPoint;
    }
  }
 
  const G4double tolerance = 1.e-12;
  if(std::abs(ya)<=tolerance||std::abs(yc)<=tolerance)
  {
    ; // What to do for the moment: return the same point as at start
      // then PropagatorInField will take care
  }
  else
  {
    G4double test_step = InvParabolic(xa,ya,xb,yb,xc,yc);
    G4double curve;
    if(first)
    {
      curve=std::abs(EndPoint.GetCurveLength()
                    -ApproxCurveV.GetCurveLength());
    }
    else
    {
      test_step = test_step - xb;
      curve=std::abs(EndPoint.GetCurveLength()
                    -CurveB_PointVelocity.GetCurveLength());
      xb = (CurrentF_Point-Point_B).mag();
    }
      
    if(test_step<=0)    { test_step=0.1*xb; }
    if(test_step>=xb)   { test_step=0.5*xb; }
    if(test_step>=curve){ test_step=0.5*curve; } 
 
    if(curve*(1.+eps_step)<xb) // Similar to ReEstimate Step from
    {                          // G4VIntersectionLocator
      test_step=0.5*curve;
    }
 
    fIntgrDriver->AccurateAdvance(EndPoint,test_step, eps_step);
      
#ifdef G4DEBUG_FIELD
    // Printing Brent and Linear Approximation
    //
    G4cout << "G4ChordFinder::ApproxCurvePointS() - test-step ShF = "
           << test_step << "  EndPoint = " << EndPoint << G4endl;
 
    //  Test Track
    //
    G4FieldTrack TestTrack( CurveA_PointVelocity);
    TestTrack = ApproxCurvePointV( CurveA_PointVelocity, 
                                   CurveB_PointVelocity, 
                                   CurrentE_Point, eps_step );
    G4cout.precision(14);
    G4cout << "G4ChordFinder::BrentApprox = " << EndPoint  << G4endl;
    G4cout << "G4ChordFinder::LinearApprox= " << TestTrack << G4endl; 
#endif
  }
  return EndPoint;
}

Referenced by G4BrentLocator::EstimateIntersectionPoint().

ApproxCurvePointV()

G4FieldTrack G4ChordFinder::ApproxCurvePointV	(	const G4FieldTrack &	curveAPointVelocity,
		const G4FieldTrack &	curveBPointVelocity,
		const G4ThreeVector &	currentEPoint,
		G4double	epsStep )

If r=|AE|/|AB|, and s=true path lenght (AB) returns the point that is r*s along the curve.

Definition at line 538 of file G4ChordFinder.cc.

{
  // If r=|AE|/|AB|, and s=true path lenght (AB)
  // return the point that is r*s along the curve!
 
  G4FieldTrack   Current_PointVelocity = CurveA_PointVelocity; 
 
  G4ThreeVector  CurveA_Point= CurveA_PointVelocity.GetPosition();
  G4ThreeVector  CurveB_Point= CurveB_PointVelocity.GetPosition();
 
  G4ThreeVector  ChordAB_Vector= CurveB_Point   - CurveA_Point;
  G4ThreeVector  ChordAE_Vector= CurrentE_Point - CurveA_Point;
 
  G4double       ABdist= ChordAB_Vector.mag();
  G4double  curve_length;  //  A curve length  of AB
  G4double  AE_fraction; 
  
  curve_length= CurveB_PointVelocity.GetCurveLength()
              - CurveA_PointVelocity.GetCurveLength();  
 
  G4double integrationInaccuracyLimit= std::max( perMillion, 0.5*eps_step ); 
  if( curve_length < ABdist * (1. - integrationInaccuracyLimit) )
  { 
#ifdef G4DEBUG_FIELD
    G4cerr << " Warning in G4ChordFinder::ApproxCurvePoint: "
           << G4endl
           << " The two points are further apart than the curve length "
           << G4endl
           << " Dist = "         << ABdist
           << " curve length = " << curve_length 
           << " relativeDiff = " << (curve_length-ABdist)/ABdist 
           << G4endl;
    if( curve_length < ABdist * (1. - 10*eps_step) )
    {
      std::ostringstream message;
      message << "Unphysical curve length." << G4endl
              << "The size of the above difference exceeds allowed limits."
              << G4endl
              << "Aborting.";
      G4Exception("G4ChordFinder::ApproxCurvePointV()", "GeomField0003",
                  FatalException, message);
    }
#endif
    // Take default corrective action: adjust the maximum curve length. 
    // NOTE: this case only happens for relatively straight paths.
    // curve_length = ABdist; 
  }
 
  G4double new_st_length; 
 
  if ( ABdist > 0.0 )
  {
     AE_fraction = ChordAE_Vector.mag() / ABdist;
  }
  else
  {
     AE_fraction = 0.5;                         // Guess .. ?; 
#ifdef G4DEBUG_FIELD
     G4cout << "Warning in G4ChordFinder::ApproxCurvePointV():"
            << " A and B are the same point!" << G4endl
            << " Chord AB length = " << ChordAE_Vector.mag() << G4endl
            << G4endl;
#endif
  }
  
  if( (AE_fraction> 1.0 + perMillion) || (AE_fraction< 0.) )
  {
#ifdef G4DEBUG_FIELD
    G4cerr << " G4ChordFinder::ApproxCurvePointV() - Warning:"
           << " Anomalous condition:AE > AB or AE/AB <= 0 " << G4endl
           << "   AE_fraction = " <<  AE_fraction << G4endl
           << "   Chord AE length = " << ChordAE_Vector.mag() << G4endl
           << "   Chord AB length = " << ABdist << G4endl << G4endl;
    G4cerr << " OK if this condition occurs after a recalculation of 'B'"
           << G4endl << " Otherwise it is an error. " << G4endl ; 
#endif
     // This course can now result if B has been re-evaluated, 
     // without E being recomputed (1 July 99).
     // In this case this is not a "real error" - but it is undesired
     // and we cope with it by a default corrective action ...
     //
     AE_fraction = 0.5;                         // Default value
  }
 
  new_st_length = AE_fraction * curve_length; 
 
  if ( AE_fraction > 0.0 )
  { 
     fIntgrDriver->AccurateAdvance(Current_PointVelocity, 
                                   new_st_length, eps_step );
     //
     // In this case it does not matter if it cannot advance the full distance
  }
 
  // If there was a memory of the step_length actually required at the start 
  // of the integration Step, this could be re-used ...
 
  G4cout.precision(14);
 
  return Current_PointVelocity;
}

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

GetDeltaChord()

G4double G4ChordFinder::GetDeltaChord ( ) const

inline

Accessors and modifiers.

Referenced by G4PropagatorInField::ComputeStep().

GetIntegrationDriver()

G4VIntegrationDriver * G4ChordFinder::GetIntegrationDriver ( )

inline

Referenced by G4BrentLocator::EstimateIntersectionPoint(), G4MultiLevelLocator::EstimateIntersectionPoint(), G4ErrorPropagatorManager::InitFieldForBackwards(), G4VIntersectionLocator::ReEstimateEndpoint(), and G4PropagatorInField::SetVerboseLevel().

InvParabolic()

G4double G4ChordFinder::InvParabolic ( const G4double xa, const G4double ya, const G4double xb, const G4double yb, const G4double xc, const G4double yc )

inline

Calculates the inverse parabolic through the three points (x,y) and returns the value x that, for the inverse parabolic, corresponds to y=0.

Referenced by ApproxCurvePointS().

OnComputeStep()

void G4ChordFinder::OnComputeStep ( const G4FieldTrack * track )

inline

Dispatch interface method for computing step.

Referenced by G4PropagatorInField::ComputeStep().

operator=()

G4ChordFinder & G4ChordFinder::operator= ( const G4ChordFinder & )

delete

ResetStepEstimate()

void G4ChordFinder::ResetStepEstimate ( )

inline

Clears the internal state (last step estimate).

Referenced by G4FieldManagerStore::ClearAllChordFindersState().

SetDeltaChord()

void G4ChordFinder::SetDeltaChord ( G4double newval )

inline

Referenced by G4PropagatorInField::ComputeStep().

SetIntegrationDriver()

void G4ChordFinder::SetIntegrationDriver ( G4VIntegrationDriver * IntegrationDriver )

inline

SetVerbose()

G4int G4ChordFinder::SetVerbose ( G4int newvalue = 1 )

inline

Sets the verbosity.

Returns

The old verbosity value.

SetVerboseConstruction()

void G4ChordFinder::SetVerboseConstruction ( G4bool v = true )

static

Sets verbosity for constructor.

Definition at line 646 of file G4ChordFinder.cc.

{
  gVerboseCtor = v;
}

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & os, const G4ChordFinder & cf )

friend

Writes out to stream the parameters/state of the driver.

Definition at line 653 of file G4ChordFinder.cc.

{
   // Dumping the state of G4ChordFinder
   os << "State of G4ChordFinder : " << std::endl;
   os << "   delta_chord   = " <<  cf.fDeltaChord;
   os << "   Default d_c   = " <<  cf.fDefaultDeltaChord;
 
   os << "   stats-verbose = " <<  cf.fStatsVerbose;
 
   return os;
}

---

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

• G4ChordFinder.hh
• G4ChordFinder.cc