#include <G4MagIntegratorDriver.hh>

Inheritance diagram for G4MagInt_Driver:

Public Member Functions
virtual G4bool	AccurateAdvance (G4FieldTrack &y_current, G4double hstep, G4double eps, G4double hinitial=0.0) override

virtual G4double	AdvanceChordLimited (G4FieldTrack &track, G4double stepMax, G4double epsStep, G4double chordDistance) override

G4double	AdvanceChordLimitedImpl (G4FieldTrack &track, G4double hstep, G4double eps, G4double chordDistance)

G4double	ComputeAndSetErrcon ()

virtual G4double	ComputeNewStepSize (G4double errMaxNorm, G4double hstepCurrent) override

G4double	ComputeNewStepSize_WithinLimits (G4double errMaxNorm, G4double hstepCurrent)

G4double	ComputeNewStepSize_WithoutReductionLimit (G4double errMaxNorm, G4double hstepCurrent)

virtual G4bool	DoesReIntegrate () const override

	G4MagInt_Driver (const G4MagInt_Driver &)=delete

	G4MagInt_Driver (G4double hminimum, G4MagIntegratorStepper *pItsStepper, G4int numberOfComponents=6, G4int statisticsVerbosity=0)

virtual void	GetDerivatives (const G4FieldTrack &track, G4double dydx[], G4double field[]) const override

virtual void	GetDerivatives (const G4FieldTrack &y_curr, G4double dydx[]) const override

virtual G4EquationOfMotion *	GetEquationOfMotion () override

G4double	GetErrcon () const

G4double	GetFirstFraction ()

G4double	GetFractionLast ()

G4double	GetFractionNextEstimate ()

G4double	GetHmin () const

G4double	GetLastStepEstimateUnc ()

G4int	GetMaxNoSteps () const

G4int	GetNoCalls ()

G4int	GetNoMaxTrials ()

G4int	GetNoTrials ()

G4double	GetPgrow () const

G4double	GetPshrnk () const

G4double	GetSafety () const

G4double	GetSmallestFraction () const

virtual const G4MagIntegratorStepper *	GetStepper () const override

virtual G4MagIntegratorStepper *	GetStepper () override

virtual G4int	GetVerboseLevel () const override

G4double	Hmin () const

virtual void	OnComputeStep () override

void	OneGoodStep (G4double ystart[], const G4double dydx[], G4double &x, G4double htry, G4double eps, G4double &hdid, G4double &hnext)

virtual void	OnStartTracking () override

G4MagInt_Driver &	operator= (const G4MagInt_Driver &)=delete

G4bool	QuickAdvance (G4FieldTrack &y_posvel, const G4double dydx[], G4double hstep, G4double &dchord_step, G4double &dyerr_pos_sq, G4double &dyerr_mom_rel_sq)

virtual G4bool	QuickAdvance (G4FieldTrack &y_val, const G4double dydx[], G4double hstep, G4double &dchord_step, G4double &dyerr) override

virtual void	RenewStepperAndAdjust (G4MagIntegratorStepper *pItsStepper) override

void	ReSetParameters (G4double new_safety=0.9)

void	ResetStepEstimate ()

virtual void	SetEquationOfMotion (G4EquationOfMotion *equation) override

void	SetErrcon (G4double valEc)

void	SetFirstFraction (G4double fractFirst)

void	SetFractions_Last_Next (G4double fractLast=0.90, G4double fractNext=0.95)

void	SetHmin (G4double newval)

void	SetLastStepEstimateUnc (G4double stepEst)

void	SetMaxNoSteps (G4int val)

void	SetPgrow (G4double valPg)

void	SetPshrnk (G4double valPs)

void	SetSafety (G4double valS)

void	SetSmallestFraction (G4double val)

virtual void	SetVerboseLevel (G4int newLevel) override

void	StreamDelegateInfo (std::ostream &os) const

void	StreamInfo (std::ostream &os) const override

void	TestChordPrint (G4int noTrials, G4int lastStepTrial, G4double dChordStep, G4double fDeltaChord, G4double nextStepTrial)

virtual	~G4MagInt_Driver () override

Protected Member Functions
void	PrintStat_Aux (const G4FieldTrack &aFieldTrack, G4double requestStep, G4double actualStep, G4int subStepNo, G4double subStepSize, G4double dotVelocities)

void	PrintStatisticsReport ()

void	PrintStatus (const G4double StartArr, G4double xstart, const G4double CurrentArr, G4double xcurrent, G4double requestStep, G4int subStepNo)

void	PrintStatus (const G4FieldTrack &StartFT, const G4FieldTrack &CurrentFT, G4double requestStep, G4int subStepNo)

void	WarnEndPointTooFar (G4double endPointDist, G4double hStepSize, G4double epsilonRelative, G4int debugFlag)

void	WarnSmallStepSize (G4double hnext, G4double hstep, G4double h, G4double xDone, G4int noSteps)

void	WarnTooManyStep (G4double x1start, G4double x2end, G4double xCurrent)

Static Protected Attributes
static constexpr G4double	max_stepping_decrease = 0.1

static constexpr G4double	max_stepping_increase = 5

Private Types
using	ChordFinderDelegate = G4ChordFinderDelegate< G4MagInt_Driver >

Private Member Functions
void	AccumulateStatistics (G4int noTrials)

G4double	FindNextChord (const G4FieldTrack &yStart, G4double stepMax, G4double epsStep, G4double chordDistance, G4FieldTrack &yEnd, G4double &dyErrPos, G4double &pStepForAccuracy)

G4MagInt_Driver &	GetDriver ()

G4double	NewStep (G4double stepTrialOld, G4double dChordStep, G4double fDeltaChord, G4double &stepEstimate_Unconstrained)

void	PrintStatistics ()

Private Attributes
G4double	errcon

G4double	fDyerr_max =0.0

G4double	fDyerr_mx2 =0.0

G4double	fDyerrPos_lgTot =0.0

G4double	fDyerrPos_smTot =0.0

G4double	fDyerrVel_lgTot =0.0

G4double	fFirstFraction

G4double	fFractionLast

G4double	fFractionNextEstimate

G4double	fLastStepEstimate_Unconstrained

G4int	fMaxNoSteps

G4int	fMaxStepBase = 250

G4int	fmaxTrials

G4double	fMinimumStep = 0.0

const G4int	fMinNoVars = 12

unsigned long	fNoBadSteps =0

unsigned long	fNoCalls =0

unsigned long	fNoInitialSmallSteps =0

const G4int	fNoIntegrationVariables = 0

unsigned long	fNoSmallSteps =0

unsigned long	fNoTotalSteps =0

const G4int	fNoVars = 0

G4double	fSmallestFraction = 1.0e-12

G4int	fStatisticsVerboseLevel = 0

G4double	fSumH_lg =0.0

G4double	fSumH_sm =0.0

G4int	fTotalNoTrials

G4int	fVerboseLevel = 0

G4double	pgrow

G4MagIntegratorStepper *	pIntStepper = nullptr

G4double	pshrnk

G4double	safety

Detailed Description

Definition at line 44 of file G4MagIntegratorDriver.hh.

Member Typedef Documentation

◆ ChordFinderDelegate

using G4MagInt_Driver::ChordFinderDelegate = G4ChordFinderDelegate<G4MagInt_Driver>

private

Definition at line 273 of file G4MagIntegratorDriver.hh.

Constructor & Destructor Documentation

◆ G4MagInt_Driver() [1/2]

G4MagInt_Driver::G4MagInt_Driver	(	G4double	hminimum,
		G4MagIntegratorStepper *	pItsStepper,
		G4int	numberOfComponents = `6`,
		G4int	statisticsVerbosity = `0`
	)

Definition at line 49 of file G4MagIntegratorDriver.cc.

  : fNoIntegrationVariables(numComponents), 
    fNoVars( std::max( fNoIntegrationVariables, fMinNoVars )),
    fStatisticsVerboseLevel(statisticsVerbose)
{  
  // In order to accomodate "Laboratory Time", which is [7], fMinNoVars=8
  // is required. For proper time of flight and spin,  fMinNoVars must be 12
 
  RenewStepperAndAdjust( pStepper );
  fMinimumStep = hminimum;
 
  fMaxNoSteps = fMaxStepBase / pIntStepper->IntegratorOrder();
#ifdef G4DEBUG_FIELD
  fVerboseLevel=2;
#endif
 
  if( (fVerboseLevel > 0) || (fStatisticsVerboseLevel > 1) )
  {
    G4cout << "MagIntDriver version: Accur-Adv: "
           << "invE_nS, QuickAdv-2sqrt with Statistics "
#ifdef G4FLD_STATS
           << " enabled "
#else
           << " disabled "
#endif
           << G4endl;
  }
}

