G4HelixMixedStepper Class Reference

#include <G4HelixMixedStepper.hh>

Inheritance diagram for G4HelixMixedStepper:

Public Member Functions
G4double	DistChord () const
void	DumbStepper (const G4double y[], G4ThreeVector Bfld, G4double h, G4double yout[])
	G4HelixMixedStepper (G4Mag_EqRhs *EqRhs, G4int StepperNumber=-1, G4double Angle_threshold=-1.0)
G4double	GetAngleThreshold ()
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	PrintCalls ()
void	ResetfNORHSCalls ()
void	RightHandSide (const G4double y[], G4double dydx[]) const
void	RightHandSide (const G4double y[], G4double dydx[], G4double field[]) const
void	SetAngleThreshold (G4double val)
void	SetEquationOfMotion (G4EquationOfMotion *newEquation)
G4MagIntegratorStepper *	SetupStepper (G4Mag_EqRhs *EqRhs, G4int StepperName)
void	SetVerbose (G4int newvalue)
void	Stepper (const G4double y[], const G4double dydx[], G4double h, G4double yout[], G4double yerr[])
	~G4HelixMixedStepper ()

Protected Member Functions
void	AdvanceHelix (const G4double yIn[], G4ThreeVector Bfld, G4double h, G4double yHelix[], G4double yHelix2[]=0)
G4double	GetAngCurve () const
G4double	GetCurve () const
G4double	GetInverseCurve (const G4double Momentum, const G4double Bmag)
G4double	GetRadHelix () const
void	LinearStep (const G4double yIn[], G4double h, G4double yHelix[]) const
void	MagFieldEvaluate (const G4double y[], G4ThreeVector &Bfield)
void	SetAngCurve (const G4double Ang)
void	SetCurve (const G4double Curve)
void	SetFSAL (G4bool flag=true)
void	SetIntegrationOrder (G4int order)
void	SetRadHelix (const G4double Rad)

Private Attributes
G4double	fAngCurve = 0.0
G4double	fAngle_threshold = -1.0
G4EquationOfMotion *	fEquation_Rhs = nullptr
G4int	fIntegrationOrder = -1
G4bool	fIsFSAL = false
const G4int	fNoIntegrationVariables = 0
unsigned long	fNoRHSCalls = 0UL
const G4int	fNoStateVariables = 0
G4int	fNumCallsHelix = 0
G4int	fNumCallsRK4 = 0
G4Mag_EqRhs *	fPtrMagEqOfMot = nullptr
G4double	frCurve = 0.0
G4double	frHelix = 0.0
G4MagIntegratorStepper *	fRK4Stepper = nullptr
G4int	fStepperNumber = -1
G4int	fVerbose = 0
G4ThreeVector	yFinal
G4ThreeVector	yInitial
G4ThreeVector	yMidPoint

Static Private Attributes
static const G4double	fUnitConstant = 0.299792458*(GeV/(tesla*m))

Detailed Description

Definition at line 62 of file G4HelixMixedStepper.hh.

Constructor & Destructor Documentation

G4HelixMixedStepper()

G4HelixMixedStepper::G4HelixMixedStepper	(	G4Mag_EqRhs *	EqRhs,
		G4int	StepperNumber = -1,
		G4double	Angle_threshold = -1.0
	)

Definition at line 64 of file G4HelixMixedStepper.cc.

  : G4MagHelicalStepper(EqRhs)
{
   if( angleThreshold < 0.0 )
   {
     fAngle_threshold = (1.0/3.0)*pi;
   }
   else
   {
     fAngle_threshold = angleThreshold;
   }
 
   if(stepperNumber<0)
   {
     // stepperNumber = 4;  // Default is RK4   (original)      
     stepperNumber = 745;   // Default is DormandPrince745 (ie DoPri5)
     // stepperNumber = 8;  // Default is CashKarp
   }
 
   fStepperNumber = stepperNumber; // Store the choice
   fRK4Stepper =  SetupStepper(EqRhs, fStepperNumber);
}

