G4BorisDriver Class Reference

G4BorisDriver is a driver class using the second order Boris method to integrate the equation of motion. More...

#include <G4BorisDriver.hh>

Inheritance diagram for G4BorisDriver:

Public Member Functions
	G4BorisDriver (G4double hminimum, G4BorisScheme *Boris, G4int numberOfComponents=6, G4bool verbosity=false)
	~G4BorisDriver () override=default
	G4BorisDriver (const G4BorisDriver &)=delete
G4BorisDriver &	operator= (const G4BorisDriver &)=delete
G4bool	AccurateAdvance (G4FieldTrack &track, G4double stepLen, G4double eps, G4double beginStep=0) override
G4bool	QuickAdvance (G4FieldTrack &y_val, const G4double dydx[], G4double hstep, G4double &missDist, G4double &dyerr) override
void	OneGoodStep (G4double yCurrentState[], G4double &curveLength, G4double htry, G4double epsilon_rel, G4double restMass, G4double charge, G4double &hdid, G4double &hnext)
G4double	AdvanceChordLimited (G4FieldTrack &track, G4double hstep, G4double eps, G4double chordDistance) override
void	OnStartTracking () override
void	OnComputeStep (const G4FieldTrack *) override
G4bool	DoesReIntegrate () const override
G4double	ComputeNewStepSize (G4double errMaxNorm, G4double hstepCurrent) override
G4double	ShrinkStepSize2 (G4double h, G4double error2) const
G4double	GrowStepSize2 (G4double h, G4double error2) const
void	GetDerivatives (const G4FieldTrack &track, G4double dydx[]) const override
void	GetDerivatives (const G4FieldTrack &track, G4double dydx[], G4double field[]) const override
void	SetVerboseLevel (G4int level) override
G4int	GetVerboseLevel () const override
G4EquationOfMotion *	GetEquationOfMotion () override
const G4EquationOfMotion *	GetEquationOfMotion () const
void	SetEquationOfMotion (G4EquationOfMotion *equation) override
void	StreamInfo (std::ostream &os) const override
const G4MagIntegratorStepper *	GetStepper () const override
G4MagIntegratorStepper *	GetStepper () override
Public Member Functions inherited from G4VIntegrationDriver
virtual	~G4VIntegrationDriver ()=default
virtual void	RenewStepperAndAdjust (G4MagIntegratorStepper *pItsStepper)
Public Member Functions inherited from G4ChordFinderDelegate< G4BorisDriver >
virtual	~G4ChordFinderDelegate ()
G4double	AdvanceChordLimitedImpl (G4FieldTrack &track, G4double hstep, G4double eps, G4double chordDistance)
void	ResetStepEstimate ()
G4double	GetLastStepEstimateUnc ()
void	SetLastStepEstimateUnc (G4double stepEst)
G4int	GetNoCalls ()
G4int	GetNoTrials ()
G4int	GetNoMaxTrials ()
void	SetFractions_Last_Next (G4double fractLast=0.90, G4double fractNext=0.95)
void	SetFirstFraction (G4double fractFirst)
G4double	GetFirstFraction ()
G4double	GetFractionLast ()
G4double	GetFractionNextEstimate ()
void	StreamDelegateInfo (std::ostream &os) const
void	TestChordPrint (G4int noTrials, G4int lastStepTrial, G4double dChordStep, G4double fDeltaChord, G4double nextStepTrial)

Additional Inherited Members
Static Protected Attributes inherited from G4VIntegrationDriver
static constexpr G4double	max_stepping_increase = 5
static constexpr G4double	max_stepping_decrease = 0.1

Detailed Description

G4BorisDriver is a driver class using the second order Boris method to integrate the equation of motion.

Definition at line 47 of file G4BorisDriver.hh.

Constructor & Destructor Documentation

G4BorisDriver() [1/2]

G4BorisDriver::G4BorisDriver	(	G4double	hminimum,
		G4BorisScheme *	Boris,
		G4int	numberOfComponents = 6,
		G4bool	verbosity = false )

