G4DoLoMcPriRK34 Class Reference

G4DoLoMcPriRK34 implements the Dormand-Lockyer-McGorrigan-Prince-6-3-4 non-FSAL method ( 6 stage, 3rd & 4th order embedded Runge-Kutta method ). More...

#include <G4DoLoMcPriRK34.hh>

Inheritance diagram for G4DoLoMcPriRK34:

Public Member Functions
	G4DoLoMcPriRK34 (G4EquationOfMotion *EqRhs, G4int numberOfVariables=6, G4bool primary=true)
	~G4DoLoMcPriRK34 () override
	G4DoLoMcPriRK34 (const G4DoLoMcPriRK34 &)=delete
G4DoLoMcPriRK34 &	operator= (const G4DoLoMcPriRK34 &)=delete
void	Stepper (const G4double y[], const G4double dydx[], G4double h, G4double yout[], G4double yerr[]) override
void	SetupInterpolation ()
void	Interpolate (const G4double yInput[], const G4double dydx[], const G4double Step, G4double yOut[], G4double tau)
void	Interpolate (G4double tau, G4double yOut[])
G4double	DistChord () const override
G4int	IntegratorOrder () const override
G4StepperType	StepperType () const override
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
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
G4int	IntegrationOrder ()
G4EquationOfMotion *	GetEquationOfMotion ()
const G4EquationOfMotion *	GetEquationOfMotion () const
void	SetEquationOfMotion (G4EquationOfMotion *newEquation)
unsigned long	GetfNoRHSCalls ()
void	ResetfNORHSCalls ()
G4bool	IsFSAL () const
G4bool	isQSS () const
void	SetIsQSS (G4bool val)

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

Detailed Description

G4DoLoMcPriRK34 implements the Dormand-Lockyer-McGorrigan-Prince-6-3-4 non-FSAL method ( 6 stage, 3rd & 4th order embedded Runge-Kutta method ).

Definition at line 46 of file G4DoLoMcPriRK34.hh.

Constructor & Destructor Documentation

G4DoLoMcPriRK34() [1/2]

G4DoLoMcPriRK34::G4DoLoMcPriRK34	(	G4EquationOfMotion *	EqRhs,
		G4int	numberOfVariables = 6,
		G4bool	primary = true )

Constructor for G4DoLoMcPriRK34.

Parameters

[in]	EqRhs	Pointer to the provided equation of motion.
[in]	numberOfVariables	The number of integration variables.
[in]	primary	Flag for initialisation of the auxiliary stepper.

Definition at line 37 of file G4DoLoMcPriRK34.cc.

   : G4MagIntegratorStepper(EqRhs, noIntegrationVariables)
{
   const G4int numberOfVariables = noIntegrationVariables;
   
   // New Chunk of memory being created for use by the Stepper
   
   // aki - for storing intermediate RHS
   //
   ak2 = new G4double[numberOfVariables];
   ak3 = new G4double[numberOfVariables];
   ak4 = new G4double[numberOfVariables];
   ak5 = new G4double[numberOfVariables];
   ak6 = new G4double[numberOfVariables];
   
   yTemp = new G4double[numberOfVariables] ;
   yIn = new G4double[numberOfVariables] ;
      
   fLastInitialVector = new G4double[numberOfVariables] ;
   fLastFinalVector = new G4double[numberOfVariables] ;
   fLastDyDx = new G4double[numberOfVariables];
   
   fMidVector = new G4double[numberOfVariables];
   fMidError = new G4double[numberOfVariables];
   if( primary )
   {
     fAuxStepper = new G4DoLoMcPriRK34(EqRhs, numberOfVariables, !primary);
   }
}

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

~G4DoLoMcPriRK34()

G4DoLoMcPriRK34::~G4DoLoMcPriRK34 ( )

override

Destructor.

Definition at line 71 of file G4DoLoMcPriRK34.cc.

{
   // clear all previously allocated memory for Stepper and DistChord
 
   delete [] ak2;
   delete [] ak3;
   delete [] ak4;
   delete [] ak5;
   delete [] ak6;
   
   delete [] yTemp;
   delete [] yIn;
   
   delete [] fLastInitialVector;
   delete [] fLastFinalVector;
   delete [] fLastDyDx;
   delete [] fMidVector;
   delete [] fMidError;
   
   delete fAuxStepper;
}

G4DoLoMcPriRK34() [2/2]

G4DoLoMcPriRK34::G4DoLoMcPriRK34 ( const G4DoLoMcPriRK34 & )

delete

Copy constructor and assignment operator not allowed.

