#include <G4TExplicitEuler.hh>

Inheritance diagram for G4TExplicitEuler< T_Equation, N >:

Public Member Functions
G4double	DistChord () const override final

void	DumbStepper (const G4double yIn[], const G4double dydx[], G4double h, G4double yOut[])

	G4TExplicitEuler (T_Equation *EqRhs, G4int numberOfVariables=N)

G4EquationOfMotion *	GetEquationOfMotion ()

const G4EquationOfMotion *	GetEquationOfMotion () const

unsigned long	GetfNoRHSCalls ()

G4int	GetNumberOfStateVariables () const

G4int	GetNumberOfVariables () const

G4int	IntegrationOrder ()

G4int	IntegratorOrder () const

G4bool	IsFSAL () const

void	NormalisePolarizationVector (G4double vec[12])

void	NormaliseTangentVector (G4double vec[6])

void	ResetfNORHSCalls ()

void	RightHandSide (const G4double y[], G4double dydx[]) const

void	RightHandSide (const G4double y[], G4double dydx[], G4double field[]) const

void	RightHandSide (G4double y[], G4double dydx[])

void	SetEquationOfMotion (G4EquationOfMotion *newEquation)

void	Stepper (const G4double yInput[], const G4double dydx[], G4double hstep, G4double yOutput[], G4double yError[]) override final

	~G4TExplicitEuler ()

Static Public Attributes
static constexpr double	IntegratorCorrection = 1.

Protected Member Functions
void	SetFSAL (G4bool flag=true)

void	SetIntegrationOrder (G4int order)

Private Attributes
G4double	dydxMid [N< 8 ? 8 :N]

T_Equation *	fEquation_Rhs

G4ThreeVector	fFinalPoint

G4ThreeVector	fInitialPoint

G4int	fIntegrationOrder = -1

G4bool	fIsFSAL = false

G4ThreeVector	fMidPoint

const G4int	fNoIntegrationVariables = 0

unsigned long	fNoRHSCalls = 0UL

const G4int	fNoStateVariables = 0

G4double	yInitial [N< 8 ? 8 :N]

G4double	yMiddle [N< 8 ? 8 :N]

G4double	yOneStep [N< 8 ? 8 :N]

Detailed Description

template<class T_Equation, int N>
class G4TExplicitEuler< T_Equation, N >

Definition at line 56 of file G4TExplicitEuler.hh.

Constructor & Destructor Documentation

◆ G4TExplicitEuler()

template<class T_Equation , int N>

G4TExplicitEuler< T_Equation, N >::G4TExplicitEuler	(	T_Equation *	EqRhs,
		G4int	numberOfVariables = `N`
	)

inline

Definition at line 62 of file G4TExplicitEuler.hh.

    : G4TMagErrorStepper<G4TExplicitEuler<T_Equation, N>, T_Equation, N>(
        EqRhs, numberOfVariables)
    , fEquation_Rhs(EqRhs)
  {
    if( numberOfVariables != N ){
       G4ExceptionDescription msg;
       msg << "Equation has an incompatible number of variables." ;
       msg << "   template N = " << N << " equation-Nvar= "
           << numberOfVariables;
       G4Exception("G4TExplicitEuler: constructor", "GeomField0003",
                   FatalErrorInArgument, msg );
    }
  }

References FatalErrorInArgument, and G4Exception().

◆ ~G4TExplicitEuler()

template<class T_Equation , int N>

G4TExplicitEuler< T_Equation, N >::~G4TExplicitEuler ( )

inline

Definition at line 77 of file G4TExplicitEuler.hh.

77{ ; }

Member Function Documentation

◆ DistChord()

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

inlinefinaloverridevirtualinherited

Implements G4MagIntegratorStepper.

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

◆ DumbStepper()

template<class T_Equation , int N>

void G4TExplicitEuler< T_Equation, N >::DumbStepper	(	const G4double	yIn[],
		const G4double	dydx[],
		G4double	h,
		G4double	yOut[]
	)

inline

Definition at line 79 of file G4TExplicitEuler.hh.

  {
    // Initialise time to t0, needed when it is not updated by the integration.
    // yOut[7] = yIn[7];   //  Better to set it to NaN;  // TODO
 
    for(G4int i = 0; i < N; ++i)
    {
      yOut[i] = yIn[i] + h * dydx[i];  // 1st and only Step
    }
 
    return;
  }

◆ GetEquationOfMotion() [1/2]

G4EquationOfMotion * G4MagIntegratorStepper::GetEquationOfMotion ( )

inlineinherited

Referenced by G4MagInt_Driver::GetEquationOfMotion(), G4OldMagIntDriver::GetEquationOfMotion(), G4NystromRK4::GetField(), G4DormandPrince745::GetSpecificEquation(), G4NystromRK4::SetDistanceForConstantField(), G4RKG3_Stepper::StepNoErr(), and G4RKG3_Stepper::Stepper().