Constructor for G4BorisDriver.

Parameters

[in]	hminimum	The minumum allowed step.
[in]	Boris	Pointer to the Boris motion algorithm.
[in]	numberOfComponents	The number of integration variables.
[in]	verbosity	Flag for verbosity.

Definition at line 46 of file G4BorisDriver.cc.

  : fMinimumStep(hminimum),
    fVerbosity(verbosity),
    boris(Boris)
    // , interval_sequence{2,4}
{    
    assert(boris->GetNumberOfVariables() == numberOfComponents);
    
    if(boris->GetNumberOfVariables() != numberOfComponents)
    {
      std::ostringstream msg;
      msg << "Disagreement in number of variables = "
          << boris->GetNumberOfVariables()
          << " vs no of components = " << numberOfComponents;
      G4Exception("G4BorisDriver Constructor:",
                  "GeomField1001", FatalException, msg);       
    }
 
}

Referenced by G4BorisDriver(), and operator=().

~G4BorisDriver()

G4BorisDriver::~G4BorisDriver ( )

overridedefault

Default Destructor.

G4BorisDriver() [2/2]

G4BorisDriver::G4BorisDriver ( const G4BorisDriver & )

delete

Copy constructor and assignment operator not allowed.

Member Function Documentation

AccurateAdvance()

G4bool G4BorisDriver::AccurateAdvance ( G4FieldTrack & track, G4double stepLen, G4double eps, G4double beginStep = 0 )

overridevirtual

Advances integration accurately by relative accuracy better than 'eps'.

Parameters

[in,out]	track	The current track in field.
[in]	stepLen	Proposed step length.
[in]	epsilon	Requested accuracy, y_err/hstep.
[in]	beginStep	Initial minimum integration step.

Returns

true if integration succeeds.

Implements G4VIntegrationDriver.

Definition at line 70 of file G4BorisDriver.cc.

{
   // Specification: Driver with adaptive stepsize control.
   // Integrate starting values at y_current over hstep x2 with (relative) accuracy 'eps'.
   // On output 'track' is replaced by values at the end of the integration interval. 
   
   //  Ensure that hstep > 0
   if(hstep == 0)
   {
      std::ostringstream message;
      message << "Proposed step is zero; hstep = " << hstep << " !";
      G4Exception("G4BorisDriver::AccurateAdvance()",
                  "GeomField1001", JustWarning, message);
      return true;
   }
   if(hstep < 0)
   {
      std::ostringstream message;
      message << "Invalid run condition." << G4endl
              << "Proposed step is negative; hstep = " << hstep << G4endl
              << "Requested step cannot be negative! Aborting event.";
      G4Exception("G4BorisDriver::AccurateAdvance()",
                  "GeomField0003", EventMustBeAborted, message);
      return false;
   }
 
   if( hinitial == 0.0 ) { hinitial = hstep; }   
   if( hinitial < 0.0 ) { hinitial = std::fabs( hinitial ); }
   // G4double htrial = std::min( hstep, hinitial );
   G4double htrial = hstep;
   // Decide first step size      
 
   // G4int noOfSteps = h/hstep;
   
    // integration variables
    //
   track.DumpToArray(yCurrent);
 
   const G4double restMass = track.GetRestMass();
   const G4double charge = track.GetCharge()*e_SI;
   const G4int    nvar= GetNumberOfVariables();
   
   // copy non-integration variables to out array
   //
   std::memcpy(yOut + nvar,
               yCurrent + nvar,
               sizeof(G4double)*(G4FieldTrack::ncompSVEC-nvar));
   
   G4double curveLength = track.GetCurveLength();  // starting value
   const G4double endCurveLength = curveLength + hstep;
 
   // -- Initial version: Did it in one step -- did not account for errors !!!
   // G4FieldTrack yFldTrk(track);
   // yFldTrk.LoadFromArray(yCurrent, G4FieldTrack::ncompSVEC);
   // yFldTrk.SetCurveLength(curveLength);
   // G4double dchord_step, dyerr_len;   
   // QuickAdvance(yFldTrk, dydxCurrent, htrial, dchord_step, dyerr_len);
 
   const G4double hThreshold = 
        std::max(epsilon * hstep, fSmallestFraction * curveLength);
 
   G4double htry= htrial;
   
   for (G4int nstp = 0; nstp < fMaxNoSteps; ++nstp)
   {
      G4double hdid= 0.0, hnext=0.0;
        
      OneGoodStep(yCurrent, curveLength, htry, epsilon, restMass, charge, hdid, hnext);
      //*********
 
      // Simple check: move (distance of displacement) is smaller than length along curve!
      const G4ThreeVector StartPos = field_utils::makeVector(yCurrent, field_utils::Value3D::Position);      
      const G4ThreeVector EndPos = field_utils::makeVector(yCurrent, field_utils::Value3D::Position);
      CheckStep(EndPos, StartPos, hdid);
      
      // Check   1. for finish   and    2. *avoid* numerous small last steps
      if (curveLength >= endCurveLength || htry < hThreshold)
      {
         break; 
      }
      
      htry = std::max(hnext, fMinimumStep);
      if (curveLength + htry > endCurveLength)
      {
         htry = endCurveLength - curveLength;
      }
   }
 
   // upload new state   
   track.LoadFromArray(yCurrent, G4FieldTrack::ncompSVEC);
   track.SetCurveLength(curveLength);
 
   return true;
}

