G4QSStepper< QSS > Class Template Reference

#include <G4QSStepper.hh>

Inheritance diagram for G4QSStepper< QSS >:

Public Member Functions
	G4QSStepper (G4EquationOfMotion *EqRhs, G4int numberOfVariables=6, G4bool primary=true)
	~G4QSStepper () override
void	Stepper (const G4double y[], const G4double dydx[], G4double h, G4double yout[], G4double yerr[]) override
void	Stepper (const G4double yInput[], const G4double dydx[], G4double hstep, G4double yOutput[], G4double yError[], G4double dydxOutput[])
void	SetupInterpolation ()
void	Interpolate (G4double tau, G4double yOut[])
G4double	DistChord () const override
G4int	IntegratorOrder () const override
void	reset (const G4FieldTrack *track)
void	SetPrecision (G4double dq_rel, G4double dq_min)
G4EquationOfMotion *	GetSpecificEquation ()
const field_utils::State &	GetYOut () const
G4double	GetLastStepLength ()
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)

Static Public Member Functions
static G4QSStepper< G4QSS2 > *	build_QSS2 (G4EquationOfMotion *EqRhs, G4int numberOfVariables=6, G4bool primary=true)
static G4QSStepper< G4QSS3 > *	build_QSS3 (G4EquationOfMotion *EqRhs, G4int numberOfVariables=6, G4bool primary=true)

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

Detailed Description

template<class QSS>
class G4QSStepper< QSS >

Definition at line 53 of file G4QSStepper.hh.

Constructor & Destructor Documentation

G4QSStepper()

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

Definition at line 34 of file G4QSStepper.cc.

  : G4QSStepper(new G4QSS3(G4QSStepper_QSS3::build_simulator()),
                EqRhs, numberOfVariables, primary)
{
}

Referenced by G4QSStepper< QSS >::build_QSS2(), and G4QSStepper< QSS >::build_QSS3().

~G4QSStepper()

template<class QSS >

G4QSStepper< QSS >::~G4QSStepper ( )

inlineoverride

Definition at line 192 of file G4QSStepper.hh.

{
  for (auto & i : simulator->SD) { free(i); }
 
  free(SUBSTEPS(this->simulator));
  free(this->simulator);
}

Member Function Documentation

build_QSS2()

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

static

Definition at line 52 of file G4QSStepper.cc.

{
  return new G4QSStepper<G4QSS2>(EqRhs, noIntegrationVariables, primary);
}

Referenced by G4QSSDriverCreator::CreateQss2Driver().

build_QSS3()

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

static

Definition at line 60 of file G4QSStepper.cc.

{
  return new G4QSStepper<G4QSS3>(EqRhs, noIntegrationVariables, primary);
}

Referenced by G4QSSDriverCreator::CreateQss3Driver(), and G4QSSDriverCreator::CreateQss3Stepper().

DistChord()

template<class QSS >

G4double G4QSStepper< QSS >::DistChord ( ) const

inlineoverridevirtual

Implements G4MagIntegratorStepper.

Definition at line 331 of file G4QSStepper.hh.

{
  G4double yMid[6];
  const_cast<G4QSStepper<QSS>*>(this)->Interpolate(0.5, yMid);
 
  const G4ThreeVector begin = makeVector(fyIn, field_utils::Value3D::Position);
  const G4ThreeVector end = makeVector(fyOut, field_utils::Value3D::Position);
  const G4ThreeVector mid = makeVector(yMid, field_utils::Value3D::Position);
 
  return G4LineSection::Distline(mid, begin, end);
}

GetLastStepLength()

template<class QSS >

G4double G4QSStepper< QSS >::GetLastStepLength ( )

inline

Definition at line 101 of file G4QSStepper.hh.

{ return fLastStepLength; }

GetSpecificEquation()

template<class QSS >

G4EquationOfMotion * G4QSStepper< QSS >::GetSpecificEquation ( )

inline

Definition at line 97 of file G4QSStepper.hh.

{ return GetEquationOfMotion(); }

GetYOut()

template<class QSS >

const field_utils::State & G4QSStepper< QSS >::GetYOut ( ) const

inline

Definition at line 99 of file G4QSStepper.hh.

{ return fyOut; }

IntegratorOrder()

template<class QSS >

G4int G4QSStepper< QSS >::IntegratorOrder ( ) const

inlineoverridevirtual

Implements G4MagIntegratorStepper.

Definition at line 82 of file G4QSStepper.hh.

{ return method->order(); }

Interpolate()

template<class QSS >

void G4QSStepper< QSS >::Interpolate ( G4double tau, G4double yOut[] )

inline

Definition at line 344 of file G4QSStepper.hh.

{
  G4double length = tau * fLastStepLength;
  G4int idx = 0, j = LAST_SUBSTEP(simulator);
  G4double end_time;
 
  if (j >= 15) {
    G4int i = 0, k = j;
    idx = j >> 1;
    while (idx < k && i < j - 1) {
      if (length < SUBSTEP_LEN(simulator, idx)) {
        j = idx;
      } else if (length >= SUBSTEP_LEN(simulator, idx + 1)) {
        i = idx;
      } else {
        break;
      }
 
      idx = (i + j) >> 1;
    }
  }
  else {
    for (; idx < j && length >= SUBSTEP_LEN(simulator, idx + 1); idx++) {;}
  }
 
  auto* const substep = &SUBSTEP_STRUCT(simulator, idx);
  end_time = substep->start_time + (length - substep->len) / fVelocity;
 
  this->get_state_from_poly(substep->x, substep->tx, end_time, yOut);
 
  velocity_to_momentum(yOut);
}

