G4BorisDriver Class Reference

#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 epsilon, 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 ()
void	TestChordPrint (G4int noTrials, G4int lastStepTrial, G4double dChordStep, G4double fDeltaChord, G4double nextStepTrial)
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 ()
G4double	GetLastStepEstimateUnc ()
void	SetLastStepEstimateUnc (G4double stepEst)
void	StreamDelegateInfo (std::ostream &os) const

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

Definition at line 44 of file G4BorisDriver.hh.

Constructor & Destructor Documentation

G4BorisDriver() [1/2]

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

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

~G4BorisDriver()

G4BorisDriver::~G4BorisDriver ( )

inlineoverridedefault

G4BorisDriver() [2/2]

G4BorisDriver::G4BorisDriver ( const G4BorisDriver & )

inlinedelete

Member Function Documentation

AccurateAdvance()

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

overridevirtual

Implements G4VIntegrationDriver.

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

Implements G4VIntegrationDriver.

Definition at line 87 of file G4BorisDriver.hh.

    {
      return ChordFinderDelegate::
             AdvanceChordLimitedImpl(track, hstep, eps, chordDistance);
    }

ComputeNewStepSize()

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

inlineoverridevirtual

Implements G4VIntegrationDriver.

DoesReIntegrate()

G4bool G4BorisDriver::DoesReIntegrate ( ) const

inlineoverridevirtual

Implements G4VIntegrationDriver.

Definition at line 106 of file G4BorisDriver.hh.

{ return true; }

GetDerivatives() [1/2]

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

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 275 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 284 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

Implements G4VIntegrationDriver.

Referenced by GetDerivatives().

GetStepper() [1/2]

const G4MagIntegratorStepper * G4BorisDriver::GetStepper ( ) const

inlineoverridevirtual

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

Implements G4VIntegrationDriver.

Definition at line 101 of file G4BorisDriver.hh.

{}

OneGoodStep()

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

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

Implements G4VIntegrationDriver.

Definition at line 96 of file G4BorisDriver.hh.

    {
      ChordFinderDelegate::ResetStepEstimate();
    }

operator=()

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

inlinedelete

QuickAdvance()

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

overridevirtual

Reimplemented from G4VIntegrationDriver.

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

Implements G4VIntegrationDriver.

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

Implements G4VIntegrationDriver.

ShrinkStepSize2()

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

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

Implements G4VIntegrationDriver.

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