AdvanceChordLimited()

G4double G4BorisDriver::AdvanceChordLimited ( G4FieldTrack & track, G4double hstep, G4double eps, G4double chordDistance )

inlineoverridevirtual

Computes the step to take, based on chord limits.

Parameters

[in,out]	track	The current track in field.
[in]	hstep	Proposed step length.
[in]	eps	Requested accuracy, y_err/hstep.
[in]	chordDistance	Maximum sagitta distance.

Returns

The length of step taken.

Implements G4VIntegrationDriver.

ComputeNewStepSize()

G4double G4BorisDriver::ComputeNewStepSize ( G4double errMaxNorm, G4double hstepCurrent )

inlineoverridevirtual

Computes a step size for the next step, taking the last step's normalised error 'errMaxNorm'.

Parameters

[in]	errMaxNorm	The normalised error on last step.
[in]	hstepCurrent	The current proposed step.

Returns

The step size for the next step.

Implements G4VIntegrationDriver.

DoesReIntegrate()

G4bool G4BorisDriver::DoesReIntegrate ( ) const

inlineoverridevirtual

The driver implements re-integration. Returns true. It would be false if it just used interpolation to provide a result.

Implements G4VIntegrationDriver.

GetDerivatives() [1/2]

void G4BorisDriver::GetDerivatives ( const G4FieldTrack & track, G4double dydx[] ) const

overridevirtual

Getters for derivatives.

Implements G4VIntegrationDriver.

Definition at line 269 of file G4BorisDriver.cc.

{
   G4double  EBfieldValue[6];
   GetDerivatives(yTrack, dydx, EBfieldValue);
}

Referenced by GetDerivatives().

GetDerivatives() [2/2]

void G4BorisDriver::GetDerivatives ( const G4FieldTrack & track, G4double dydx[], G4double field[] ) const

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 278 of file G4BorisDriver.cc.

{
   // G4Exception("G4BorisDriver::GetDerivatives()",
   //             "GeomField0003", FatalException, "This method is not implemented.");
   G4double ytemp[G4FieldTrack::ncompSVEC];
   yTrack.DumpToArray(ytemp);
   GetEquationOfMotion()->EvaluateRhsReturnB(ytemp, dydx, EBfieldValue);
}

GetEquationOfMotion() [1/2]

const G4EquationOfMotion * G4BorisDriver::GetEquationOfMotion ( ) const

inline

GetEquationOfMotion() [2/2]