◆ GetEquationOfMotion() [2/2]

const G4EquationOfMotion * G4MagIntegratorStepper::GetEquationOfMotion ( ) const

inlineinherited

◆ GetfNoRHSCalls()

unsigned long G4MagIntegratorStepper::GetfNoRHSCalls ( )

inlineinherited

◆ GetNumberOfStateVariables()

G4int G4MagIntegratorStepper::GetNumberOfStateVariables ( ) const

inlineinherited

Referenced by G4BogackiShampine45::G4BogackiShampine45(), G4CashKarpRKF45::G4CashKarpRKF45(), G4SimpleRunge::G4SimpleRunge(), G4TSimpleRunge< T_Equation, N >::G4TSimpleRunge(), G4TsitourasRK45::G4TsitourasRK45(), G4BogackiShampine23::makeStep(), G4RK547FEq1::makeStep(), G4RK547FEq2::makeStep(), G4RK547FEq3::makeStep(), G4ConstRK4::Stepper(), G4MagErrorStepper::Stepper(), and G4TMagErrorStepper< T_Stepper, T_Equation, N >::Stepper().

◆ GetNumberOfVariables()

G4int G4MagIntegratorStepper::GetNumberOfVariables ( ) const

inlineinherited

Referenced by G4ExplicitEuler::DumbStepper(), G4ImplicitEuler::DumbStepper(), G4ClassicalRK4::DumbStepper(), G4ChordFinder::G4ChordFinder(), G4BogackiShampine45::GetLastDydx(), G4DoLoMcPriRK34::Interpolate(), G4TsitourasRK45::Interpolate(), G4DormandPrince745::Interpolate4thOrder(), G4DormandPrince745::Interpolate5thOrder(), G4DormandPrinceRK56::Interpolate_high(), G4DormandPrinceRK56::Interpolate_low(), G4BogackiShampine45::InterpolateHigh(), G4BogackiShampine23::makeStep(), G4RK547FEq1::makeStep(), G4RK547FEq2::makeStep(), G4RK547FEq3::makeStep(), G4DormandPrinceRK56::SetupInterpolate_high(), G4DormandPrinceRK56::SetupInterpolate_low(), G4DormandPrince745::SetupInterpolation5thOrder(), G4BogackiShampine45::SetupInterpolationHigh(), G4BogackiShampine45::Stepper(), G4CashKarpRKF45::Stepper(), G4DoLoMcPriRK34::Stepper(), G4DormandPrinceRK56::Stepper(), G4DormandPrinceRK78::Stepper(), G4MagErrorStepper::Stepper(), G4TsitourasRK45::Stepper(), and G4DormandPrince745::Stepper().

◆ IntegrationOrder()

G4int G4MagIntegratorStepper::IntegrationOrder ( )

inlineinherited

◆ IntegratorOrder()

template<class T_Equation , int N>

G4int G4TExplicitEuler< T_Equation, N >::IntegratorOrder ( ) const

inlinevirtual

Implements G4MagIntegratorStepper.

Definition at line 95 of file G4TExplicitEuler.hh.

95{ return 1; }

◆ IsFSAL()

G4bool G4MagIntegratorStepper::IsFSAL ( ) const

inlineinherited

◆ NormalisePolarizationVector()

void G4MagIntegratorStepper::NormalisePolarizationVector ( G4double vec[12] )

inlineinherited

Referenced by G4SimpleHeum::DumbStepper(), and G4ClassicalRK4::DumbStepper().

◆ NormaliseTangentVector()

void G4MagIntegratorStepper::NormaliseTangentVector ( G4double vec[6] )

inlineinherited

◆ ResetfNORHSCalls()

void G4MagIntegratorStepper::ResetfNORHSCalls ( )

inlineinherited

◆ RightHandSide() [1/3]

void G4MagIntegratorStepper::RightHandSide	(	const G4double	y[],
		G4double	dydx[]
	)		const

inlineinherited

◆ RightHandSide() [2/3]

void G4MagIntegratorStepper::RightHandSide	(	const G4double	y[],
		G4double	dydx[],
		G4double	field[]
	)		const

inlineinherited

◆ RightHandSide() [3/3]

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

inlineinherited

Definition at line 59 of file G4TMagErrorStepper.hh.

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

◆ SetEquationOfMotion()

void G4MagIntegratorStepper::SetEquationOfMotion ( G4EquationOfMotion * newEquation )

inlineinherited

Referenced by G4MagInt_Driver::SetEquationOfMotion(), and G4OldMagIntDriver::SetEquationOfMotion().

◆ SetFSAL()

void G4MagIntegratorStepper::SetFSAL ( G4bool flag = true )

inlineprotectedinherited

Referenced by G4BogackiShampine23::G4BogackiShampine23().

◆ SetIntegrationOrder()

void G4MagIntegratorStepper::SetIntegrationOrder ( G4int order )