References fAngle_threshold, fRK4Stepper, fStepperNumber, pi, and SetupStepper().

~G4HelixMixedStepper()

G4HelixMixedStepper::~G4HelixMixedStepper

(

)

Definition at line 91 of file G4HelixMixedStepper.cc.

{  
  delete fRK4Stepper;
  if (fVerbose>0) { PrintCalls(); }
}

References fRK4Stepper, fVerbose, and PrintCalls().

Member Function Documentation

AdvanceHelix()

void G4MagHelicalStepper::AdvanceHelix ( const G4double  yIn[], G4ThreeVector  Bfld, G4double  h, G4double  yHelix[], G4double  yHelix2[] = 0  )

protectedinherited

Definition at line 57 of file G4MagHelicalStepper.cc.

{
  // const G4int    nvar = 6;
 
  // OLD  const G4double approc_limit = 0.05;
  // OLD  approc_limit = 0.05 gives max.error=x^5/5!=(0.05)^5/5!=2.6*e-9
  // NEW  approc_limit = 0.005 gives max.error=x^5/5!=2.6*e-14
 
  const G4double approc_limit = 0.005;
  G4ThreeVector  Bnorm, B_x_P, vperp, vpar;
 
  G4double B_d_P;
  G4double B_v_P;
  G4double Theta;
  G4double R_1;
  G4double R_Helix;
  G4double CosT2, SinT2, CosT, SinT;
  G4ThreeVector positionMove, endTangent;
 
  G4double Bmag = Bfld.mag();
  const G4double* pIn = yIn+3;
  G4ThreeVector initVelocity = G4ThreeVector( pIn[0], pIn[1], pIn[2]);
  G4double      velocityVal = initVelocity.mag();
  G4ThreeVector initTangent = (1.0/velocityVal) * initVelocity;
  
  R_1 = GetInverseCurve(velocityVal,Bmag);
 
  // for too small magnetic fields there is no curvature
  // (include momentum here) FIXME
 
  if( (std::fabs(R_1) < 1e-10)||(Bmag<1e-12) )
  {
    LinearStep( yIn, h, yHelix );
 
    // Store and/or calculate parameters for chord distance
 
    SetAngCurve(1.);     
    SetCurve(h);
    SetRadHelix(0.);
  }
  else
  {
    Bnorm = (1.0/Bmag)*Bfld;
 
    // calculate the direction of the force
    
    B_x_P = Bnorm.cross(initTangent);
 
    // parallel and perp vectors
 
    B_d_P = Bnorm.dot(initTangent); // this is the fraction of P parallel to B
 
    vpar = B_d_P * Bnorm;       // the component parallel      to B
    vperp= initTangent - vpar;  // the component perpendicular to B
    
    B_v_P  = std::sqrt( 1 - B_d_P * B_d_P); // Fraction of P perp to B
 
    // calculate  the stepping angle
  
    Theta   = R_1 * h; // * B_v_P;
 
    // Trigonometrix
      
    if( std::fabs(Theta) > approc_limit )
    {
       SinT     = std::sin(Theta);
       CosT     = std::cos(Theta);
    }
    else
    {
      G4double Theta2 = Theta*Theta;
      G4double Theta3 = Theta2 * Theta;
      G4double Theta4 = Theta2 * Theta2;
      SinT     = Theta - 1.0/6.0 * Theta3;
      CosT     = 1 - 0.5 * Theta2 + 1.0/24.0 * Theta4;
    }
 
    // the actual "rotation"
 
    G4double R = 1.0 / R_1;
 
    positionMove  = R * ( SinT * vperp + (1-CosT) * B_x_P) + h * vpar;
    endTangent    = CosT * vperp + SinT * B_x_P + vpar;
 
    // Store the resulting position and tangent
 
    yHelix[0]   = yIn[0] + positionMove.x(); 
    yHelix[1]   = yIn[1] + positionMove.y(); 
    yHelix[2]   = yIn[2] + positionMove.z();
    yHelix[3] = velocityVal * endTangent.x();
    yHelix[4] = velocityVal * endTangent.y();
    yHelix[5] = velocityVal * endTangent.z();
 
    // Store 2*h step Helix if exist
 
    if(yHelix2)
    {
      SinT2     = 2.0 * SinT * CosT;
      CosT2     = 1.0 - 2.0 * SinT * SinT;
      endTangent    = (CosT2 * vperp + SinT2 * B_x_P + vpar);
      positionMove  = R * ( SinT2 * vperp + (1-CosT2) * B_x_P) + h*2 * vpar;
      
      yHelix2[0]   = yIn[0] + positionMove.x(); 
      yHelix2[1]   = yIn[1] + positionMove.y(); 
      yHelix2[2]   = yIn[2] + positionMove.z(); 
      yHelix2[3] = velocityVal * endTangent.x();
      yHelix2[4] = velocityVal * endTangent.y();
      yHelix2[5] = velocityVal * endTangent.z();
    }
 
    // Store and/or calculate parameters for chord distance
 
    G4double ptan=velocityVal*B_v_P;
 
    G4double particleCharge = fPtrMagEqOfMot->FCof() / (eplus*c_light); 
    R_Helix =std::abs( ptan/(fUnitConstant  * particleCharge*Bmag));
       
    SetAngCurve(std::abs(Theta));
    SetCurve(std::abs(R));
    SetRadHelix(R_Helix);
  }
}