References fMaxNoSteps, fMaxStepBase, fMinimumStep, fStatisticsVerboseLevel, fVerboseLevel, G4cout, G4endl, G4MagIntegratorStepper::IntegratorOrder(), pIntStepper, and RenewStepperAndAdjust().

◆ ~G4MagInt_Driver()

G4MagInt_Driver::~G4MagInt_Driver ( )

overridevirtual

Definition at line 85 of file G4MagIntegratorDriver.cc.

{ 
  if( fStatisticsVerboseLevel > 1 )
  {
    PrintStatisticsReport();
  }
}

References fStatisticsVerboseLevel, and PrintStatisticsReport().

◆ G4MagInt_Driver() [2/2]

G4MagInt_Driver::G4MagInt_Driver ( const G4MagInt_Driver & )

delete

Member Function Documentation

◆ AccumulateStatistics()

void G4ChordFinderDelegate< G4MagInt_Driver >::AccumulateStatistics ( G4int noTrials )

privateinherited

◆ AccurateAdvance()

G4bool G4MagInt_Driver::AccurateAdvance	(	G4FieldTrack &	y_current,
		G4double	hstep,
		G4double	eps,
		G4double	hinitial = `0.0`
	)

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 96 of file G4MagIntegratorDriver.cc.

{
  // Runge-Kutta driver with adaptive stepsize control. Integrate starting
  // values at y_current over hstep x2 with accuracy eps. 
  // On output ystart is replaced by values at the end of the integration 
  // interval. RightHandSide is the right-hand side of ODE system. 
  // The source is similar to odeint routine from NRC p.721-722 .
 
  G4int nstp, i, no_warnings = 0;
  G4double x, hnext, hdid, h;
 
#ifdef G4DEBUG_FIELD
  static G4int dbg = 1;
  static G4int nStpPr = 50;   // For debug printing of long integrations
  G4double ySubStepStart[G4FieldTrack::ncompSVEC];
  G4FieldTrack  yFldTrkStart(y_current);
#endif
 
  G4double y[G4FieldTrack::ncompSVEC], dydx[G4FieldTrack::ncompSVEC];
  G4double ystart[G4FieldTrack::ncompSVEC], yEnd[G4FieldTrack::ncompSVEC]; 
  G4double  x1, x2;
  G4bool succeeded = true, lastStepSucceeded;
 
  G4double startCurveLength;
 
  G4int noFullIntegr = 0, noSmallIntegr = 0;
  static G4ThreadLocal G4int  noGoodSteps = 0;  // Bad = chord > curve-len 
  const G4int nvar = fNoVars;
 
  G4FieldTrack yStartFT(y_current);
 
  //  Ensure that hstep > 0
  //
  if( hstep <= 0.0 )
  { 
    if( hstep == 0.0 )
    {
      std::ostringstream message;
      message << "Proposed step is zero; hstep = " << hstep << " !";
      G4Exception("G4MagInt_Driver::AccurateAdvance()", 
                  "GeomField1001", JustWarning, message);
      return succeeded; 
    }
    else
    { 
      std::ostringstream message;
      message << "Invalid run condition." << G4endl
              << "Proposed step is negative; hstep = " << hstep << "." << G4endl
              << "Requested step cannot be negative! Aborting event.";
      G4Exception("G4MagInt_Driver::AccurateAdvance()", 
                  "GeomField0003", EventMustBeAborted, message);
      return false;
    }
  }
 
  y_current.DumpToArray( ystart );
 
  startCurveLength= y_current.GetCurveLength();
  x1= startCurveLength; 
  x2= x1 + hstep;
 
  if ( (hinitial > 0.0) && (hinitial < hstep)
    && (hinitial > perMillion * hstep) )
  {
     h = hinitial;
  }
  else  //  Initial Step size "h" defaults to the full interval
  {
     h = hstep;
  }
 
  x = x1;
 
  for ( i=0; i<nvar; ++i)  { y[i] = ystart[i]; }
 
  G4bool lastStep= false;
  nstp = 1;
 
  do
  {
    G4ThreeVector StartPos( y[0], y[1], y[2] );
 
#ifdef G4DEBUG_FIELD
    G4double xSubStepStart= x; 
    for (i=0; i<nvar; ++i)  { ySubStepStart[i] = y[i]; }
    yFldTrkStart.LoadFromArray(y, fNoIntegrationVariables);
    yFldTrkStart.SetCurveLength(x);
#endif
 
    pIntStepper->RightHandSide( y, dydx );
    ++fNoTotalSteps;
 
    // Perform the Integration
    //      
    if( h > fMinimumStep )
    { 
      OneGoodStep(y,dydx,x,h,eps,hdid,hnext) ;
      //--------------------------------------
      lastStepSucceeded = (hdid == h);   
#ifdef G4DEBUG_FIELD
      if (dbg>2)
      {
         // PrintStatus( ySubStepStart, xSubStepStart, y, x, h,  nstp); // Only
        G4DriverReporter::PrintStatus( ySubStepStart, xSubStepStart, y, x, h,  nstp, nvar);
      }
#endif
    }
    else
    {
      G4FieldTrack yFldTrk( G4ThreeVector(0,0,0), 
                            G4ThreeVector(0,0,0), 0., 0., 0., 0. );
      G4double dchord_step, dyerr, dyerr_len;   // What to do with these ?
      yFldTrk.LoadFromArray(y, fNoIntegrationVariables); 
      yFldTrk.SetCurveLength( x );
 
      QuickAdvance( yFldTrk, dydx, h, dchord_step, dyerr_len );
      //-----------------------------------------------------
 
      yFldTrk.DumpToArray(y);    
 
#ifdef G4FLD_STATS
      ++fNoSmallSteps; 
      if ( dyerr_len > fDyerr_max )  { fDyerr_max = dyerr_len; }
      fDyerrPos_smTot += dyerr_len;
      fSumH_sm += h;  // Length total for 'small' steps
      if (nstp==1)  { ++fNoInitialSmallSteps; }
#endif
#ifdef G4DEBUG_FIELD
      if (dbg>1)
      {
        if(fNoSmallSteps<2) { PrintStatus(ySubStepStart, x1, y, x, h, -nstp); }
        G4cout << "Another sub-min step, no " << fNoSmallSteps 
               << " of " << fNoTotalSteps << " this time " << nstp << G4endl; 
        PrintStatus( ySubStepStart, x1, y, x, h,  nstp);   // Only this
        G4cout << " dyerr= " << dyerr_len << " relative = " << dyerr_len / h 
               << " epsilon= " << eps << " hstep= " << hstep 
               << " h= " << h << " hmin= " << fMinimumStep << G4endl;
      }
#endif        
      if( h == 0.0 )
      { 
        G4Exception("G4MagInt_Driver::AccurateAdvance()",
                    "GeomField0003", FatalException,
                    "Integration Step became Zero!"); 
      }
      dyerr = dyerr_len / h;
      hdid = h;
      x += hdid;
 
      // Compute suggested new step
      hnext = ComputeNewStepSize( dyerr/eps, h);
 
      // .. hnext= ComputeNewStepSize_WithinLimits( dyerr/eps, h);
      lastStepSucceeded = (dyerr<= eps);
    }
 
    if (lastStepSucceeded)  { ++noFullIntegr; }
    else                    { ++noSmallIntegr; }
 
    G4ThreeVector EndPos( y[0], y[1], y[2] );
 
#ifdef  G4DEBUG_FIELD
    if( (dbg>0) && (dbg<=2) && (nstp>nStpPr))
    {
      if( nstp==nStpPr )  { G4cout << "***** Many steps ****" << G4endl; }
      G4cout << "MagIntDrv: " ; 
      G4cout << "hdid="  << std::setw(12) << hdid  << " "
             << "hnext=" << std::setw(12) << hnext << " " 
             << "hstep=" << std::setw(12) << hstep << " (requested) " 
             << G4endl;
      PrintStatus( ystart, x1, y, x, h, (nstp==nStpPr) ? -nstp: nstp); 
    }
#endif
 
    // Check the endpoint
    G4double endPointDist= (EndPos-StartPos).mag(); 
    if ( endPointDist >= hdid*(1.+perMillion) )
    {
      ++fNoBadSteps;
 
      // Issue a warning only for gross differences -
      // we understand how small difference occur.
      if ( endPointDist >= hdid*(1.+perThousand) )
      { 
#ifdef G4DEBUG_FIELD
        if (dbg)
        {
          WarnEndPointTooFar ( endPointDist, hdid, eps, dbg ); 
          G4cerr << "  Total steps:  bad " << fNoBadSteps
                 << " good " << noGoodSteps << " current h= " << hdid
                 << G4endl;
          PrintStatus( ystart, x1, y, x, hstep, no_warnings?nstp:-nstp);  
        }
#endif
        ++no_warnings;
      }
    }
    else
    {
      ++noGoodSteps;
    } 
// #endif
 
    //  Avoid numerous small last steps
    if( (h < eps * hstep) || (h < fSmallestFraction * startCurveLength) )
    {
      // No more integration -- the next step will not happen
      lastStep = true;  
    }
    else
    {
      // Check the proposed next stepsize
      if(std::fabs(hnext) <= Hmin())
      {
#ifdef  G4DEBUG_FIELD
        // If simply a very small interval is being integrated, do not warn
        if( (x < x2 * (1-eps) ) &&        // The last step can be small: OK
            (std::fabs(hstep) > Hmin()) ) // and if we are asked, it's OK
        {
          if(dbg>0)
          {
            WarnSmallStepSize( hnext, hstep, h, x-x1, nstp );  
            PrintStatus( ystart, x1, y, x, hstep, no_warnings?nstp:-nstp);
          }
          ++no_warnings;
        }
#endif
        // Make sure that the next step is at least Hmin.
        h = Hmin();
      }
      else
      {
        h = hnext;
      }
 
      //  Ensure that the next step does not overshoot
      if ( x+h > x2 )
      {                // When stepsize overshoots, decrease it!
        h = x2 - x ;   // Must cope with difficult rounding-error
      }                // issues if hstep << x2
 
      if ( h == 0.0 )
      {
        // Cannot progress - accept this as last step - by default
        lastStep = true;
#ifdef G4DEBUG_FIELD
        if (dbg>2)
        {
          int prec= G4cout.precision(12); 
          G4cout << "Warning: G4MagIntegratorDriver::AccurateAdvance"
                 << G4endl
                 << "  Integration step 'h' became "
                 << h << " due to roundoff. " << G4endl
                 << " Calculated as difference of x2= "<< x2 << " and x=" << x
                 << "  Forcing termination of advance." << G4endl;
          G4cout.precision(prec);
        }          
#endif
      }
    }
  } while ( ((++nstp)<=fMaxNoSteps) && (x < x2) && (!lastStep) );
  // Loop checking, 07.10.2016, J. Apostolakis
 
     // Have we reached the end ?
     // --> a better test might be x-x2 > an_epsilon
 
  succeeded = (x>=x2);  // If it was a "forced" last step
 
  for (i=0; i<nvar; ++i)  { yEnd[i] = y[i]; }
 
  // Put back the values.
  y_current.LoadFromArray( yEnd, fNoIntegrationVariables );
  y_current.SetCurveLength( x );
 
  if(nstp > fMaxNoSteps)
  {
    ++no_warnings;
    succeeded = false;
#ifdef G4DEBUG_FIELD
    if (dbg)
    {
      WarnTooManyStep( x1, x2, x );  //  Issue WARNING
      PrintStatus( yEnd, x1, y, x, hstep, -nstp);
    }
#endif
  }
 
#ifdef G4DEBUG_FIELD
  if( dbg && no_warnings )
  {
    G4cerr << "G4MagIntegratorDriver exit status: no-steps " << nstp << G4endl;
    PrintStatus( yEnd, x1, y, x, hstep, nstp);
  }
#endif
 
  return succeeded;
}  // end of AccurateAdvance ...........................