inlineprotectedinherited

Referenced by G4BogackiShampine23::G4BogackiShampine23().

◆ Stepper()

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

inlinefinaloverridevirtualinherited

Implements G4MagIntegratorStepper.

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

Field Documentation

◆ dydxMid

G4double G4TMagErrorStepper< G4TExplicitEuler< T_Equation, N > , T_Equation, N >::dydxMid[N< 8 ? 8 :N]

privateinherited

Definition at line 82 of file G4TMagErrorStepper.hh.

◆ fEquation_Rhs

template<class T_Equation , int N>

T_Equation* G4TExplicitEuler< T_Equation, N >::fEquation_Rhs

private

Definition at line 98 of file G4TExplicitEuler.hh.

◆ fFinalPoint

G4ThreeVector G4TMagErrorStepper< G4TExplicitEuler< T_Equation, N > , T_Equation, N >::fFinalPoint

privateinherited

Definition at line 76 of file G4TMagErrorStepper.hh.

◆ fInitialPoint

G4ThreeVector G4TMagErrorStepper< G4TExplicitEuler< T_Equation, N > , T_Equation, N >::fInitialPoint

privateinherited

Definition at line 76 of file G4TMagErrorStepper.hh.

◆ fIntegrationOrder

G4int G4MagIntegratorStepper::fIntegrationOrder = -1

privateinherited

Definition at line 134 of file G4MagIntegratorStepper.hh.

◆ fIsFSAL

G4bool G4MagIntegratorStepper::fIsFSAL = false

privateinherited

Definition at line 136 of file G4MagIntegratorStepper.hh.

◆ fMidPoint

G4ThreeVector G4TMagErrorStepper< G4TExplicitEuler< T_Equation, N > , T_Equation, N >::fMidPoint

privateinherited

Definition at line 76 of file G4TMagErrorStepper.hh.

◆ fNoIntegrationVariables

const G4int G4MagIntegratorStepper::fNoIntegrationVariables = 0

privateinherited

Definition at line 125 of file G4MagIntegratorStepper.hh.

◆ fNoRHSCalls

unsigned long G4MagIntegratorStepper::fNoRHSCalls = 0UL

mutableprivateinherited

Definition at line 128 of file G4MagIntegratorStepper.hh.

◆ fNoStateVariables

const G4int G4MagIntegratorStepper::fNoStateVariables = 0

privateinherited

Definition at line 126 of file G4MagIntegratorStepper.hh.

◆ IntegratorCorrection

template<class T_Equation , int N>

constexpr double G4TExplicitEuler< T_Equation, N >::IntegratorCorrection = 1.

staticconstexpr

Definition at line 60 of file G4TExplicitEuler.hh.

◆ yInitial

G4double G4TMagErrorStepper< G4TExplicitEuler< T_Equation, N > , T_Equation, N >::yInitial[N< 8 ? 8 :N]

privateinherited

Definition at line 80 of file G4TMagErrorStepper.hh.

◆ yMiddle

G4double G4TMagErrorStepper< G4TExplicitEuler< T_Equation, N > , T_Equation, N >::yMiddle[N< 8 ? 8 :N]

privateinherited

Definition at line 81 of file G4TMagErrorStepper.hh.

◆ yOneStep

G4double G4TMagErrorStepper< G4TExplicitEuler< T_Equation, N > , T_Equation, N >::yOneStep[N< 8 ? 8 :N]

privateinherited

Definition at line 83 of file G4TMagErrorStepper.hh.

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

source/geometry/magneticfield/include/G4TExplicitEuler.hh

Public Member Functions

Static Public Attributes

Protected Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4TExplicitEuler()

◆ ~G4TExplicitEuler()

Member Function Documentation

◆ DistChord()

◆ DumbStepper()

◆ GetEquationOfMotion() [1/2]

◆ GetEquationOfMotion() [2/2]

◆ GetfNoRHSCalls()

◆ GetNumberOfStateVariables()

◆ GetNumberOfVariables()

◆ IntegrationOrder()

◆ IntegratorOrder()

◆ IsFSAL()

◆ NormalisePolarizationVector()

◆ NormaliseTangentVector()

◆ ResetfNORHSCalls()

◆ RightHandSide() [1/3]

◆ RightHandSide() [2/3]

◆ RightHandSide() [3/3]

◆ SetEquationOfMotion()

◆ SetFSAL()

◆ SetIntegrationOrder()

◆ Stepper()

Field Documentation

◆ dydxMid

◆ fEquation_Rhs

◆ fFinalPoint

◆ fInitialPoint

◆ fIntegrationOrder

◆ fIsFSAL

◆ fMidPoint

◆ fNoIntegrationVariables

◆ fNoRHSCalls

◆ fNoStateVariables

◆ IntegratorCorrection

◆ yInitial

◆ yMiddle

◆ yOneStep