G4EquationOfMotion * G4BorisDriver::GetEquationOfMotion ( )

inlineoverridevirtual

Getters for the equation of motion.

Implements G4VIntegrationDriver.

Referenced by GetDerivatives().

GetStepper() [1/2]

const G4MagIntegratorStepper * G4BorisDriver::GetStepper ( ) const

inlineoverridevirtual

Accessors for stepper. Not relevant for Boris and other non-RK methods.

Implements G4VIntegrationDriver.

GetStepper() [2/2]

G4MagIntegratorStepper * G4BorisDriver::GetStepper ( )

inlineoverridevirtual

Implements G4VIntegrationDriver.

GetVerboseLevel()

G4int G4BorisDriver::GetVerboseLevel ( ) const

inlineoverridevirtual

Implements G4VIntegrationDriver.

GrowStepSize2()

G4double G4BorisDriver::GrowStepSize2	(	G4double	h,
		G4double	error2 ) const

Definition at line 302 of file G4BorisDriver.cc.

{
    if (error2 < fErrorConstraintGrow * fErrorConstraintGrow)
    {
        return fMaxSteppingIncrease * h;
    }
    return fSafetyFactor * h * std::pow(error2, 0.5 * fPowerGrow);
}

Referenced by OneGoodStep().

OnComputeStep()

void G4BorisDriver::OnComputeStep ( const G4FieldTrack * )

inlineoverridevirtual

Dispatch interface method for computing step. Does nothing here.

Implements G4VIntegrationDriver.

OneGoodStep()

void G4BorisDriver::OneGoodStep	(	G4double	yCurrentState[],
		G4double &	curveLength,
		G4double	htry,
		G4double	epsilon_rel,
		G4double	restMass,
		G4double	charge,
		G4double &	hdid,
		G4double &	hnext )

Takes one Step that is as large as possible while satisfying the accuracy criterion.

Parameters

[in,out]	yCurrentState	The current track state, y.
[in,out]	curveLength	Step start, x.
[in]	htry	Step to attempt.
[in]	epsilon_rel	The relative accuracy.
[in]	restMass	Mass value for computing velocity.
[in]	charge	Charge value for computing momentum.
[out]	hdid	Step achieved.
[out]	hnext	Proposed next step.

Returns

true if integration succeeds.

Definition at line 170 of file G4BorisDriver.cc.

{
    G4double error2 = DBL_MAX;
    G4double yerr[G4FieldTrack::ncompSVEC], ytemp[G4FieldTrack::ncompSVEC];
 
    G4double h = htry;
 
    const G4int max_trials = 100; 
 
    for (G4int iter = 0; iter < max_trials; ++iter)
    {
        boris->StepWithErrorEstimate(y, restMass, charge, h, ytemp, yerr);
        
        error2 = field_utils::relativeError2(y, yerr, std::max(h, fMinimumStep),
                                             epsilon_rel);
        if (error2 <= 1.0)
        {
            break; 
        }
 
        h = ShrinkStepSize2(h, error2);
 
        G4double xnew = curveLength + h;
        if(xnew == curveLength)
        {
            std::ostringstream message;
            message << "Stepsize underflow in Stepper !" << G4endl
                    << "- Step's start x=" << curveLength
                    << " and end x= " << xnew 
                    << " are equal !! " << G4endl
                    << "  Due to step-size= " << h 
                    << ". Note that input step was " << htry;
            G4Exception("G4IntegrationDriver::OneGoodStep()",
                        "GeomField1001", JustWarning, message);
            break;
        }
    }
 
    hnext = GrowStepSize2(h, error2);
    curveLength += (hdid = h);
 
    field_utils::copy(y, ytemp, GetNumberOfVariables());
}

Referenced by AccurateAdvance().

OnStartTracking()

void G4BorisDriver::OnStartTracking ( )

inlineoverridevirtual

Dispatch interface method for initialisation/reset of driver.

Implements G4VIntegrationDriver.

operator=()

