G4BorisDriver Class Reference

#include <G4BorisDriver.hh>

Inheritance diagram for G4BorisDriver:

Public Member Functions
	G4BorisDriver (G4double hminimum, G4BorisScheme *Boris, G4int numberOfComponents=6, bool verbosity=false)
	~G4BorisDriver ()=default
	G4BorisDriver (const G4BorisDriver &)=delete
G4BorisDriver &	operator= (const G4BorisDriver &)=delete
virtual G4bool	AccurateAdvance (G4FieldTrack &track, G4double stepLen, G4double epsilon, G4double beginStep=0) override
virtual 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)
virtual G4double	AdvanceChordLimited (G4FieldTrack &track, G4double hstep, G4double eps, G4double chordDistance) override
virtual void	OnStartTracking () override
virtual void	OnComputeStep () override
virtual G4bool	DoesReIntegrate () const override
virtual G4double	ComputeNewStepSize (G4double errMaxNorm, G4double hstepCurrent) override
G4double	ShrinkStepSize2 (G4double h, G4double error2) const
G4double	GrowStepSize2 (G4double h, G4double error2) const
virtual void	GetDerivatives (const G4FieldTrack &track, G4double dydx[]) const override
virtual void	GetDerivatives (const G4FieldTrack &track, G4double dydx[], G4double field[]) const override
virtual void	SetVerboseLevel (G4int level) override
virtual G4int	GetVerboseLevel () const override
virtual G4EquationOfMotion *	GetEquationOfMotion () override
const G4EquationOfMotion *	GetEquationOfMotion () const
virtual void	SetEquationOfMotion (G4EquationOfMotion *equation) override
virtual void	StreamInfo (std::ostream &os) const override
virtual const G4MagIntegratorStepper *	GetStepper () const override
virtual G4MagIntegratorStepper *	GetStepper () override
Public Member Functions inherited from G4VIntegrationDriver
virtual	~G4VIntegrationDriver ()=default
virtual G4double	AdvanceChordLimited (G4FieldTrack &track, G4double hstep, G4double eps, G4double chordDistance)=0
virtual G4bool	AccurateAdvance (G4FieldTrack &track, G4double hstep, G4double eps, G4double hinitial=0)=0
virtual void	SetEquationOfMotion (G4EquationOfMotion *equation)=0
virtual G4EquationOfMotion *	GetEquationOfMotion ()=0
virtual void	RenewStepperAndAdjust (G4MagIntegratorStepper *pItsStepper)
virtual void	SetVerboseLevel (G4int level)=0
virtual G4int	GetVerboseLevel () const =0
virtual void	OnComputeStep ()=0
virtual void	OnStartTracking ()=0
virtual G4bool	QuickAdvance (G4FieldTrack &, const G4double[], G4double, G4double &, G4double &)
virtual void	GetDerivatives (const G4FieldTrack &track, G4double dydx[]) const =0
virtual void	GetDerivatives (const G4FieldTrack &track, G4double dydx[], G4double field[]) const =0
virtual const G4MagIntegratorStepper *	GetStepper () const =0
virtual G4MagIntegratorStepper *	GetStepper ()=0
virtual G4double	ComputeNewStepSize (G4double errMaxNorm, G4double hstepCurrent)=0
virtual G4bool	DoesReIntegrate () const =0
virtual void	StreamInfo (std::ostream &os) const =0
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,
		bool	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 ( )

inlinedefault

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

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

inlineoverridevirtual

Implements G4VIntegrationDriver.

Definition at line 85 of file G4BorisDriver.hh.

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

ComputeNewStepSize()

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

inlineoverridevirtual

Implements G4VIntegrationDriver.

DoesReIntegrate()

virtual G4bool G4BorisDriver::DoesReIntegrate ( ) const

inlineoverridevirtual

Implements G4VIntegrationDriver.

Definition at line 105 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]

virtual G4EquationOfMotion * G4BorisDriver::GetEquationOfMotion ( )

inlineoverridevirtual

Implements G4VIntegrationDriver.

Referenced by GetDerivatives().

GetStepper() [1/2]

virtual const G4MagIntegratorStepper * G4BorisDriver::GetStepper ( ) const

inlineoverridevirtual

Implements G4VIntegrationDriver.

GetStepper() [2/2]

virtual G4MagIntegratorStepper * G4BorisDriver::GetStepper ( )

inlineoverridevirtual

Implements G4VIntegrationDriver.

GetVerboseLevel()

virtual 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()

virtual void G4BorisDriver::OnComputeStep ( )

inlineoverridevirtual

Implements G4VIntegrationDriver.

Definition at line 98 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()

virtual void G4BorisDriver::OnStartTracking ( )

inlineoverridevirtual

Implements G4VIntegrationDriver.

Definition at line 94 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()

virtual 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