References ComputeNewStepSize(), G4FieldTrack::DumpToArray(), eps, EventMustBeAborted, FatalException, fDyerr_max, fDyerrPos_smTot, fMaxNoSteps, fMinimumStep, fNoBadSteps, fNoInitialSmallSteps, fNoIntegrationVariables, fNoSmallSteps, fNoTotalSteps, fNoVars, fSmallestFraction, fSumH_sm, G4cerr, G4cout, G4endl, G4Exception(), G4ThreadLocal, G4FieldTrack::GetCurveLength(), Hmin(), JustWarning, G4FieldTrack::LoadFromArray(), G4FieldTrack::ncompSVEC, OneGoodStep(), perMillion, perThousand, pIntStepper, CLHEP::prec, PrintStatus(), G4DriverReporter::PrintStatus(), QuickAdvance(), G4MagIntegratorStepper::RightHandSide(), G4FieldTrack::SetCurveLength(), WarnEndPointTooFar(), WarnSmallStepSize(), and WarnTooManyStep().

Referenced by G4RKPropagation::FieldTransport().

◆ AdvanceChordLimited()

virtual G4double G4MagInt_Driver::AdvanceChordLimited	(	G4FieldTrack &	track,
		G4double	stepMax,
		G4double	epsStep,
		G4double	chordDistance
	)

inlineoverridevirtual

Implements G4VIntegrationDriver.

◆ AdvanceChordLimitedImpl()

G4double G4ChordFinderDelegate< G4MagInt_Driver >::AdvanceChordLimitedImpl	(	G4FieldTrack &	track,
		G4double	hstep,
		G4double	eps,
		G4double	chordDistance
	)

inherited

◆ ComputeAndSetErrcon()

G4double G4MagInt_Driver::ComputeAndSetErrcon ( )

inline

◆ ComputeNewStepSize()

G4double G4MagInt_Driver::ComputeNewStepSize	(	G4double	errMaxNorm,
		G4double	hstepCurrent
	)

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 755 of file G4MagIntegratorDriver.cc.

{
   // Legacy behaviour:
   return ComputeNewStepSize_WithoutReductionLimit( errMaxNorm, hstepCurrent );
   // 'Improved' behaviour - at least more consistent with other step estimates:
   // return ComputeNewStepSize_WithinLimits( errMaxNorm, hstepCurrent );
}

References ComputeNewStepSize_WithoutReductionLimit().

Referenced by AccurateAdvance(), and QuickAdvance().

◆ ComputeNewStepSize_WithinLimits()

G4double G4MagInt_Driver::ComputeNewStepSize_WithinLimits	(	G4double	errMaxNorm,
		G4double	hstepCurrent
	)

Definition at line 771 of file G4MagIntegratorDriver.cc.

{
  G4double hnew;
 
  // Compute size of next Step for a failed step
  if (errMaxNorm > 1.0 )
  {
    // Step failed; compute the size of retrial Step.
    hnew = GetSafety()*hstepCurrent*std::pow(errMaxNorm,GetPshrnk()) ;
  
    if (hnew < max_stepping_decrease*hstepCurrent)
    {
      hnew = max_stepping_decrease*hstepCurrent ;
                         // reduce stepsize, but no more
                         // than this factor (value= 1/10)
    }
  }
  else
  {
    // Compute size of next Step for a successful step
    if (errMaxNorm > errcon)
     { hnew = GetSafety()*hstepCurrent*std::pow(errMaxNorm,GetPgrow()); }
    else  // No more than a factor of 5 increase
     { hnew = max_stepping_increase * hstepCurrent; }
  }
  return hnew;
}

References errcon, GetPgrow(), GetPshrnk(), GetSafety(), G4VIntegrationDriver::max_stepping_decrease, and G4VIntegrationDriver::max_stepping_increase.

◆ ComputeNewStepSize_WithoutReductionLimit()

G4double G4MagInt_Driver::ComputeNewStepSize_WithoutReductionLimit	(	G4double	errMaxNorm,
		G4double	hstepCurrent
	)

Definition at line 726 of file G4MagIntegratorDriver.cc.

{
  G4double hnew;
 
  // Compute size of next Step for a failed step
  if(errMaxNorm > 1.0 )
  {
    // Step failed; compute the size of retrial Step.
    hnew = GetSafety()*hstepCurrent*std::pow(errMaxNorm,GetPshrnk()) ;
  }
  else if(errMaxNorm > 0.0 )
  {
    // Compute size of next Step for a successful step
    hnew = GetSafety()*hstepCurrent*std::pow(errMaxNorm,GetPgrow()) ;
  }
  else
  {
    // if error estimate is zero (possible) or negative (dubious)
    hnew = max_stepping_increase * hstepCurrent; 
  }
 
  return hnew;
}

References GetPgrow(), GetPshrnk(), GetSafety(), and G4VIntegrationDriver::max_stepping_increase.

Referenced by ComputeNewStepSize().

◆ DoesReIntegrate()

virtual G4bool G4MagInt_Driver::DoesReIntegrate ( ) const