G4BorisDriver & G4BorisDriver::operator= ( const G4BorisDriver & )

delete

QuickAdvance()

G4bool G4BorisDriver::QuickAdvance ( G4FieldTrack & y_val, const G4double dydx[], G4double hstep, G4double & missDist, G4double & dyerr )

overridevirtual

Attempts one integration step, and returns estimated error 'dyerr'. It does not ensure accuracy.

Parameters

[in,out]	y_val	The current track in field.
[in]	dydx	dydx array.
[in]	hstep	Proposed step length.
[out]	missDist	Estimated sagitta distance.
[out]	dyerr	Estimated error.

Returns

true if integration succeeds.

Reimplemented from G4VIntegrationDriver.

Definition at line 223 of file G4BorisDriver.cc.

{
    const auto nvar = boris->GetNumberOfVariables();
 
    track.DumpToArray(yIn);
    const G4double curveLength = track.GetCurveLength();
 
    // call the boris method for step length hstep
    G4double restMass = track.GetRestMass();
    G4double charge = track.GetCharge()*e_SI;
 
    // boris->DoStep(restMass, charge, yIn,  yMid, hstep*0.5);
    // boris->DoStep(restMass, charge, yMid, yOut, hstep*0.5);  // Use mid-point !!
    boris->StepWithMidAndErrorEstimate(yIn, restMass, charge, hstep,
                                       yMid, yOut, yError);
      // Same, and also return mid-point evaluation
    
    // How to calculate chord length??
    const auto mid = field_utils::makeVector(yMid,
                     field_utils::Value3D::Position);
    const auto in  = field_utils::makeVector(yIn,
                     field_utils::Value3D::Position);
    const auto out = field_utils::makeVector(yOut,
                     field_utils::Value3D::Position);
 
    missDist = G4LineSection::Distline(mid, in, out);
 
    dyerr = field_utils::absoluteError(yOut, yError, hstep);
 
    // copy non-integrated variables to output array
    //
    std::memcpy(yOut + nvar, yIn + nvar,
                sizeof(G4double) * (G4FieldTrack::ncompSVEC - nvar));
 
    // set new state
    //
    track.LoadFromArray(yOut, G4FieldTrack::ncompSVEC);
    track.SetCurveLength(curveLength +  hstep);
 
    return true;
}

SetEquationOfMotion()

void G4BorisDriver::SetEquationOfMotion ( G4EquationOfMotion * equation )

overridevirtual

Setter for the equation of motion. Issues an exception, as not foreseen to change equation of motion for the Boris stepper.

Implements G4VIntegrationDriver.

Definition at line 314 of file G4BorisDriver.cc.

{
   G4Exception("G4BorisDriver::SetEquationOfMotion()", "GeomField0003", FatalException,
               "This method is not implemented. BorisDriver/Stepper should keep its equation");
}

SetVerboseLevel()

void G4BorisDriver::SetVerboseLevel ( G4int level )

inlineoverridevirtual

Setter and getter for verbosity.

Implements G4VIntegrationDriver.

ShrinkStepSize2()

G4double G4BorisDriver::ShrinkStepSize2	(	G4double	h,
		G4double	error2 ) const

Methods to calculate the next step size given the square of the relative error.

Definition at line 291 of file G4BorisDriver.cc.

{
   if (error2 > fErrorConstraintShrink * fErrorConstraintShrink)
   {
      return fMaxSteppingDecrease * h;
   }
   return fSafetyFactor * h * std::pow(error2, 0.5 * fPowerShrink);
}

Referenced by OneGoodStep().

StreamInfo()

void G4BorisDriver::StreamInfo ( std::ostream & os ) const

overridevirtual

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

Implements G4VIntegrationDriver.

Definition at line 323 of file G4BorisDriver.cc.

{
  os << "State of G4BorisDriver: " << std::endl;
  os << "   Method is implemented, but gives no information. " << std::endl;
}

---

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

• G4BorisDriver.hh
• G4BorisDriver.cc