References source.hepunit::c_light, CLHEP::Hep3Vector::cross(), CLHEP::Hep3Vector::dot(), eplus, G4Mag_EqRhs::FCof(), G4MagHelicalStepper::fPtrMagEqOfMot, G4MagHelicalStepper::fUnitConstant, G4MagHelicalStepper::GetInverseCurve(), G4MagHelicalStepper::LinearStep(), CLHEP::Hep3Vector::mag(), G4MagHelicalStepper::SetAngCurve(), G4MagHelicalStepper::SetCurve(), G4MagHelicalStepper::SetRadHelix(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4ExactHelixStepper::DumbStepper(), G4HelixExplicitEuler::DumbStepper(), G4HelixHeum::DumbStepper(), G4HelixImplicitEuler::DumbStepper(), DumbStepper(), G4HelixSimpleRunge::DumbStepper(), G4HelixExplicitEuler::Stepper(), G4ExactHelixStepper::Stepper(), and Stepper().

DistChord()

G4double G4HelixMixedStepper::DistChord ( ) const

virtual

Implements G4MagIntegratorStepper.

Definition at line 178 of file G4HelixMixedStepper.cc.

{
  // Implementation : must check whether h/R > 2 pi  !!
  //   If( h/R <  pi) use G4LineSection::DistLine
  //   Else           DistChord=R_helix
  //
  G4double distChord;
  G4double Ang_curve=GetAngCurve();
  
  if(Ang_curve<=pi)
  {
    distChord=GetRadHelix()*(1-std::cos(0.5*Ang_curve));
  }
  else
  {
    if(Ang_curve<twopi)
    {
      distChord=GetRadHelix()*(1+std::cos(0.5*(twopi-Ang_curve)));
    }
    else
    {
      distChord=2.*GetRadHelix();
    }
  }
  
  return distChord;
}

References G4MagHelicalStepper::GetAngCurve(), G4MagHelicalStepper::GetRadHelix(), pi, and twopi.

DumbStepper()

void G4HelixMixedStepper::DumbStepper ( const G4double  y[], G4ThreeVector  Bfld, G4double  h, G4double  yout[]  )

virtual

Implements G4MagHelicalStepper.

Definition at line 169 of file G4HelixMixedStepper.cc.

{
  AdvanceHelix(yIn, Bfld, h, yOut);
}

References G4MagHelicalStepper::AdvanceHelix().

GetAngCurve()

G4double G4MagHelicalStepper::GetAngCurve ( ) const

inlineprotectedinherited

Referenced by G4ExactHelixStepper::DistChord(), G4HelixExplicitEuler::DistChord(), DistChord(), G4MagHelicalStepper::DistChord(), and G4HelixExplicitEuler::Stepper().

GetAngleThreshold()

G4double G4HelixMixedStepper::GetAngleThreshold ( )

inline

Definition at line 99 of file G4HelixMixedStepper.hh.

{ return fAngle_threshold; }

References fAngle_threshold.

GetCurve()

G4double G4MagHelicalStepper::GetCurve ( ) const

inlineprotectedinherited

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

GetInverseCurve()

G4double G4MagHelicalStepper::GetInverseCurve ( const G4double  Momentum, const G4double  Bmag  )

inlineprotectedinherited

Referenced by G4MagHelicalStepper::AdvanceHelix(), and Stepper().

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

GetRadHelix()

G4double G4MagHelicalStepper::GetRadHelix ( ) const

inlineprotectedinherited

Referenced by G4ExactHelixStepper::DistChord(), G4HelixExplicitEuler::DistChord(), DistChord(), and G4MagHelicalStepper::DistChord().

IntegrationOrder()

G4int G4MagIntegratorStepper::IntegrationOrder ( )

inlineinherited

IntegratorOrder()

G4int G4HelixMixedStepper::IntegratorOrder ( ) const

inlinevirtual

Implements G4MagIntegratorStepper.

Definition at line 100 of file G4HelixMixedStepper.hh.

{ return 4; }

IsFSAL()

G4bool G4MagIntegratorStepper::IsFSAL ( ) const

inlineinherited

LinearStep()

void G4MagHelicalStepper::LinearStep ( const G4double  yIn[], G4double  h, G4double  yHelix[]  ) const

inlineprotectedinherited

Referenced by G4MagHelicalStepper::AdvanceHelix().

MagFieldEvaluate()

void G4MagHelicalStepper::MagFieldEvaluate ( const G4double  y[], G4ThreeVector &  Bfield  )

inlineprotectedinherited

Referenced by G4HelixHeum::DumbStepper(), G4HelixImplicitEuler::DumbStepper(), G4HelixSimpleRunge::DumbStepper(), G4HelixExplicitEuler::Stepper(), G4ExactHelixStepper::Stepper(), Stepper(), and G4MagHelicalStepper::Stepper().

NormalisePolarizationVector()

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

inlineinherited

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

NormaliseTangentVector()

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

inlineinherited

PrintCalls()

void G4HelixMixedStepper::PrintCalls

(

)

Definition at line 207 of file G4HelixMixedStepper.cc.

{
  G4cout << "In HelixMixedStepper::Number of calls to smallStepStepper = "
         << fNumCallsRK4
         << "  and Number of calls to Helix = " << fNumCallsHelix << G4endl;
}

References fNumCallsHelix, fNumCallsRK4, G4cout, and G4endl.

Referenced by ~G4HelixMixedStepper().

ResetfNORHSCalls()

void G4MagIntegratorStepper::ResetfNORHSCalls ( )

inlineinherited

RightHandSide() [1/2]

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

inlineinherited

Referenced by G4MagInt_Driver::AccurateAdvance(), G4OldMagIntDriver::AccurateAdvance(), G4ImplicitEuler::DumbStepper(), G4SimpleHeum::DumbStepper(), G4SimpleRunge::DumbStepper(), G4ClassicalRK4::DumbStepper(), G4MagInt_Driver::GetDerivatives(), G4OldMagIntDriver::GetDerivatives(), 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().

RightHandSide() [2/2]

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

inlineinherited

SetAngCurve()

void G4MagHelicalStepper::SetAngCurve ( const G4double  Ang )

inlineprotectedinherited

Referenced by G4MagHelicalStepper::AdvanceHelix(), G4HelixExplicitEuler::Stepper(), and Stepper().

SetAngleThreshold()

void G4HelixMixedStepper::SetAngleThreshold ( G4double  val )

inline

Definition at line 98 of file G4HelixMixedStepper.hh.

{ fAngle_threshold = val; }

References fAngle_threshold.

SetCurve()

void G4MagHelicalStepper::SetCurve ( const G4double  Curve )

inlineprotectedinherited

Referenced by G4MagHelicalStepper::AdvanceHelix(), and Stepper().

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

SetRadHelix()

void G4MagHelicalStepper::SetRadHelix ( const G4double  Rad )

inlineprotectedinherited

Referenced by G4MagHelicalStepper::AdvanceHelix().

SetupStepper()

G4MagIntegratorStepper * G4HelixMixedStepper::SetupStepper	(	G4Mag_EqRhs *	EqRhs,
		G4int	StepperName
	)

Definition at line 216 of file G4HelixMixedStepper.cc.

{
  G4MagIntegratorStepper* pStepper;
  if (fVerbose>0) G4cout << " G4HelixMixedStepper: ";
  switch ( StepperNumber )
  {
      // Robust, classic method
      case 4:
        pStepper = new G4ClassicalRK4( pE );
        if (fVerbose>0) G4cout << "G4ClassicalRK4";
        break;
 
      // Steppers with embedded estimation of error
      case 8:
        pStepper = new G4CashKarpRKF45( pE );
        if (fVerbose>0) G4cout << "G4CashKarpRKF45";
        break;
      case 13:
        pStepper = new G4NystromRK4( pE );
        if (fVerbose>0) G4cout << "G4NystromRK4";
        break;
        
      // Lowest order RK Stepper - experimental
      case 1:
        pStepper = new G4ImplicitEuler( pE );
        if (fVerbose>0) G4cout << "G4ImplicitEuler";
        break;
 
      // Lower order RK Steppers - ok overall, good for uneven fields        
      case 2:
        pStepper = new G4SimpleRunge( pE );
        if (fVerbose>0) G4cout << "G4SimpleRunge";
        break;
      case 3:
        pStepper = new G4SimpleHeum( pE );
        if (fVerbose>0) G4cout << "G4SimpleHeum";
        break;
      case 23:
        pStepper = new G4BogackiShampine23( pE );
        if (fVerbose>0) G4cout << "G4BogackiShampine23";
        break;
 
      // Higher order RK Steppers
      // for smoother fields and high accuracy requirements 
      case 45:
        pStepper = new G4BogackiShampine45( pE );
        if (fVerbose>0) G4cout << "G4BogackiShampine45";
        break;
      case 145:
        pStepper = new G4TsitourasRK45( pE );
        if (fVerbose>0) G4cout << "G4TsitourasRK45";
        break;
      case 745:
        pStepper = new G4DormandPrince745( pE );
        if (fVerbose>0) G4cout << "G4DormandPrince745";
        break;
 
      // Helical Steppers
      case 6:
        pStepper = new G4HelixImplicitEuler( pE );
        if (fVerbose>0) G4cout << "G4HelixImplicitEuler";
        break;
      case 7:
        pStepper = new G4HelixSimpleRunge( pE );
        if (fVerbose>0) G4cout << "G4HelixSimpleRunge";
        break;
      case 5:
        pStepper = new G4HelixExplicitEuler( pE );
        if (fVerbose>0) G4cout << "G4HelixExplicitEuler";
        break; //  Since Helix Explicit is used for long steps,
               // this is useful only to measure overhead.
      // Exact Helix - likely good only for cases of
      //            i) uniform field (potentially over small distances)
      //           ii) segmented uniform field (maybe)
      case 9:
        pStepper = new G4ExactHelixStepper( pE );
        if (fVerbose>0) G4cout << "G4ExactHelixStepper";
        break;
      case 10:
        pStepper = new G4RKG3_Stepper( pE );
        if (fVerbose>0) G4cout << "G4RKG3_Stepper";
        break;
 
      // Low Order Steppers - not good except for very weak fields
      case 11:
        pStepper = new G4ExplicitEuler( pE );
        if (fVerbose>0) G4cout << "G4ExplicitEuler";
        break;
      case 12:
        pStepper = new G4ImplicitEuler( pE );
        if (fVerbose>0) G4cout << "G4ImplicitEuler";
        break;
 
      case 0:
      case -1:
      default:
         pStepper = new G4DormandPrince745( pE ); // Was G4ClassicalRK4( pE );
        if (fVerbose>0) G4cout << "G4DormandPrince745 (Default)";
        break;
  }
 
  if(fVerbose>0)
  {
    G4cout << " chosen as stepper for small steps in G4HelixMixedStepper."
           << G4endl;
  }
 
  return pStepper;
}

References fVerbose, G4cout, and G4endl.

Referenced by G4HelixMixedStepper().

SetVerbose()

void G4HelixMixedStepper::SetVerbose ( G4int  newvalue )

inline

Definition at line 91 of file G4HelixMixedStepper.hh.

{ fVerbose = newvalue; }

References fVerbose.

Stepper()

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

virtual

Reimplemented from G4MagHelicalStepper.

Definition at line 98 of file G4HelixMixedStepper.cc.

{
  // Estimation of the Stepping Angle
  //
  G4ThreeVector Bfld;
  MagFieldEvaluate(yInput, Bfld);
  
  G4double Bmag = Bfld.mag();
  const G4double* pIn = yInput+3;
  G4ThreeVector initVelocity = G4ThreeVector( pIn[0], pIn[1], pIn[2] );
  G4double velocityVal = initVelocity.mag();
 
  const G4double R_1 = std::abs(GetInverseCurve(velocityVal,Bmag));
    // curv = inverse Radius
  G4double Ang_curve = R_1 * Step;
  // SetAngCurve(Ang_curve);
  // SetCurve(std::abs(1/R_1));
 
  if(Ang_curve < fAngle_threshold)
  {
    ++fNumCallsRK4;
    fRK4Stepper->Stepper(yInput,dydx,Step,yOut,yErr);
  }
  else
  {
    constexpr G4int nvar    = 6 ;
    constexpr G4int nvarMax = 8 ;
    G4double      yTemp[nvarMax], yIn[nvarMax], yTemp2[nvarMax];
    G4ThreeVector Bfld_midpoint;
    
    SetAngCurve(Ang_curve);
    SetCurve(std::abs(1.0/R_1));
    ++fNumCallsHelix;
    
    // Saving yInput because yInput and yOut can be aliases for same array
    //
    for(G4int i=0; i<nvar; ++i)
    {
      yIn[i]=yInput[i];
    }
    
    G4double halfS = Step * 0.5;
 
    // 1. Do first half step and full step
    //
    AdvanceHelix(yIn, Bfld, halfS, yTemp, yTemp2); // yTemp2 for s=2*h (halfS)
 
    MagFieldEvaluate(yTemp, Bfld_midpoint) ;
 
    // 2. Do second half step - with revised field
    // NOTE: Could avoid this call if  'Bfld_midpoint == Bfld'
    //       or diff 'almost' zero
    //
    AdvanceHelix(yTemp, Bfld_midpoint, halfS, yOut);
      // Not requesting y at s=2*h (halfS)
    
    // 3. Estimate the integration error
    //    should be (nearly) zero if Bfield= constant
    //
    for(G4int i=0; i<nvar; ++i)
    {
      yErr[i] = yOut[i] - yTemp2[i];
    }
  }
}

References G4MagHelicalStepper::AdvanceHelix(), fAngle_threshold, fNumCallsHelix, fNumCallsRK4, fRK4Stepper, G4MagHelicalStepper::GetInverseCurve(), CLHEP::Hep3Vector::mag(), G4MagHelicalStepper::MagFieldEvaluate(), G4MagHelicalStepper::SetAngCurve(), G4MagHelicalStepper::SetCurve(), and G4MagIntegratorStepper::Stepper().

Field Documentation

fAngCurve

G4double G4MagHelicalStepper::fAngCurve = 0.0

privateinherited

Definition at line 120 of file G4MagHelicalStepper.hh.

fAngle_threshold

G4double G4HelixMixedStepper::fAngle_threshold = -1.0

private

Definition at line 109 of file G4HelixMixedStepper.hh.

Referenced by G4HelixMixedStepper(), GetAngleThreshold(), SetAngleThreshold(), and Stepper().

fEquation_Rhs

G4EquationOfMotion* G4MagIntegratorStepper::fEquation_Rhs = nullptr

privateinherited

Definition at line 124 of file G4MagIntegratorStepper.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.

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.

fNumCallsHelix

G4int G4HelixMixedStepper::fNumCallsHelix = 0

private

Definition at line 117 of file G4HelixMixedStepper.hh.

Referenced by PrintCalls(), and Stepper().

fNumCallsRK4

G4int G4HelixMixedStepper::fNumCallsRK4 = 0

private

Definition at line 116 of file G4HelixMixedStepper.hh.

Referenced by PrintCalls(), and Stepper().

fPtrMagEqOfMot

G4Mag_EqRhs* G4MagHelicalStepper::fPtrMagEqOfMot = nullptr

privateinherited

Definition at line 116 of file G4MagHelicalStepper.hh.

Referenced by G4MagHelicalStepper::AdvanceHelix().

frCurve

G4double G4MagHelicalStepper::frCurve = 0.0

privateinherited

Definition at line 121 of file G4MagHelicalStepper.hh.

frHelix

G4double G4MagHelicalStepper::frHelix = 0.0

privateinherited

Definition at line 122 of file G4MagHelicalStepper.hh.

fRK4Stepper

G4MagIntegratorStepper* G4HelixMixedStepper::fRK4Stepper = nullptr

private

Definition at line 104 of file G4HelixMixedStepper.hh.

Referenced by G4HelixMixedStepper(), Stepper(), and ~G4HelixMixedStepper().

fStepperNumber

G4int G4HelixMixedStepper::fStepperNumber = -1

private

Definition at line 106 of file G4HelixMixedStepper.hh.

Referenced by G4HelixMixedStepper().

fUnitConstant

const G4double G4MagHelicalStepper::fUnitConstant = 0.299792458*(GeV/(tesla*m))

staticprivateinherited

Definition at line 113 of file G4MagHelicalStepper.hh.

Referenced by G4MagHelicalStepper::AdvanceHelix().

fVerbose

G4int G4HelixMixedStepper::fVerbose = 0

private

Definition at line 114 of file G4HelixMixedStepper.hh.

Referenced by SetupStepper(), SetVerbose(), and ~G4HelixMixedStepper().

yFinal

G4ThreeVector G4MagHelicalStepper::yFinal

privateinherited

Definition at line 123 of file G4MagHelicalStepper.hh.

yInitial

G4ThreeVector G4MagHelicalStepper::yInitial

privateinherited

Definition at line 123 of file G4MagHelicalStepper.hh.

yMidPoint

G4ThreeVector G4MagHelicalStepper::yMidPoint

privateinherited

Definition at line 123 of file G4MagHelicalStepper.hh.

---

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

• source/geometry/magneticfield/include/G4HelixMixedStepper.hh
• source/geometry/magneticfield/src/G4HelixMixedStepper.cc