inlineoverridevirtual

Implements G4VIntegrationDriver.

Definition at line 66 of file G4MagIntegratorDriver.hh.

66{ return true; }

Referenced by PrintInfo(), and StreamInfo().

◆ FindNextChord()

G4double G4ChordFinderDelegate< G4MagInt_Driver >::FindNextChord	(	const G4FieldTrack &	yStart,
		G4double	stepMax,
		G4double	epsStep,
		G4double	chordDistance,
		G4FieldTrack &	yEnd,
		G4double &	dyErrPos,
		G4double &	pStepForAccuracy
	)

privateinherited

◆ GetDerivatives() [1/2]

void G4MagInt_Driver::GetDerivatives	(	const G4FieldTrack &	track,
		G4double	dydx[],
		G4double	field[]
	)		const

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 1000 of file G4MagIntegratorDriver.cc.

{
    G4double ytemp[G4FieldTrack::ncompSVEC];
    track.DumpToArray(ytemp);
    pIntStepper->RightHandSide(ytemp, dydx, field);
}

References G4FieldTrack::DumpToArray(), G4FieldTrack::ncompSVEC, pIntStepper, and G4MagIntegratorStepper::RightHandSide().

◆ GetDerivatives() [2/2]

virtual void G4MagInt_Driver::GetDerivatives	(	const G4FieldTrack &	y_curr,
		G4double	dydx[]
	)		const

overridevirtual

Implements G4VIntegrationDriver.

◆ GetDriver()

G4MagInt_Driver & G4ChordFinderDelegate< G4MagInt_Driver >::GetDriver ( )

privateinherited

◆ GetEquationOfMotion()

G4EquationOfMotion * G4MagInt_Driver::GetEquationOfMotion ( )

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 1009 of file G4MagIntegratorDriver.cc.

{
    return pIntStepper->GetEquationOfMotion();
}

References G4MagIntegratorStepper::GetEquationOfMotion(), and pIntStepper.

◆ GetErrcon()

G4double G4MagInt_Driver::GetErrcon ( ) const

inline

Referenced by PrintInfo().

◆ GetFirstFraction()

G4double G4ChordFinderDelegate< G4MagInt_Driver >::GetFirstFraction ( )

inherited

◆ GetFractionLast()

G4double G4ChordFinderDelegate< G4MagInt_Driver >::GetFractionLast ( )

inherited

◆ GetFractionNextEstimate()

G4double G4ChordFinderDelegate< G4MagInt_Driver >::GetFractionNextEstimate ( )

inherited

◆ GetHmin()

G4double G4MagInt_Driver::GetHmin ( ) const

inline

Referenced by PrintInfo().

◆ GetLastStepEstimateUnc()

G4double G4ChordFinderDelegate< G4MagInt_Driver >::GetLastStepEstimateUnc ( )

inherited

◆ GetMaxNoSteps()

G4int G4MagInt_Driver::GetMaxNoSteps ( ) const

inline

Referenced by PrintInfo().

◆ GetNoCalls()

G4int G4ChordFinderDelegate< G4MagInt_Driver >::GetNoCalls ( )

inherited

◆ GetNoMaxTrials()

G4int G4ChordFinderDelegate< G4MagInt_Driver >::GetNoMaxTrials ( )

inherited

◆ GetNoTrials()

G4int G4ChordFinderDelegate< G4MagInt_Driver >::GetNoTrials ( )

inherited

◆ GetPgrow()

G4double G4MagInt_Driver::GetPgrow ( ) const

inline

Referenced by ComputeNewStepSize_WithinLimits(), ComputeNewStepSize_WithoutReductionLimit(), OneGoodStep(), and PrintInfo().

◆ GetPshrnk()

G4double G4MagInt_Driver::GetPshrnk ( ) const

inline

Referenced by ComputeNewStepSize_WithinLimits(), ComputeNewStepSize_WithoutReductionLimit(), OneGoodStep(), and PrintInfo().

◆ GetSafety()

G4double G4MagInt_Driver::GetSafety ( ) const

inline

Referenced by ComputeNewStepSize_WithinLimits(), ComputeNewStepSize_WithoutReductionLimit(), OneGoodStep(), and PrintInfo().

◆ GetSmallestFraction()

G4double G4MagInt_Driver::GetSmallestFraction ( ) const

inline

Referenced by PrintInfo().

◆ GetStepper() [1/2]

const G4MagIntegratorStepper * G4MagInt_Driver::GetStepper ( ) const

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 1019 of file G4MagIntegratorDriver.cc.

{
    return pIntStepper;
}

References pIntStepper.

◆ GetStepper() [2/2]

G4MagIntegratorStepper * G4MagInt_Driver::GetStepper ( )

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 1024 of file G4MagIntegratorDriver.cc.

{
    return pIntStepper;
}

References pIntStepper.

◆ GetVerboseLevel()

virtual G4int G4MagInt_Driver::GetVerboseLevel ( ) const

overridevirtual

Implements G4VIntegrationDriver.

Referenced by PrintInfo().

◆ Hmin()

G4double G4MagInt_Driver::Hmin ( ) const

inline

Referenced by AccurateAdvance(), and WarnSmallStepSize().

◆ NewStep()

G4double G4ChordFinderDelegate< G4MagInt_Driver >::NewStep	(	G4double	stepTrialOld,
		G4double	dChordStep,
		G4double	fDeltaChord,
		G4double &	stepEstimate_Unconstrained
	)

privateinherited

◆ OnComputeStep()

virtual void G4MagInt_Driver::OnComputeStep ( )

inlineoverridevirtual

Implements G4VIntegrationDriver.

Definition at line 65 of file G4MagIntegratorDriver.hh.

65{};

◆ OneGoodStep()

void G4MagInt_Driver::OneGoodStep	(	G4double	ystart[],
		const G4double	dydx[],
		G4double &	x,
		G4double	htry,
		G4double	eps,
		G4double &	hdid,
		G4double &	hnext
	)

Definition at line 485 of file G4MagIntegratorDriver.cc.

{
  G4double errmax_sq;
  G4double h, htemp, xnew ;
 
  G4double yerr[G4FieldTrack::ncompSVEC], ytemp[G4FieldTrack::ncompSVEC];
 
  h = htry ; // Set stepsize to the initial trial value
 
  G4double inv_eps_vel_sq = 1.0 / (eps_rel_max*eps_rel_max);
 
  G4double errpos_sq = 0.0;    // square of displacement error
  G4double errvel_sq = 0.0;    // square of momentum vector difference
  G4double errspin_sq = 0.0;   // square of spin vector difference
 
  static G4ThreadLocal G4int tot_no_trials=0; 
  const G4int max_trials=100; 
 
  G4ThreeVector Spin(y[9],y[10],y[11]);
  G4double spin_mag2 = Spin.mag2();
  G4bool hasSpin = (spin_mag2 > 0.0); 
 
  for (G4int iter=0; iter<max_trials; ++iter)
  {
    ++tot_no_trials;
    pIntStepper-> Stepper(y,dydx,h,ytemp,yerr); 
    //            *******
    G4double eps_pos = eps_rel_max * std::max(h, fMinimumStep); 
    G4double inv_eps_pos_sq = 1.0 / (eps_pos*eps_pos); 
 
    // Evaluate accuracy
    //
    errpos_sq =  sqr(yerr[0]) + sqr(yerr[1]) + sqr(yerr[2]) ;
    errpos_sq *= inv_eps_pos_sq; // Scale relative to required tolerance
 
    // Accuracy for momentum
    G4double magvel_sq=  sqr(y[3]) + sqr(y[4]) + sqr(y[5]) ;
    G4double sumerr_sq =  sqr(yerr[3]) + sqr(yerr[4]) + sqr(yerr[5]) ; 
    if( magvel_sq > 0.0 )
    { 
       errvel_sq = sumerr_sq / magvel_sq; 
    }
    else
    {
       std::ostringstream message;
       message << "Found case of zero momentum." << G4endl
               << "- iteration= " << iter << "; h= " << h;
       G4Exception("G4MagInt_Driver::OneGoodStep()",
                   "GeomField1001", JustWarning, message);
       errvel_sq = sumerr_sq; 
    }
    errvel_sq *= inv_eps_vel_sq;
    errmax_sq = std::max( errpos_sq, errvel_sq ); // Square of maximum error
 
    if( hasSpin )
    { 
      // Accuracy for spin
      errspin_sq =  ( sqr(yerr[9]) + sqr(yerr[10]) + sqr(yerr[11]) )
                    /  spin_mag2; // ( sqr(y[9]) + sqr(y[10]) + sqr(y[11]) );
      errspin_sq *= inv_eps_vel_sq;
      errmax_sq = std::max( errmax_sq, errspin_sq ); 
    }
 
    if ( errmax_sq <= 1.0 )  { break; } // Step succeeded. 
 
    // Step failed; compute the size of retrial Step.
    htemp = GetSafety() * h * std::pow( errmax_sq, 0.5*GetPshrnk() );
 
    if (htemp >= 0.1*h)  { h = htemp; }  // Truncation error too large,
    else  { h = 0.1*h; }                 // reduce stepsize, but no more
                                         // than a factor of 10
    xnew = x + h;
    if(xnew == x)
    {
      std::ostringstream message;
      message << "Stepsize underflow in Stepper !" << G4endl
              << "- Step's start x=" << x << " and end x= " << xnew 
              << " are equal !! " << G4endl
              << "  Due to step-size= " << h 
              << ". Note that input step was " << htry;
      G4Exception("G4MagInt_Driver::OneGoodStep()",
                  "GeomField1001", JustWarning, message);
      break;
    }
  }
 
  // Compute size of next Step
  if (errmax_sq > errcon*errcon)
  { 
    hnext = GetSafety()*h*std::pow(errmax_sq, 0.5*GetPgrow());
  }
  else
  {
    hnext = max_stepping_increase*h ; // No more than a factor of 5 increase
  }
  x += (hdid = h);
 
  for(G4int k=0; k<fNoIntegrationVariables; ++k) { y[k] = ytemp[k]; }
 
  return;
}