Member Function Documentation

DistChord()

G4double G4DoLoMcPriRK34::DistChord ( ) const

overridevirtual

Returns the distance from chord line.

Implements G4MagIntegratorStepper.

Definition at line 201 of file G4DoLoMcPriRK34.cc.

{
   G4double distLine, distChord;
   G4ThreeVector initialPoint, finalPoint, midPoint;
   
   // Store last initial and final points
   // (they will be overwritten in self-Stepper call!)
   //
   initialPoint = G4ThreeVector( fLastInitialVector[0],
                                 fLastInitialVector[1], fLastInitialVector[2] );
   finalPoint   = G4ThreeVector( fLastFinalVector[0],
                                 fLastFinalVector[1],  fLastFinalVector[2] );
   
   // Do half a Step using StepNoErr
   
   fAuxStepper->Stepper( fLastInitialVector, fLastDyDx, 0.5 * fLastStepLength,
                         fMidVector, fMidError );
   
   midPoint = G4ThreeVector( fMidVector[0], fMidVector[1], fMidVector[2]);
   
   // Use stored values of Initial and Endpoint + new Midpoint to evaluate
   // distance of Chord
   //
   if (initialPoint != finalPoint)
   {
     distLine  = G4LineSection::Distline( midPoint, initialPoint, finalPoint );
     distChord = distLine;
   }
   else
   {
     distChord = (midPoint-initialPoint).mag();
   }
   return distChord;
}

IntegratorOrder()

G4int G4DoLoMcPriRK34::IntegratorOrder ( ) const

inlineoverridevirtual

Returns the order, 3, of integration.

Implements G4MagIntegratorStepper.

Definition at line 117 of file G4DoLoMcPriRK34.hh.

{ return 3; }

Interpolate() [1/2]

void G4DoLoMcPriRK34::Interpolate	(	const G4double	yInput[],
		const G4double	dydx[],
		const G4double	Step,
		G4double	yOut[],
		G4double	tau )

Calculates the output at the tau fraction of Step.

Parameters

[in]	yInput	Starting values array of integration variables.
[in]	dydx	Derivatives array.
[in]	Step	The given step size.
[out]	yOut	Interpolation output.
[out]	tau	Fraction of step.

Definition at line 244 of file G4DoLoMcPriRK34.cc.

{
   G4double bf1, bf2, bf3, bf4, bf5, bf6;    
 
   const G4int numberOfVariables = GetNumberOfVariables();
   
   for(G4int i=0; i<numberOfVariables; ++i)
   {
     yIn[i]=yInput[i];
   }
   
   G4double tau_2 = tau*tau, tau_3 = tau*tau_2;
   
   // Calculating the polynomials (coefficients for the respective stages)
   //
   bf1 = -(162.0*tau_3 - 504.0*tau_2 + 551.0*tau - 238.0)/238.0 ,
   bf2 =  0.0 ,
   bf3 =  27.0*tau*(27.0*tau_2 - 70.0*tau + 51.0 )/385.0 ,
   bf4 = -27*tau*(27.0*tau_2 - 50.0*tau + 21.0)/85.0 ,
   bf5 =  7.0*tau*(2232.0*tau_2 - 4166.0*tau + 1785.0 )/3278.0 ,
   bf6 = tau*(tau - 1.0)*(387.0*tau - 238.0)/149.0 ;
   
   for( G4int i=0; i<numberOfVariables; ++i)
   {
     yOut[i] = yIn[i] + Step*tau*(bf1*dydx[i] + bf2*ak2[i] + bf3*ak3[i]
             + bf4*ak4[i] + bf5*ak5[i] + bf6*ak6[i] ) ;
   }
}

Referenced by Interpolate().

Interpolate() [2/2]

void G4DoLoMcPriRK34::Interpolate	(	G4double	tau,
		G4double	yOut[] )

Definition at line 236 of file G4DoLoMcPriRK34.cc.

{
  Interpolate( fLastInitialVector, fLastDyDx, fLastStepLength, yOut, tau );
}

operator=()

G4DoLoMcPriRK34 & G4DoLoMcPriRK34::operator= ( const G4DoLoMcPriRK34 & )

delete

SetupInterpolation()

void G4DoLoMcPriRK34::SetupInterpolation ( )

inline

Interface method for interpolation setup. Does nothing here.

Definition at line 91 of file G4DoLoMcPriRK34.hh.

{}

Stepper()

void G4DoLoMcPriRK34::Stepper ( const G4double y[], const G4double dydx[], G4double h, G4double yout[], G4double yerr[] )

overridevirtual

