G4TMagErrorStepper< T_Stepper, T_Equation, N > Class Template Reference

#include <G4TMagErrorStepper.hh>

Inheritance diagram for G4TMagErrorStepper< T_Stepper, T_Equation, N >:

Public Member Functions
	G4TMagErrorStepper (T_Equation *EqRhs, G4int numberOfVariables, G4int numStateVariables=12)
virtual	~G4TMagErrorStepper ()
void	RightHandSide (G4double y[], G4double dydx[])
void	Stepper (const G4double yInput[], const G4double dydx[], G4double hstep, G4double yOutput[], G4double yError[]) override final
G4double	DistChord () const override final
Public Member Functions inherited from G4MagIntegratorStepper
	G4MagIntegratorStepper (G4EquationOfMotion *Equation, G4int numIntegrationVariables, G4int numStateVariables=12, G4bool isFSAL=false)
virtual	~G4MagIntegratorStepper ()=default
	G4MagIntegratorStepper (const G4MagIntegratorStepper &)=delete
G4MagIntegratorStepper &	operator= (const G4MagIntegratorStepper &)=delete
virtual void	Stepper (const G4double y[], const G4double dydx[], G4double h, G4double yout[], G4double yerr[])=0
virtual G4double	DistChord () const =0
void	NormaliseTangentVector (G4double vec[6])
void	NormalisePolarizationVector (G4double vec[12])
void	RightHandSide (const G4double y[], G4double dydx[]) const
void	RightHandSide (const G4double y[], G4double dydx[], G4double field[]) const
G4int	GetNumberOfVariables () const
G4int	GetNumberOfStateVariables () const
virtual G4int	IntegratorOrder () const =0
G4int	IntegrationOrder ()
G4EquationOfMotion *	GetEquationOfMotion ()
const G4EquationOfMotion *	GetEquationOfMotion () const
void	SetEquationOfMotion (G4EquationOfMotion *newEquation)
unsigned long	GetfNoRHSCalls ()
void	ResetfNORHSCalls ()
G4bool	IsFSAL () const

Additional Inherited Members
Protected Member Functions inherited from G4MagIntegratorStepper
void	SetIntegrationOrder (G4int order)
void	SetFSAL (G4bool flag=true)

Detailed Description

template<class T_Stepper, class T_Equation, unsigned int N>
class G4TMagErrorStepper< T_Stepper, T_Equation, N >

Definition at line 46 of file G4TMagErrorStepper.hh.

Constructor & Destructor Documentation

G4TMagErrorStepper()

template<class T_Stepper , class T_Equation , unsigned int N>

G4TMagErrorStepper< T_Stepper, T_Equation, N >::G4TMagErrorStepper ( T_Equation *  EqRhs, G4int  numberOfVariables, G4int  numStateVariables = 12  )

inline

Definition at line 49 of file G4TMagErrorStepper.hh.

    : G4MagIntegratorStepper(EqRhs, numberOfVariables, numStateVariables)
    , fEquation_Rhs(EqRhs)
  {
    // G4int nvar = std::max(this->GetNumberOfVariables(), 8);
  }

~G4TMagErrorStepper()

template<class T_Stepper , class T_Equation , unsigned int N>

virtual G4TMagErrorStepper< T_Stepper, T_Equation, N >::~G4TMagErrorStepper ( )

inlinevirtual

Definition at line 57 of file G4TMagErrorStepper.hh.

{ ; }

Member Function Documentation

DistChord()

template<class T_Stepper , class T_Equation , unsigned int N>

G4double G4TMagErrorStepper< T_Stepper, T_Equation, N >::DistChord

inlinefinaloverridevirtual

Implements G4MagIntegratorStepper.

Definition at line 153 of file G4TMagErrorStepper.hh.

{
  // Estimate the maximum distance from the curve to the chord
  //
  //  We estimate this using the distance of the midpoint to
  //  chord (the line between
  //
  //  Method below is good only for angle deviations < 2 pi,
  //   This restriction should not a problem for the Runge cutta methods,
  //   which generally cannot integrate accurately for large angle deviations.
  G4double distLine, distChord;
 
  if(fInitialPoint != fFinalPoint)
  {
    distLine = G4LineSection::Distline(fMidPoint, fInitialPoint, fFinalPoint);
    // This is a class method that gives distance of Mid
    //  from the Chord between the Initial and Final points.
    
    distChord = distLine;
  }
  else
  {
     distChord = (fMidPoint - fInitialPoint).mag();
  }
  
  return distChord;
}

RightHandSide()

template<class T_Stepper , class T_Equation , unsigned int N>

void G4TMagErrorStepper< T_Stepper, T_Equation, N >::RightHandSide ( G4double  y[], G4double  dydx[]  )

inline

Definition at line 59 of file G4TMagErrorStepper.hh.

  {
    fEquation_Rhs->T_Equation::RightHandSide(y, dydx);
  }

Referenced by G4TMagErrorStepper< T_Stepper, T_Equation, N >::Stepper().

Stepper()

template<class T_Stepper , class T_Equation , unsigned int N>

void G4TMagErrorStepper< T_Stepper, T_Equation, N >::Stepper ( const G4double  yInput[], const G4double  dydx[], G4double  hstep, G4double  yOutput[], G4double  yError[]  )

inlinefinaloverridevirtual

Implements G4MagIntegratorStepper.

Definition at line 94 of file G4TMagErrorStepper.hh.

{
  const unsigned int maxvar = GetNumberOfStateVariables();
  
  //  Saving yInput because yInput and yOutput can be aliases for same array
  for(unsigned int i = 0; i < N; ++i)
     yInitial[i] = yInput[i];
  yInitial[7] =
     yInput[7];  // Copy the time in case ... even if not really needed
  yMiddle[7]  = yInput[7];  // Copy the time from initial value
  yOneStep[7] = yInput[7];  // As it contributes to final value of yOutput ?
  // yOutput[7] = yInput[7];  // -> dumb stepper does it too for RK4
  for(unsigned int i = N; i < maxvar; ++i)
     yOutput[i] = yInput[i];
 
  G4double halfStep = hstep * 0.5;
  
  // Do two half steps
  
  static_cast<T_Stepper*>(this)->DumbStepper(yInitial, dydx, halfStep,
                                               yMiddle);
  this->RightHandSide(yMiddle, dydxMid);
  static_cast<T_Stepper*>(this)->DumbStepper(yMiddle, dydxMid, halfStep,
                                             yOutput);
  
  // Store midpoint, chord calculation
  
  fMidPoint = G4ThreeVector(yMiddle[0], yMiddle[1], yMiddle[2]);
  
  // Do a full Step
  static_cast<T_Stepper*>(this)->DumbStepper(yInitial, dydx, hstep, yOneStep);
  for(unsigned int i = 0; i < N; ++i)
  {
    yError[i] = yOutput[i] - yOneStep[i];
    yOutput[i] +=
       yError[i] *
       T_Stepper::IntegratorCorrection;  // Provides accuracy increased
    // by 1 order via the
    // Richardson Extrapolation
  }
 
  fInitialPoint = G4ThreeVector(yInitial[0], yInitial[1], yInitial[2]);
  fFinalPoint   = G4ThreeVector(yOutput[0], yOutput[1], yOutput[2]);
  
  return;
}

---

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

• G4TMagErrorStepper.hh