References errcon, fMinimumStep, fNoIntegrationVariables, G4endl, G4Exception(), G4ThreadLocal, GetPgrow(), GetPshrnk(), GetSafety(), JustWarning, G4INCL::Math::max(), G4VIntegrationDriver::max_stepping_increase, G4FieldTrack::ncompSVEC, pIntStepper, and sqr().

Referenced by AccurateAdvance().

◆ OnStartTracking()

virtual void G4MagInt_Driver::OnStartTracking ( )

inlineoverridevirtual

Implements G4VIntegrationDriver.

◆ operator=()

G4MagInt_Driver & G4MagInt_Driver::operator= ( const G4MagInt_Driver & )

delete

◆ PrintStat_Aux()

void G4MagInt_Driver::PrintStat_Aux	(	const G4FieldTrack &	aFieldTrack,
		G4double	requestStep,
		G4double	actualStep,
		G4int	subStepNo,
		G4double	subStepSize,
		G4double	dotVelocities
	)

protected

Definition at line 891 of file G4MagIntegratorDriver.cc.

{
    const G4ThreeVector Position = aFieldTrack.GetPosition();
    const G4ThreeVector UnitVelocity = aFieldTrack.GetMomentumDir();
 
    if( subStepNo >= 0)
    {
       G4cout << std::setw( 5) << subStepNo << " ";
    }
    else
    {
       G4cout << std::setw( 5) << "Start" << " ";
    }
    G4double curveLen= aFieldTrack.GetCurveLength();
    G4cout << std::setw( 7) << curveLen;
    G4cout << std::setw( 9) << Position.x() << " "
           << std::setw( 9) << Position.y() << " "
           << std::setw( 9) << Position.z() << " "
           << std::setw( 8) << UnitVelocity.x() << " "
           << std::setw( 8) << UnitVelocity.y() << " "
           << std::setw( 8) << UnitVelocity.z() << " ";
    G4int oldprec= G4cout.precision(3);
    G4cout << std::setw( 8) << UnitVelocity.mag2()-1.0 << " ";
    G4cout.precision(6);
    G4cout << std::setw(10) << dotVeloc_StartCurr << " ";
    G4cout.precision(oldprec);
    G4cout << std::setw( 7) << aFieldTrack.GetKineticEnergy();
    G4cout << std::setw(12) << step_len << " ";
 
    static G4ThreadLocal G4double oldCurveLength = 0.0;
    static G4ThreadLocal G4double oldSubStepLength = 0.0;
    static G4ThreadLocal G4int oldSubStepNo = -1;
 
    G4double subStep_len = 0.0;
    if( curveLen > oldCurveLength )
    {
      subStep_len= curveLen - oldCurveLength;
    }
    else if (subStepNo == oldSubStepNo)
    {
      subStep_len= oldSubStepLength;
    }
    oldCurveLength= curveLen;
    oldSubStepLength= subStep_len;
 
    G4cout << std::setw(12) << subStep_len << " "; 
    G4cout << std::setw(12) << subStepSize << " "; 
    if( requestStep != -1.0 )
    {
      G4cout << std::setw( 9) << requestStep << " ";
    }
    else
    {
       G4cout << std::setw( 9) << " InitialStep " << " ";
    }
    G4cout << G4endl;
}