The stepper for the Runge Kutta integration. The stepsize is fixed, with the step size given by 'h'. Integrates ODE starting values y[0 to 6]. Outputs yout[] and its estimated error yerr[].

Parameters

[in]	y	Starting values array of integration variables.
[in]	dydx	Derivatives array.
[in]	h	The given step size.
[out]	yout	Integration output.
[out]	yerr	The estimated error.

Implements G4MagIntegratorStepper.

Definition at line 98 of file G4DoLoMcPriRK34.cc.

{
   G4int i;
   
   // The various constants defined on the basis of butcher tableu
   //
   const G4double b21 = 7.0/27.0 ,
                  b31 = 7.0/72.0 , 
                  b32 = 7.0/24.0 ,
   
                  b41 = 3043.0/3528.0 , 
                  b42 = -3757.0/1176.0 ,
                  b43 = 1445.0/441.0,
   
                  b51 = 17617.0/11662.0 ,
                  b52 = -4023.0/686.0 , 
                  b53 = 9372.0/1715.0 ,
                  b54 = -66.0/595.0 ,
   
                  b61 = 29.0/238.0 ,
                  b62 = 0.0 , 
                  b63 = 216.0/385.0 ,
                  b64 = 54.0/85.0 ,
                  b65 = -7.0/22.0 ,
 
                  dc1 = 363.0/2975.0 - b61 ,
                  dc2 = 0.0 - b62 ,
                  dc3 = 981.0/1750.0 - b63,
                  dc4 = 2709.0/4250.0 - b64 ,
                  dc5 = -3.0/10.0 - b65 ,
                  dc6 = -1.0/50.0 ;        // end of declaration
 
   const G4int numberOfVariables = GetNumberOfVariables();
   
   // The number of variables to be integrated over
   //
   yOut[7] = yTemp[7]  = yIn[7];
 
   // Saving yInput because yInput and yOut can be aliases for same array
   //
   for(i=0; i<numberOfVariables; ++i)
   {
       yIn[i]=yInput[i];
   }
 
   // RightHandSide(yIn, DyDx) ;   // 1st stage - Not doing, getting passed
   
   for(i=0; i<numberOfVariables; ++i)
   {
       yTemp[i] = yIn[i] + b21*Step*DyDx[i] ;
   }
   RightHandSide(yTemp, ak2) ;              // 2nd stage
   
   for(i=0; i<numberOfVariables; ++i)
   {
       yTemp[i] = yIn[i] + Step*(b31*DyDx[i] + b32*ak2[i]) ;
   }
   RightHandSide(yTemp, ak3) ;              // 3rd stage
   
   for(i=0; i<numberOfVariables; ++i)
   {
       yTemp[i] = yIn[i] + Step*(b41*DyDx[i] + b42*ak2[i] + b43*ak3[i]) ;
   }
   RightHandSide(yTemp, ak4) ;              // 4th stage
   
   for(i=0; i<numberOfVariables; ++i)
   {
       yTemp[i] = yIn[i] + Step*(b51*DyDx[i] + b52*ak2[i]
                               + b53*ak3[i] + b54*ak4[i]) ;
   }
   RightHandSide(yTemp, ak5) ;              // 5th stage
   
   for(i=0; i<numberOfVariables; ++i)
   {
       yOut[i] = yIn[i] + Step*(b61*DyDx[i] + b62*ak2[i] + b63*ak3[i]
                              + b64*ak4[i] + b65*ak5[i]) ;
   }
   RightHandSide(yOut, ak6) ;              // 6th and Final stage
 
   for(i=0; i<numberOfVariables; ++i)
   {
       
       yErr[i] = Step*(dc1*DyDx[i] + dc2*ak2[i] + dc3*ak3[i] + dc4*ak4[i]
                     + dc5*ak5[i] + dc6*ak6[i] ) ;
 
       // Store Input and Final values, for possible use in calculating chord
       //
       fLastInitialVector[i] = yIn[i] ;
       fLastFinalVector[i]   = yOut[i];
       fLastDyDx[i]          = DyDx[i];
   }
   
   fLastStepLength = Step;
   
   return ;
}

StepperType()

G4StepperType G4DoLoMcPriRK34::StepperType ( ) const

inlineoverridevirtual

Returns the stepper type-ID, "kDoLoMcPriRK34".

Reimplemented from G4MagIntegratorStepper.

Definition at line 123 of file G4DoLoMcPriRK34.hh.

{ return kDoLoMcPriRK34; }

---

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

• G4DoLoMcPriRK34.hh
• G4DoLoMcPriRK34.cc