reset()

template<class QSS >

void G4QSStepper< QSS >::reset ( const G4FieldTrack * track )

inline

Definition at line 378 of file G4QSStepper.hh.

{
  using Qss_misc::PXidx;
  using Qss_misc::PYidx;
  using Qss_misc::PZidx;
  using Qss_misc::VXidx;
  using Qss_misc::VYidx;
  using Qss_misc::VZidx;
 
  G4ThreeVector pos = track->GetPosition();
  G4ThreeVector momentum = track->GetMomentum();
 
  f_mass = track->GetRestMass();
  set_charge(track->GetCharge());
  set_gamma(momentum.mag2());
  G4double c_mg = cLight_local / fMassGamma;
  set_velocity(momentum.mag() * c_mg);
 
  method->reset_state(PXidx, pos.getX());
  method->reset_state(PYidx, pos.getY());
  method->reset_state(PZidx, pos.getZ());
 
  method->reset_state(VXidx, momentum.getX() * c_mg);
  method->reset_state(VYidx, momentum.getY() * c_mg);
  method->reset_state(VZidx, momentum.getZ() * c_mg);
 
  this->update_field();
  method->full_definition(get_coeff());
 
  method->recompute_all_state_times(0);
 
  simulator->time = 0;
}

SetPrecision()

template<class QSS >

void G4QSStepper< QSS >::SetPrecision ( G4double dq_rel, G4double dq_min )

inline

Definition at line 413 of file G4QSStepper.hh.

{
  G4double* dQMin = simulator->dQMin;
  G4double* dQRel = simulator->dQRel;
  G4int n_vars = simulator->states;
 
  if (dq_min <= 0) { dq_min = dq_rel * 1e-3; }
 
  for (G4int i = 0; i < n_vars; ++i) {
    dQRel[i] = dq_rel;
    dQMin[i] = dq_min;
  }
}

SetupInterpolation()

template<class QSS >

void G4QSStepper< QSS >::SetupInterpolation ( )

inline

Definition at line 77 of file G4QSStepper.hh.

{}

Stepper() [1/2]

template<class QSS >

void G4QSStepper< QSS >::Stepper ( const G4double y[], const G4double dydx[], G4double h, G4double yout[], G4double yerr[] )

inlineoverridevirtual

Implements G4MagIntegratorStepper.

Definition at line 242 of file G4QSStepper.hh.

{
  G4double elapsed;
  G4double t, prev_time = 0;
  G4double length = 0.;
  G4int index;
 
  const G4int coeffs = method->order() + 1;
  G4double* tq = simulator->tq;
  G4double* tx = simulator->tx;
  G4double* dQRel = simulator->dQRel;
  G4double* dQMin = simulator->dQMin;
  G4double* lqu = simulator->lqu;
  G4double* x = simulator->x;
  G4int** SD = simulator->SD;
  G4int cf0, infCf0;
 
  CUR_SUBSTEP(simulator) = 0;
 
  this->save_substep(0, length);
 
  this->update_time();
  t = simulator->time;
  index = simulator->minIndex;
 
  while (length < max_length && t < Qss_misc::INF && CUR_SUBSTEP(simulator) < QSS_MAX_SUBSTEPS) {
    cf0 = index * coeffs;
    elapsed = t - tx[index];
    method->advance_time_x(cf0, elapsed);
    tx[index] = t;
    lqu[index] = dQRel[index] * std::fabs(x[cf0]);
    if (lqu[index] < dQMin[index]) {
      lqu[index] = dQMin[index];
    }
    method->update_quantized_state(index);
    tq[index] = t;
    method->next_time(index, t);
    for (G4int i = 0; i < 3; i++) {
      G4int j = SD[index][i];
      elapsed = t - tx[j];
      infCf0 = j * coeffs;
      if (elapsed > 0) {
        x[infCf0] = method->evaluate_x_poly(infCf0, elapsed, x);
        tx[j] = t;
      }
    }
 
    this->update_field();
    this->recompute_derivatives(index);
    method->recompute_next_times(SD[index], t);
 
    if (t > prev_time) {
      length += fVelocity * (t - prev_time);
      if (length <= max_length) { this->save_substep(t, length); }
      else { break; }
    }
 
    this->update_time();
    prev_time = t;
    t = simulator->time;
    index = simulator->minIndex;
  }
 
  if(CUR_SUBSTEP(simulator) >= QSS_MAX_SUBSTEPS) {
    max_length = length;
  }
 
  auto* const substep = &LAST_SUBSTEP_STRUCT(simulator);
  t = substep->start_time + (max_length - substep->len) / fVelocity;
 
  this->get_state_from_poly(substep->x, substep->tx, t, yOut);
 
  velocity_to_momentum(yOut);
 
  const G4int numberOfVariables = GetNumberOfVariables();
  for (G4int i = 0; i < numberOfVariables; ++i) {
    // Store Input and Final values, for possible use in calculating chord
    fyIn[i] = yInput[i];
    fyOut[i] = yOut[i];
  }
 
  fLastStepLength = max_length;
}

Stepper() [2/2]

template<class QSS >

void G4QSStepper< QSS >::Stepper ( const G4double yInput[], const G4double dydx[], G4double hstep, G4double yOutput[], G4double yError[], G4double dydxOutput[] )

inline

Definition at line 201 of file G4QSStepper.hh.

{
  Stepper(yInput, dydx, hstep, yOutput, yError);
}

---

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

• G4QSStepper.hh
• G4QSStepper.cc