References G4cout, G4endl, G4ThreadLocal, G4FieldTrack::GetCurveLength(), G4FieldTrack::GetKineticEnergy(), G4FieldTrack::GetMomentumDir(), G4FieldTrack::GetPosition(), CLHEP::Hep3Vector::mag2(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by PrintStatus().

◆ PrintStatistics()

void G4ChordFinderDelegate< G4MagInt_Driver >::PrintStatistics ( )

privateinherited

◆ PrintStatisticsReport()

void G4MagInt_Driver::PrintStatisticsReport ( )

protected

Definition at line 956 of file G4MagIntegratorDriver.cc.

{
  G4int noPrecBig = 6;
  G4int oldPrec = G4cout.precision(noPrecBig);
 
  G4cout << "G4MagInt_Driver Statistics of steps undertaken. " << G4endl;
  G4cout << "G4MagInt_Driver: Number of Steps: "
         << " Total= " <<  fNoTotalSteps
         << " Bad= "   <<  fNoBadSteps 
         << " Small= " <<  fNoSmallSteps 
         << " Non-initial small= " << (fNoSmallSteps-fNoInitialSmallSteps)
         << G4endl;
 G4cout.precision(oldPrec);
}

References fNoBadSteps, fNoInitialSmallSteps, fNoSmallSteps, fNoTotalSteps, G4cout, and G4endl.

Referenced by ~G4MagInt_Driver().

◆ PrintStatus() [1/2]

void G4MagInt_Driver::PrintStatus	(	const G4double *	StartArr,
		G4double	xstart,
		const G4double *	CurrentArr,
		G4double	xcurrent,
		G4double	requestStep,
		G4int	subStepNo
	)

protected

Definition at line 803 of file G4MagIntegratorDriver.cc.

{
   G4FieldTrack  StartFT(G4ThreeVector(0,0,0),
                 G4ThreeVector(0,0,0), 0., 0., 0., 0. );
   G4FieldTrack  CurrentFT (StartFT);
 
   StartFT.LoadFromArray( StartArr, fNoIntegrationVariables); 
   StartFT.SetCurveLength( xstart);
   CurrentFT.LoadFromArray( CurrentArr, fNoIntegrationVariables); 
   CurrentFT.SetCurveLength( xcurrent );
 
   PrintStatus(StartFT, CurrentFT, requestStep, subStepNo ); 
}

References fNoIntegrationVariables, G4FieldTrack::LoadFromArray(), PrintStatus(), and G4FieldTrack::SetCurveLength().

Referenced by AccurateAdvance(), PrintStatus(), and QuickAdvance().

◆ PrintStatus() [2/2]

void G4MagInt_Driver::PrintStatus	(	const G4FieldTrack &	StartFT,
		const G4FieldTrack &	CurrentFT,
		G4double	requestStep,
		G4int	subStepNo
	)

protected

Definition at line 828 of file G4MagIntegratorDriver.cc.

{
    G4int verboseLevel= fVerboseLevel;
    const G4int noPrecision = 5;
    G4int oldPrec= G4cout.precision(noPrecision);
    // G4cout.setf(ios_base::fixed,ios_base::floatfield);
 
    const G4ThreeVector StartPosition=       StartFT.GetPosition();
    const G4ThreeVector StartUnitVelocity=   StartFT.GetMomentumDir();
    const G4ThreeVector CurrentPosition=     CurrentFT.GetPosition();
    const G4ThreeVector CurrentUnitVelocity= CurrentFT.GetMomentumDir();
 
    G4double  DotStartCurrentVeloc= StartUnitVelocity.dot(CurrentUnitVelocity);
 
    G4double step_len= CurrentFT.GetCurveLength() - StartFT.GetCurveLength();
    G4double subStepSize = step_len;
     
    if( (subStepNo <= 1) || (verboseLevel > 3) )
    {
       subStepNo = - subStepNo;        // To allow printing banner
 
       G4cout << std::setw( 6)  << " " << std::setw( 25)
              << " G4MagInt_Driver: Current Position  and  Direction" << " "
              << G4endl; 
       G4cout << std::setw( 5) << "Step#" << " "
              << std::setw( 7) << "s-curve" << " "
              << std::setw( 9) << "X(mm)" << " "
              << std::setw( 9) << "Y(mm)" << " "  
              << std::setw( 9) << "Z(mm)" << " "
              << std::setw( 8) << " N_x " << " "
              << std::setw( 8) << " N_y " << " "
              << std::setw( 8) << " N_z " << " "
              << std::setw( 8) << " N^2-1 " << " "
              << std::setw(10) << " N(0).N " << " "
              << std::setw( 7) << "KinEner " << " "
              << std::setw(12) << "Track-l" << " "   // Add the Sub-step ??
              << std::setw(12) << "Step-len" << " " 
              << std::setw(12) << "Step-len" << " " 
              << std::setw( 9) << "ReqStep" << " "  
              << G4endl;
    }
 
    if( (subStepNo <= 0) )
    {
      PrintStat_Aux( StartFT,  requestStep, 0., 
                       0,        0.0,         1.0);
    }
 
    if( verboseLevel <= 3 )
    {
      G4cout.precision(noPrecision);
      PrintStat_Aux( CurrentFT, requestStep, step_len, 
                     subStepNo, subStepSize, DotStartCurrentVeloc );
    }
 
    G4cout.precision(oldPrec);
}

References CLHEP::Hep3Vector::dot(), fVerboseLevel, G4cout, G4endl, G4FieldTrack::GetCurveLength(), G4FieldTrack::GetMomentumDir(), G4FieldTrack::GetPosition(), noPrecision, and PrintStat_Aux().

◆ QuickAdvance() [1/2]

G4bool G4MagInt_Driver::QuickAdvance	(	G4FieldTrack &	y_posvel,
		const G4double	dydx[],
		G4double	hstep,
		G4double &	dchord_step,
		G4double &	dyerr_pos_sq,
		G4double &	dyerr_mom_rel_sq
	)

Definition at line 611 of file G4MagIntegratorDriver.cc.

{
  G4Exception("G4MagInt_Driver::QuickAdvance()", "GeomField0001",
              FatalException, "Not yet implemented."); 
 
  // Use the parameters of this method, to please compiler
  //
  dchord_step = dyerr_pos_sq = hstep * hstep * dydx[0]; 
  dyerr_mom_rel_sq = y_posvel.GetPosition().mag2();
  return true;
}

References FatalException, G4Exception(), G4FieldTrack::GetPosition(), and CLHEP::Hep3Vector::mag2().

◆ QuickAdvance() [2/2]

G4bool G4MagInt_Driver::QuickAdvance	(	G4FieldTrack &	y_val,
		const G4double	dydx[],
		G4double	hstep,
		G4double &	dchord_step,
		G4double &	dyerr
	)

overridevirtual

Reimplemented from G4VIntegrationDriver.

Definition at line 630 of file G4MagIntegratorDriver.cc.

{
  G4double dyerr_pos_sq, dyerr_mom_rel_sq;  
  G4double yerr_vec[G4FieldTrack::ncompSVEC],
           yarrin[G4FieldTrack::ncompSVEC], yarrout[G4FieldTrack::ncompSVEC]; 
  G4double s_start;
  G4double dyerr_mom_sq, vel_mag_sq, inv_vel_mag_sq;
 
  static G4ThreadLocal G4int no_call = 0; 
  ++no_call; 
 
  // Move data into array
  y_posvel.DumpToArray( yarrin );      //  yarrin  <== y_posvel 
  s_start = y_posvel.GetCurveLength();
 
  // Do an Integration Step
  pIntStepper-> Stepper(yarrin, dydx, hstep, yarrout, yerr_vec) ; 
 
  // Estimate curve-chord distance
  dchord_step= pIntStepper-> DistChord();
 
  // Put back the values.  yarrout ==> y_posvel
  y_posvel.LoadFromArray( yarrout, fNoIntegrationVariables );
  y_posvel.SetCurveLength( s_start + hstep );
 
#ifdef  G4DEBUG_FIELD
  if(fVerboseLevel>2)
  {
    G4cout << "G4MagIntDrv: Quick Advance" << G4endl;
    PrintStatus( yarrin, s_start, yarrout, s_start+hstep, hstep,  1); 
  }
#endif
 
  // A single measure of the error   
  //      TO-DO :  account for  energy,  spin, ... ? 
  vel_mag_sq   = ( sqr(yarrout[3])+sqr(yarrout[4])+sqr(yarrout[5]) );
  inv_vel_mag_sq = 1.0 / vel_mag_sq; 
  dyerr_pos_sq = ( sqr(yerr_vec[0])+sqr(yerr_vec[1])+sqr(yerr_vec[2]));
  dyerr_mom_sq = ( sqr(yerr_vec[3])+sqr(yerr_vec[4])+sqr(yerr_vec[5]));
  dyerr_mom_rel_sq = dyerr_mom_sq * inv_vel_mag_sq;
 
  // Calculate also the change in the momentum squared also ???
  // G4double veloc_square = y_posvel.GetVelocity().mag2();
  // ...
 
#ifdef RETURN_A_NEW_STEP_LENGTH
  // The following step cannot be done here because "eps" is not known.
  dyerr_len = std::sqrt( dyerr_len_sq ); 
  dyerr_len_sq /= eps ;
 
  // Look at the velocity deviation ?
  //  sqr(yerr_vec[3])+sqr(yerr_vec[4])+sqr(yerr_vec[5]));
 
  // Set suggested new step
  hstep = ComputeNewStepSize( dyerr_len, hstep);
#endif
 
  if( dyerr_pos_sq > ( dyerr_mom_rel_sq * sqr(hstep) ) )
  {
    dyerr = std::sqrt(dyerr_pos_sq);
  }
  else
  {
    // Scale it to the current step size - for now
    dyerr = std::sqrt(dyerr_mom_rel_sq) * hstep;
  }
 
  return true;
}

References ComputeNewStepSize(), G4FieldTrack::DumpToArray(), eps, fNoIntegrationVariables, fVerboseLevel, G4cout, G4endl, G4ThreadLocal, G4FieldTrack::GetCurveLength(), G4FieldTrack::LoadFromArray(), G4FieldTrack::ncompSVEC, pIntStepper, PrintStatus(), G4FieldTrack::SetCurveLength(), and sqr().

Referenced by AccurateAdvance().

◆ RenewStepperAndAdjust()

void G4MagInt_Driver::RenewStepperAndAdjust ( G4MagIntegratorStepper * pItsStepper )

overridevirtual

Reimplemented from G4VIntegrationDriver.

Definition at line 1029 of file G4MagIntegratorDriver.cc.

{  
    pIntStepper = pItsStepper;
    ReSetParameters();
}

References pIntStepper, and ReSetParameters().

Referenced by G4MagInt_Driver().

◆ ReSetParameters()

void G4MagInt_Driver::ReSetParameters ( G4double new_safety = 0.9 )

inline

Referenced by RenewStepperAndAdjust().

◆ ResetStepEstimate()

void G4ChordFinderDelegate< G4MagInt_Driver >::ResetStepEstimate ( )

inherited

◆ SetEquationOfMotion()

void G4MagInt_Driver::SetEquationOfMotion ( G4EquationOfMotion * equation )

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 1014 of file G4MagIntegratorDriver.cc.

{
    pIntStepper->SetEquationOfMotion(equation);
}

References pIntStepper, and G4MagIntegratorStepper::SetEquationOfMotion().

◆ SetErrcon()

void G4MagInt_Driver::SetErrcon ( G4double valEc )

inline

◆ SetFirstFraction()

void G4ChordFinderDelegate< G4MagInt_Driver >::SetFirstFraction ( G4double fractFirst )

inherited

◆ SetFractions_Last_Next()

void G4ChordFinderDelegate< G4MagInt_Driver >::SetFractions_Last_Next	(	G4double	fractLast = `0.90`,
		G4double	fractNext = `0.95`
	)

inherited

◆ SetHmin()

void G4MagInt_Driver::SetHmin ( G4double newval )

inline

◆ SetLastStepEstimateUnc()

void G4ChordFinderDelegate< G4MagInt_Driver >::SetLastStepEstimateUnc ( G4double stepEst )

inherited

◆ SetMaxNoSteps()

void G4MagInt_Driver::SetMaxNoSteps ( G4int val )

inline

◆ SetPgrow()

void G4MagInt_Driver::SetPgrow ( G4double valPg )

inline

◆ SetPshrnk()

void G4MagInt_Driver::SetPshrnk ( G4double valPs )

inline

◆ SetSafety()

void G4MagInt_Driver::SetSafety ( G4double valS )

inline

◆ SetSmallestFraction()

void G4MagInt_Driver::SetSmallestFraction ( G4double val )

Definition at line 973 of file G4MagIntegratorDriver.cc.

{
  if( (newFraction > 1.e-16) && (newFraction < 1e-8) )
  {
    fSmallestFraction= newFraction;
  }
  else
  { 
    std::ostringstream message;
    message << "Smallest Fraction not changed. " << G4endl
            << "  Proposed value was " << newFraction << G4endl
            << "  Value must be between 1.e-8 and 1.e-16";
    G4Exception("G4MagInt_Driver::SetSmallestFraction()",
                "GeomField1001", JustWarning, message);
  }
}

References fSmallestFraction, G4endl, G4Exception(), and JustWarning.

◆ SetVerboseLevel()

virtual void G4MagInt_Driver::SetVerboseLevel ( G4int newLevel )

overridevirtual

Implements G4VIntegrationDriver.

◆ StreamDelegateInfo()

void G4ChordFinderDelegate< G4MagInt_Driver >::StreamDelegateInfo ( std::ostream & os ) const

inherited

◆ StreamInfo()

void G4MagInt_Driver::StreamInfo ( std::ostream & os ) const

overridevirtual

Implements G4VIntegrationDriver.

Definition at line 1036 of file G4MagIntegratorDriver.cc.

{
    os << "State of G4MagInt_Driver: " << std::endl;
    os << "  Max number of Steps = " << fMaxNoSteps
       << "    (base # = " << fMaxStepBase << " )" << std::endl;
    os << "  Safety factor       = " << safety  << std::endl;
    os << "  Power - shrink      = " << pshrnk << std::endl;
    os << "  Power - grow        = " << pgrow << std::endl;
    os << "  threshold (errcon)  = " << errcon << std::endl;
 
    os << "    fMinimumStep =      " << fMinimumStep  << std::endl;
    os << "    Smallest Fraction = " << fSmallestFraction << std::endl;
 
    os << "    No Integrat Vars  = " << fNoIntegrationVariables << std::endl;
    os << "    Min No Vars       = " << fMinNoVars << std::endl;
    os << "    Num-Vars          = " << fNoVars << std::endl;
    
    os << "    verbose level     = " << fVerboseLevel << std::endl;
    os << "    Reintegrates      = " << DoesReIntegrate() << std::endl;
}

References DoesReIntegrate(), errcon, fMaxNoSteps, fMaxStepBase, fMinimumStep, fMinNoVars, fNoIntegrationVariables, fNoVars, fSmallestFraction, fVerboseLevel, pgrow, pshrnk, and safety.

◆ TestChordPrint()

void G4ChordFinderDelegate< G4MagInt_Driver >::TestChordPrint	(	G4int	noTrials,
		G4int	lastStepTrial,
		G4double	dChordStep,
		G4double	fDeltaChord,
		G4double	nextStepTrial
	)

inherited

◆ WarnEndPointTooFar()

void G4MagInt_Driver::WarnEndPointTooFar	(	G4double	endPointDist,
		G4double	hStepSize,
		G4double	epsilonRelative,
		G4int	debugFlag
	)

protected

Definition at line 449 of file G4MagIntegratorDriver.cc.

{
  static G4ThreadLocal G4double maxRelError = 0.0;
  G4bool isNewMax, prNewMax;
 
  isNewMax = endPointDist > (1.0 + maxRelError) * h;
  prNewMax = endPointDist > (1.0 + 1.05 * maxRelError) * h;
  if( isNewMax ) { maxRelError= endPointDist / h - 1.0; }
 
  if( dbg && (h > G4GeometryTolerance::GetInstance()->GetSurfaceTolerance()) 
          && ( (dbg>1) || prNewMax || (endPointDist >= h*(1.+eps) ) ) )
  { 
    static G4ThreadLocal G4int noWarnings = 0;
    std::ostringstream message;
    if( (noWarnings++ < 10) || (dbg>2) )
    {
      message << "The integration produced an end-point which " << G4endl
              << "is further from the start-point than the curve length."
              << G4endl;
    }
    message << "  Distance of endpoints = " << endPointDist
            << ", curve length = " << h << G4endl
            << "  Difference (curveLen-endpDist)= " << (h - endPointDist)
            << ", relative = " << (h-endPointDist) / h 
            << ", epsilon =  " << eps;
    G4Exception("G4MagInt_Driver::WarnEndPointTooFar()", "GeomField1001",
                JustWarning, message);
  }
}

References eps, G4endl, G4Exception(), G4ThreadLocal, G4GeometryTolerance::GetInstance(), G4GeometryTolerance::GetSurfaceTolerance(), and JustWarning.

Referenced by AccurateAdvance().

◆ WarnSmallStepSize()

void G4MagInt_Driver::WarnSmallStepSize	(	G4double	hnext,
		G4double	hstep,
		G4double	h,
		G4double	xDone,
		G4int	noSteps
	)

protected

Definition at line 400 of file G4MagIntegratorDriver.cc.

{
  static G4ThreadLocal G4int noWarningsIssued = 0;
  const  G4int maxNoWarnings = 10;   // Number of verbose warnings
  std::ostringstream message;
  if( (noWarningsIssued < maxNoWarnings) || fVerboseLevel > 10 )
  {
    message << "The stepsize for the next iteration, " << hnext
            << ", is too small - in Step number " << nstp << "." << G4endl
            << "The minimum for the driver is " << Hmin()  << G4endl
            << "Requested integr. length was " << hstep << " ." << G4endl
            << "The size of this sub-step was " << h     << " ." << G4endl
            << "The integrations has already gone " << xDone;
  }
  else
  {
    message << "Too small 'next' step " << hnext
            << ", step-no: " << nstp << G4endl
            << ", this sub-step: " << h     
            << ",  req_tot_len: " << hstep 
            << ", done: " << xDone << ", min: " << Hmin();
  }
  G4Exception("G4MagInt_Driver::WarnSmallStepSize()", "GeomField1001",
              JustWarning, message);
  ++noWarningsIssued;
}

References fVerboseLevel, G4endl, G4Exception(), G4ThreadLocal, Hmin(), and JustWarning.

Referenced by AccurateAdvance().

◆ WarnTooManyStep()

void G4MagInt_Driver::WarnTooManyStep	(	G4double	x1start,
		G4double	x2end,
		G4double	xCurrent
	)

protected

Definition at line 432 of file G4MagIntegratorDriver.cc.

{
   std::ostringstream message;
   message << "The number of steps used in the Integration driver"
           << " (Runge-Kutta) is too many." << G4endl
           << "Integration of the interval was not completed !" << G4endl
           << "Only a " << (xCurrent-x1start)*100/(x2end-x1start)
           << " % fraction of it was done.";
   G4Exception("G4MagInt_Driver::WarnTooManyStep()", "GeomField1001",
               JustWarning, message);
}

References G4endl, G4Exception(), and JustWarning.

Referenced by AccurateAdvance().

Field Documentation

◆ errcon

G4double G4MagInt_Driver::errcon

private

Definition at line 250 of file G4MagIntegratorDriver.hh.

Referenced by ComputeNewStepSize_WithinLimits(), OneGoodStep(), and StreamInfo().

◆ fDyerr_max

G4double G4MagInt_Driver::fDyerr_max =0.0

private

Definition at line 265 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance().

◆ fDyerr_mx2

G4double G4MagInt_Driver::fDyerr_mx2 =0.0

private

Definition at line 265 of file G4MagIntegratorDriver.hh.

◆ fDyerrPos_lgTot

G4double G4MagInt_Driver::fDyerrPos_lgTot =0.0

private

Definition at line 266 of file G4MagIntegratorDriver.hh.

◆ fDyerrPos_smTot

G4double G4MagInt_Driver::fDyerrPos_smTot =0.0

private

Definition at line 266 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance().

◆ fDyerrVel_lgTot

G4double G4MagInt_Driver::fDyerrVel_lgTot =0.0

private

Definition at line 266 of file G4MagIntegratorDriver.hh.

◆ fFirstFraction

G4double G4ChordFinderDelegate< G4MagInt_Driver >::fFirstFraction

privateinherited

Definition at line 101 of file G4ChordFinderDelegate.hh.

◆ fFractionLast

G4double G4ChordFinderDelegate< G4MagInt_Driver >::fFractionLast

privateinherited

Definition at line 102 of file G4ChordFinderDelegate.hh.

◆ fFractionNextEstimate

G4double G4ChordFinderDelegate< G4MagInt_Driver >::fFractionNextEstimate

privateinherited

Definition at line 103 of file G4ChordFinderDelegate.hh.

◆ fLastStepEstimate_Unconstrained

G4double G4ChordFinderDelegate< G4MagInt_Driver >::fLastStepEstimate_Unconstrained

privateinherited

Definition at line 104 of file G4ChordFinderDelegate.hh.

◆ fMaxNoSteps

G4int G4MagInt_Driver::fMaxNoSteps

private

Definition at line 243 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), G4MagInt_Driver(), and StreamInfo().

◆ fMaxStepBase

G4int G4MagInt_Driver::fMaxStepBase = 250

private

Definition at line 244 of file G4MagIntegratorDriver.hh.

Referenced by G4MagInt_Driver(), and StreamInfo().

◆ fmaxTrials

G4int G4ChordFinderDelegate< G4MagInt_Driver >::fmaxTrials

privateinherited

Definition at line 108 of file G4ChordFinderDelegate.hh.

◆ fMinimumStep

G4double G4MagInt_Driver::fMinimumStep = 0.0

private

Definition at line 233 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), G4MagInt_Driver(), OneGoodStep(), and StreamInfo().

◆ fMinNoVars

const G4int G4MagInt_Driver::fMinNoVars = 12

private

Definition at line 240 of file G4MagIntegratorDriver.hh.

Referenced by StreamInfo().

◆ fNoBadSteps

unsigned long G4MagInt_Driver::fNoBadSteps =0

private

Definition at line 263 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), and PrintStatisticsReport().

◆ fNoCalls

unsigned long G4MagInt_Driver::fNoCalls =0

private

Definition at line 264 of file G4MagIntegratorDriver.hh.

◆ fNoInitialSmallSteps

unsigned long G4MagInt_Driver::fNoInitialSmallSteps =0

private

Definition at line 264 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), and PrintStatisticsReport().

◆ fNoIntegrationVariables

const G4int G4MagInt_Driver::fNoIntegrationVariables = 0

private

Definition at line 239 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), OneGoodStep(), PrintStatus(), QuickAdvance(), and StreamInfo().

◆ fNoSmallSteps

unsigned long G4MagInt_Driver::fNoSmallSteps =0

private

Definition at line 264 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), and PrintStatisticsReport().

◆ fNoTotalSteps

unsigned long G4MagInt_Driver::fNoTotalSteps =0

private

Definition at line 263 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), and PrintStatisticsReport().

◆ fNoVars

const G4int G4MagInt_Driver::fNoVars = 0

private

Definition at line 241 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), and StreamInfo().

◆ fSmallestFraction

G4double G4MagInt_Driver::fSmallestFraction = 1.0e-12

private

Definition at line 235 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), SetSmallestFraction(), and StreamInfo().

◆ fStatisticsVerboseLevel

G4int G4MagInt_Driver::fStatisticsVerboseLevel = 0

private

Definition at line 253 of file G4MagIntegratorDriver.hh.

Referenced by G4MagInt_Driver(), and ~G4MagInt_Driver().

◆ fSumH_lg

G4double G4MagInt_Driver::fSumH_lg =0.0

private

Definition at line 267 of file G4MagIntegratorDriver.hh.

◆ fSumH_sm

G4double G4MagInt_Driver::fSumH_sm =0.0

private

Definition at line 267 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance().

◆ fTotalNoTrials

G4int G4ChordFinderDelegate< G4MagInt_Driver >::fTotalNoTrials

privateinherited

Definition at line 106 of file G4ChordFinderDelegate.hh.

◆ fVerboseLevel

G4int G4MagInt_Driver::fVerboseLevel = 0

private

Definition at line 270 of file G4MagIntegratorDriver.hh.

Referenced by G4MagInt_Driver(), PrintStatus(), QuickAdvance(), StreamInfo(), and WarnSmallStepSize().

◆ max_stepping_decrease

constexpr G4double G4VIntegrationDriver::max_stepping_decrease = 0.1

staticconstexprprotectedinherited

Definition at line 123 of file G4VIntegrationDriver.hh.

Referenced by ComputeNewStepSize_WithinLimits(), and G4OldMagIntDriver::ComputeNewStepSize_WithinLimits().

◆ max_stepping_increase

constexpr G4double G4VIntegrationDriver::max_stepping_increase = 5

staticconstexprprotectedinherited

Definition at line 122 of file G4VIntegrationDriver.hh.

Referenced by G4OldMagIntDriver::ComputeNewStepSize(), ComputeNewStepSize_WithinLimits(), G4OldMagIntDriver::ComputeNewStepSize_WithinLimits(), ComputeNewStepSize_WithoutReductionLimit(), OneGoodStep(), and G4OldMagIntDriver::OneGoodStep().

◆ pgrow

G4double G4MagInt_Driver::pgrow

private

Definition at line 249 of file G4MagIntegratorDriver.hh.

Referenced by StreamInfo().

◆ pIntStepper

G4MagIntegratorStepper* G4MagInt_Driver::pIntStepper = nullptr

private

Definition at line 258 of file G4MagIntegratorDriver.hh.

Referenced by AccurateAdvance(), G4MagInt_Driver(), GetDerivatives(), GetEquationOfMotion(), GetStepper(), OneGoodStep(), QuickAdvance(), RenewStepperAndAdjust(), and SetEquationOfMotion().

◆ pshrnk

G4double G4MagInt_Driver::pshrnk

private

Definition at line 248 of file G4MagIntegratorDriver.hh.

Referenced by StreamInfo().

◆ safety

G4double G4MagInt_Driver::safety

private

Definition at line 247 of file G4MagIntegratorDriver.hh.

Referenced by StreamInfo().

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

source/geometry/magneticfield/include/G4MagIntegratorDriver.hh
source/geometry/magneticfield/src/G4MagIntegratorDriver.cc

Public Member Functions

Protected Member Functions

Static Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ChordFinderDelegate

Constructor & Destructor Documentation

◆ G4MagInt_Driver() [1/2]

◆ ~G4MagInt_Driver()

◆ G4MagInt_Driver() [2/2]

Member Function Documentation

◆ AccumulateStatistics()

◆ AccurateAdvance()

◆ AdvanceChordLimited()

◆ AdvanceChordLimitedImpl()

◆ ComputeAndSetErrcon()

◆ ComputeNewStepSize()

◆ ComputeNewStepSize_WithinLimits()

◆ ComputeNewStepSize_WithoutReductionLimit()

◆ DoesReIntegrate()

◆ FindNextChord()

◆ GetDerivatives() [1/2]

◆ GetDerivatives() [2/2]

◆ GetDriver()

◆ GetEquationOfMotion()

◆ GetErrcon()

◆ GetFirstFraction()

◆ GetFractionLast()

◆ GetFractionNextEstimate()

◆ GetHmin()

◆ GetLastStepEstimateUnc()

◆ GetMaxNoSteps()

◆ GetNoCalls()

◆ GetNoMaxTrials()

◆ GetNoTrials()

◆ GetPgrow()

◆ GetPshrnk()

◆ GetSafety()

◆ GetSmallestFraction()

◆ GetStepper() [1/2]

◆ GetStepper() [2/2]

◆ GetVerboseLevel()

◆ Hmin()

◆ NewStep()

◆ OnComputeStep()

◆ OneGoodStep()

◆ OnStartTracking()

◆ operator=()

◆ PrintStat_Aux()

◆ PrintStatistics()

◆ PrintStatisticsReport()

◆ PrintStatus() [1/2]

◆ PrintStatus() [2/2]

◆ QuickAdvance() [1/2]

◆ QuickAdvance() [2/2]

◆ RenewStepperAndAdjust()

◆ ReSetParameters()

◆ ResetStepEstimate()

◆ SetEquationOfMotion()

◆ SetErrcon()

◆ SetFirstFraction()

◆ SetFractions_Last_Next()

◆ SetHmin()

◆ SetLastStepEstimateUnc()

◆ SetMaxNoSteps()

◆ SetPgrow()

◆ SetPshrnk()

◆ SetSafety()

◆ SetSmallestFraction()

◆ SetVerboseLevel()

◆ StreamDelegateInfo()

◆ StreamInfo()

◆ TestChordPrint()

◆ WarnEndPointTooFar()

◆ WarnSmallStepSize()

◆ WarnTooManyStep()

Field Documentation