Trk::RungeKuttaPropagator Class Reference

Trk::RungeKuttaPropagator is an algorithm for track parameters propagation through magnetic field. More...

#include <RungeKuttaPropagator.h>

Inheritance diagram for Trk::RungeKuttaPropagator:

Collaboration diagram for Trk::RungeKuttaPropagator:

Classes
struct	Cache

Public Member Functions
	RungeKuttaPropagator (const std::string &, const std::string &, const IInterface *)
virtual StatusCode	initialize () override final
virtual	~RungeKuttaPropagator ()=default
virtual std::unique_ptr< NeutralParameters >	propagate (const NeutralParameters &, const Surface &, PropDirection, const BoundaryCheck &, bool) const override final
	Main propagation method for NeutralParameters.
virtual std::unique_ptr< TrackParameters >	propagate (const EventContext &ctx, const TrackParameters &, const Surface &, const PropDirection, const BoundaryCheck &, const MagneticFieldProperties &, ParticleHypothesis, bool, const TrackingVolume *) const override final
	Main propagation method without transport jacobian production.
virtual Trk::MultiComponentState	multiStatePropagate (const EventContext &ctx, const MultiComponentState &multiComponentState, const Surface &surface, const MagneticFieldProperties &fieldProperties, const PropDirection direction=Trk::anyDirection, const BoundaryCheck &boundaryCheck=true, const ParticleHypothesis particleHypothesis=nonInteracting) const override final
	Main propagation method for Multi Component state.
virtual std::unique_ptr< TrackParameters >	propagate (const EventContext &ctx, const TrackParameters &, const Surface &, const PropDirection, const BoundaryCheck &, const MagneticFieldProperties &, std::optional< TransportJacobian > &, double &, ParticleHypothesis, bool, const TrackingVolume *) const override final
	Main propagation method with transport jacobian production.
virtual std::unique_ptr< TrackParameters >	propagate (const EventContext &ctx, const TrackParameters &, std::vector< DestSurf > &, PropDirection, const MagneticFieldProperties &, ParticleHypothesis, std::vector< unsigned int > &, double &, bool, bool, const TrackingVolume *) const override final
	The propagation method finds the closest surface.
virtual std::unique_ptr< TrackParameters >	propagateParameters (const EventContext &ctx, const TrackParameters &, const Surface &, const PropDirection, const BoundaryCheck &, const MagneticFieldProperties &, ParticleHypothesis, bool, const TrackingVolume *) const override final
	Main propagation method for parameters only.
virtual std::unique_ptr< TrackParameters >	propagateParameters (const EventContext &ctx, const TrackParameters &, const Surface &, const PropDirection, const BoundaryCheck &, const MagneticFieldProperties &, std::optional< TransportJacobian > &, ParticleHypothesis, bool, const TrackingVolume *) const override final
	Main propagation method for parameters only with transport jacobian production.
virtual std::optional< Trk::TrackSurfaceIntersection >	intersect (const EventContext &ctx, const TrackParameters &, const Surface &, const MagneticFieldProperties &, ParticleHypothesis, const TrackingVolume *tvol=nullptr) const override final
	Global position together with direction of the trajectory on the surface.
virtual void	globalPositions (const EventContext &ctx, std::deque< Amg::Vector3D > &, const TrackParameters &, const MagneticFieldProperties &, const CylinderBounds &, double, ParticleHypothesis, const TrackingVolume *tvol=nullptr) const override final
	GlobalPositions list interface:
virtual bool	propagate (const EventContext &ctx, PatternTrackParameters &, const Surface &, PatternTrackParameters &, PropDirection, const MagneticFieldProperties &, ParticleHypothesis particle=pion) const override final
	Main propagation method.
virtual bool	propagate (const EventContext &ctx, PatternTrackParameters &, const Surface &, PatternTrackParameters &, PropDirection, const MagneticFieldProperties &, double &, ParticleHypothesis particle=pion) const override final
	Main propagation method with step to surface calculation.
virtual bool	propagateParameters (const EventContext &ctx, PatternTrackParameters &, const Surface &, PatternTrackParameters &, PropDirection, const MagneticFieldProperties &, ParticleHypothesis particle=pion) const override final
	Main propagation method for parameters only.
virtual bool	propagateParameters (const EventContext &ctx, PatternTrackParameters &, const Surface &, PatternTrackParameters &, PropDirection, const MagneticFieldProperties &, double &, ParticleHypothesis particle=pion) const override final
	Main propagation method for parameters only with step to surface calculation.
virtual void	globalPositions (const EventContext &ctx, const PatternTrackParameters &, std::vector< const Surface * > &, std::vector< std::pair< Amg::Vector3D, double > > &, const MagneticFieldProperties &, ParticleHypothesis particle=pion) const override final
virtual std::unique_ptr< Trk::TrackParameters >	propagateT (const EventContext &, const TrackParameters &, std::vector< DestSurf > &, PropDirection, const MagneticFieldProperties &, ParticleHypothesis, std::vector< unsigned int > &, PathLimit &, TimeLimit &, bool, const Trk::TrackingVolume *, std::vector< Trk::HitInfo > *&) const override final
	unimplemented propagateT
virtual std::unique_ptr< Trk::TrackParameters >	propagateM (const EventContext &, const TrackParameters &, std::vector< DestSurf > &, PropDirection, const MagneticFieldProperties &, ParticleHypothesis, std::vector< unsigned int > &, std::vector< const Trk::TrackStateOnSurface * > *, std::vector< std::pair< std::unique_ptr< Trk::TrackParameters >, int > > *, double &, bool, bool, const Trk::TrackingVolume *, Trk::ExtrapolationCache *) const override final
	unimplemented propagateM
virtual std::optional< Trk::TrackSurfaceIntersection >	intersectSurface (const EventContext &, const Surface &, const TrackSurfaceIntersection &, const double, const MagneticFieldProperties &, ParticleHypothesis) const override final
	unimplemented intersectSurface
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	AlgTool and IAlgTool interface methods.
static const InterfaceID &	interfaceID ()
	framework method providing the abstract interface

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
Cache	getInitializedCache (const EventContext &ctx) const
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCondObjInputKey
DoubleProperty	m_dlt {this, "AccuracyParameter", 0.0002}
DoubleProperty	m_helixStep {this, "MaxHelixStep", 1.}
DoubleProperty	m_straightStep {this, "MaxStraightLineStep", 0.01}
BooleanProperty	m_usegradient
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Trk::RungeKuttaPropagator is an algorithm for track parameters propagation through magnetic field.

The implementation performs the propagation in global coordinates and uses Jacobian matrices (see RungeKuttaUtils) for the transformations between the global frame and local surface-attached coordinate systems.

One can choose to perform the transport of the parameters only and omit the transport of the associated covariances (propagateParameters).

The algorithm can produce the Jacobian that transports the covariance matrix from one set of track parameters at the initial surface to another set of track parameters at the destination surface. This is useful for Chi2 fitting.

It does NOT include material effects (unlike the STEP propagator). As a result the ParticleHypothesis argument is not really used. It is assumed that in the client code , the propagation, transport of the track parameters and their associated covariances, is decoupled from the actual corrections due to interaction with the detector material.

The algorithm contains three steps :

1.The first step of the algorithm is track parameters transformation from local presentation for given start surface to global Runge Kutta coordinates.

2.The second step is propagation through the magnetic field with or without jacobian.

3.Third step is transformation from global Runge Kutta presentation to local presentation of given output surface.

AtaPlane AtaStraightLine AtaDisc AtaCylinder Perigee | | | | | | | | | |

V V V V V

| Local->Global transformation V Global position (Runge Kutta presentation) | | Propagation to next surface with or without jacobian using Nystroem algorithm (See Handbook Net. Bur. of Standards, procedure 25.5.20) |

V Global->Local transformation

| | | | | | | | | | V V V V V PlaneSurface StraightLineSurface DiscSurface CylinderSurface PerigeeSurface

For propagation using Runge Kutta method we use global coordinates, direction, inverse momentum and Jacobian of transformation. All these parameters we save in an array P[42]

              /dL0    /dL1    /dPhi   /dThe   /dCM

X ->P[0] dX/ P[ 7] P[14] P[21] P[28] P[35] Y ->P[1] dY/ P[ 8] P[15] P[22] P[29] P[36] Z ->P[2] dZ/ P[ 9] P[16] P[23] P[30] P[37] Ax ->P[3] dAx/ P[10] P[17] P[24] P[31] P[38] Ay ->P[4] dAy/ P[11] P[18] P[25] P[32] P[39] Az ->P[5] dAz/ P[12] P[19] P[26] P[33] P[40] CM ->P[6] dCM/ P[13] P[20] P[27] P[34] P[41]

where in case of local re-presentation

L0 - first local coordinate (surface dependent) L1 - second local coordinate (surface dependent) Phi - Azimuthal angle The - Polar angle CM - charge/momentum

in case of global re-presentation

X - global x-coordinate = surface dependent Y - global y-coordinate = surface dependent Z - global z-coordinate = sutface dependent Ax - direction cosine to x-axis = Sin(The)*Cos(Phi) Ay - direction cosine to y-axis = Sin(The)*Sin(Phi) Az - direction cosine to z-axis = Cos(The) CM - charge/momentum = local CM

Author

Igor..nosp@m.Gavr.nosp@m.ilenk.nosp@m.o@ce.nosp@m.rn.ch

Authors

RD Schaffer C Anastopoulos AthenaMT modifications

Definition at line 130 of file RungeKuttaPropagator.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

RungeKuttaPropagator()

Trk::RungeKuttaPropagator::RungeKuttaPropagator	(	const std::string &	p,
		const std::string &	n,
		const IInterface *	t )

Definition at line 1380 of file RungeKuttaPropagator.cxx.

    : AthAlgTool(p, n, t)
{
  declareInterface<Trk::IPropagator>(this);
  declareInterface<Trk::IPatternParametersPropagator>(this);
}

~RungeKuttaPropagator()

virtual Trk::RungeKuttaPropagator::~RungeKuttaPropagator ( )

virtualdefault

Member Function Documentation

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

getInitializedCache()

Cache Trk::RungeKuttaPropagator::getInitializedCache ( const EventContext & ctx ) const

private

Definition at line 1914 of file RungeKuttaPropagator.cxx.

{
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCondObjInputKey,
                                                        ctx};
  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
  Cache cache{};
  fieldCondObj->getInitializedCache(cache.m_fieldCache);
  cache.m_dlt = m_dlt;
  cache.m_helixStep = m_helixStep;
  cache.m_straightStep = m_straightStep;
  cache.m_usegradient = m_usegradient;
  return cache;
}

globalPositions() [1/2]

void Trk::RungeKuttaPropagator::globalPositions ( const EventContext & ctx, const PatternTrackParameters & Tp, std::vector< const Surface * > & SU, std::vector< std::pair< Amg::Vector3D, double > > & GP, const MagneticFieldProperties & M, ParticleHypothesis particle = pion ) const

finaloverridevirtual

Implements Trk::IPatternParametersPropagator.

Definition at line 1902 of file RungeKuttaPropagator.cxx.

{
  Cache cache = getInitializedCache(ctx);
  globalPositionsImpl(cache, Tp, SU, GP, M);
}

globalPositions() [2/2]

void Trk::RungeKuttaPropagator::globalPositions ( const EventContext & ctx, std::deque< Amg::Vector3D > & GP, const TrackParameters & Tp, const MagneticFieldProperties & M, const CylinderBounds & CB, double mS, ParticleHypothesis , const TrackingVolume * tvol = nullptr ) const

finaloverridevirtual

GlobalPositions list interface:

Implements Trk::IPropagator.

Definition at line 1771 of file RungeKuttaPropagator.cxx.

{
  double P[45];
  if (!Trk::RungeKuttaUtils::transformLocalToGlobal(false, Tp, P))
    return;
  Cache cache = getInitializedCache(ctx);
 
  cache.m_direction = std::abs(mS);
  if (mS > 0.)
    globalOneSidePositions(cache, GP, P, M, CB, mS);
  else
    globalTwoSidePositions(cache, GP, P, M, CB, -mS);
}

initialize()

StatusCode Trk::RungeKuttaPropagator::initialize ( )

finaloverridevirtual

Definition at line 1390 of file RungeKuttaPropagator.cxx.

{
  // Read handle for AtlasFieldCacheCondObj
  ATH_CHECK(m_fieldCondObjInputKey.initialize());
  ATH_MSG_DEBUG("initialize() init key: " << m_fieldCondObjInputKey.key());
  return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID() [1/2]

const InterfaceID & Trk::IPatternParametersPropagator::interfaceID ( )

inlinestaticinherited

framework method providing the abstract interface

Definition at line 107 of file IPatternParametersPropagator.h.

{
        return IID_IPatternParametersPropagator;
}

interfaceID() [2/2]

const InterfaceID & Trk::IPropagator::interfaceID ( )

inlinestaticinherited

AlgTool and IAlgTool interface methods.

Definition at line 60 of file IPropagator.h.

{ return IID_IPropagator; }

intersect()

std::optional< Trk::TrackSurfaceIntersection > Trk::RungeKuttaPropagator::intersect ( const EventContext & ctx, const TrackParameters & Tp, const Surface & Su, const MagneticFieldProperties & M, ParticleHypothesis , const TrackingVolume * tvol = nullptr ) const

finaloverridevirtual

Global position together with direction of the trajectory on the surface.

Implements Trk::IPropagator.

Definition at line 1796 of file RungeKuttaPropagator.cxx.

{
  bool const nJ = false;
  const Trk::Surface* su = &Su;
  Cache cache = getInitializedCache(ctx);
  cache.m_direction = 0.;
  cache.m_needgradient = false;
 
  M.magneticFieldMode() == Trk::FastField ? cache.m_solenoid = true : cache.m_solenoid = false;
  M.magneticFieldMode() != Trk::NoField ? cache.m_mcondition = true : cache.m_mcondition = false;
 
  double P[64];
  if (!Trk::RungeKuttaUtils::transformLocalToGlobal(false, Tp, P)){
    return std::nullopt;
  }
  double Step = 0.;
  if (!propagateWithJacobianSwitch(cache, (*su), nJ, P, Step)) {
    return std::nullopt;
  }
 
  const Amg::Vector3D Glo(P[0], P[1], P[2]);
  const Amg::Vector3D Dir(P[3], P[4], P[5]);
  return std::make_optional<Trk::TrackSurfaceIntersection>(Glo, Dir, Step);
}

intersectSurface()

virtual std::optional< Trk::TrackSurfaceIntersection > Trk::RungeKuttaPropagator::intersectSurface ( const EventContext & , const Surface & , const TrackSurfaceIntersection & , const double , const MagneticFieldProperties & , ParticleHypothesis  ) const

inlinefinaloverridevirtual

unimplemented intersectSurface

Implements Trk::IPropagator.

Definition at line 346 of file RungeKuttaPropagator.h.

  {
    ATH_MSG_ERROR("Call to non-implemented intersectSurface");
    return std::nullopt;
  }

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

multiStatePropagate()

Trk::MultiComponentState Trk::RungeKuttaPropagator::multiStatePropagate ( const EventContext & ctx, const MultiComponentState & multiComponentState, const Surface & surface, const MagneticFieldProperties & fieldProperties, const PropDirection direction = Trk::anyDirection, const BoundaryCheck & boundaryCheck = true, const ParticleHypothesis particleHypothesis = nonInteracting ) const

finaloverridevirtual

Main propagation method for Multi Component state.

Implements Trk::IPropagator.

Definition at line 1441 of file RungeKuttaPropagator.cxx.

{
  Cache cache = getInitializedCache(ctx);
 
  Trk::MultiComponentState propagatedState{};
  propagatedState.reserve(multiComponentState.size());
  double sumw(0);  // sum of the weights of the propagated parameters
  double J[25];
  Trk::MultiComponentState::const_iterator component =
      multiComponentState.begin();
  for (; component != multiComponentState.end(); ++component) {
    const Trk::TrackParameters* currentParameters = component->params.get();
    if (!currentParameters) {
      continue;
    }
    auto propagatedParameters =
        propagateRungeKutta(cache, true, *currentParameters, surface, direction,
                            boundaryCheck, fieldProperties, J, false);
 
    if (!propagatedParameters) {
      continue;
    }
    sumw += component->weight;
    // Propagation does not affect the weightings of the states
    propagatedState.push_back({std::move(propagatedParameters),
                                 component->weight});
  }
  // Protect low weight propagation
  constexpr double minPropWeight = (1./12.);
  if (sumw < minPropWeight) {
    propagatedState.clear();
  }
  return propagatedState;
}

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

propagate() [1/6]

std::unique_ptr< Trk::TrackParameters > Trk::RungeKuttaPropagator::propagate ( const EventContext & ctx, const TrackParameters & Tp, const Surface & Su, const PropDirection D, const BoundaryCheck & B, const MagneticFieldProperties & M, ParticleHypothesis , bool returnCurv, const TrackingVolume *  ) const

finaloverridevirtual

Main propagation method without transport jacobian production.

Implements Trk::IPropagator.

Definition at line 1422 of file RungeKuttaPropagator.cxx.

{
  double J[25];
  Cache cache = getInitializedCache(ctx);
  return propagateRungeKutta(cache, true, Tp, Su, D, B, M, J, returnCurv);
}

propagate() [2/6]

std::unique_ptr< Trk::TrackParameters > Trk::RungeKuttaPropagator::propagate ( const EventContext & ctx, const TrackParameters & Tp, const Surface & Su, const PropDirection D, const BoundaryCheck & B, const MagneticFieldProperties & M, std::optional< TransportJacobian > & Jac, double & pathLength, ParticleHypothesis , bool returnCurv, const TrackingVolume *  ) const

finaloverridevirtual

Main propagation method with transport jacobian production.

Implements Trk::IPropagator.

Definition at line 1488 of file RungeKuttaPropagator.cxx.

{
  double J[25];
  Cache cache = getInitializedCache(ctx);
  pathLength < 0. ? cache.m_maxPath = 10000. : cache.m_maxPath = pathLength;
  auto Tpn = propagateRungeKutta(cache, true, Tp, Su, D, B, M, J, returnCurv);
  pathLength = cache.m_step;
 
  if (Tpn) {
    J[24] = J[20];
    J[23] = 0.;
    J[22] = 0.;
    J[21] = 0.;
    J[20] = 0.;
    Jac = std::make_optional<Trk::TransportJacobian>(J);
  } else
    Jac.reset();
  return Tpn;
}

propagate() [3/6]

std::unique_ptr< Trk::TrackParameters > Trk::RungeKuttaPropagator::propagate ( const EventContext & ctx, const TrackParameters & Tp, std::vector< DestSurf > & DS, PropDirection D, const MagneticFieldProperties & M, ParticleHypothesis , std::vector< unsigned int > & Sol, double & Path, bool usePathLim, bool , const TrackingVolume *  ) const

finaloverridevirtual

The propagation method finds the closest surface.

If the extrapolation surpassed the last boundary it can super duper rarely happen that the propagator is trapped. The propagator then goes the same step back and forth. The flip number limit is kind of a hack to release the propagator from the limbo. The conditions are that the last_st & the current step have to be of the same size but different sign. If this happens a few times the loop is aborted. The chosen number here is at the same level of arbitrariness as the rarity that this branch of the code will be chosen

Update the number of flips. Reset the counter if the last surface is not the same as the current one and then check that the step size & the last step size are the same but of different sign

Implements Trk::IPropagator.

Definition at line 1522 of file RungeKuttaPropagator.cxx.

{
 
  Cache cache = getInitializedCache(ctx);
  Sol.erase(Sol.begin(), Sol.end());
  Path = 0.;
  if (DS.empty())
    return nullptr;
  cache.m_direction = D;
 
  // Test is it measured track parameters
  //
  bool useJac = 0;
  Tp.covariance() ? useJac = true : useJac = false;
 
  // Magnetic field information preparation
  //
  M.magneticFieldMode() == Trk::FastField ? cache.m_solenoid = true : cache.m_solenoid = false;
  (useJac && m_usegradient) ? cache.m_needgradient = true : cache.m_needgradient = false;
  M.magneticFieldMode() != Trk::NoField ? cache.m_mcondition = true : cache.m_mcondition = false;
 
  // Transform to global presentation
  //
 
  double Po[45];
  double Pn[45];
  if (!Trk::RungeKuttaUtils::transformLocalToGlobal(useJac, Tp, Po))
    return nullptr;
  Po[42] = Po[43] = Po[44] = 0.;
 
  // Straight line track propagation for small step
  //
  if (D != 0) {
    double S = cache.m_straightStep;
    if (D < 0)
      S = -S;
    S = straightLineStep(useJac, S, Po);
  }
  double Wmax = 50000.; // Max pass
  double W = 0.;        // Current pass
  double Smax = 100.;   // Max step
  if (D < 0)
    Smax = -Smax;
  if (usePathLim)
    Wmax = std::abs(Path);
 
  std::multimap<double, int> DN;
  double Scut[3];
  int Nveto = Trk::RungeKuttaUtils::fillDistancesMap(DS, DN, Po, W, &Tp.associatedSurface(), Scut);
 
  // Test conditions tor start propagation and chocse direction if D == 0
  //
  if (DN.empty())
    return nullptr;
 
  if (D == 0 && std::abs(Scut[0]) < std::abs(Scut[1]))
    Smax = -Smax;
 
  if (Smax < 0. && Scut[0] > Smax)
    Smax = Scut[0];
  if (Smax > 0. && Scut[1] < Smax)
    Smax = Scut[1];
  if (Wmax > 3. * Scut[2])
    Wmax = 3. * Scut[2];
 
  double Sl = Smax;
  double St = Smax;
  bool InS = false;
 
  for (int i = 0; i != 45; ++i)
    Pn[i] = Po[i];
 
  //----------------------------------Niels van Eldik patch
  double last_St = 0.;
  bool last_InS = !InS;
  bool reverted_P = false;
  //----------------------------------
 
  cache.m_newfield = true;
  constexpr unsigned int max_back_forth_flips{ 100 };
  unsigned int flips{0};
  int last_surface{-1};
 
  while (std::abs(W) < Wmax) {
 
    std::pair<double, int> SN;
    double S = 0;
 
    if (cache.m_mcondition) {
 
      //----------------------------------Niels van Eldik patch
      if (reverted_P && std::abs(St - last_St) <= DBL_EPSILON &&
          InS == last_InS) {
        // inputs are not changed will get same result.
        break;
      }
      last_St = St;
      last_InS = InS;
      //----------------------------------
 
      if (!cache.m_needgradient)
        S = rungeKuttaStep(cache, useJac, St, Pn, InS);
      else
        S = rungeKuttaStepWithGradient(cache, St, Pn, InS);
    } else {
 
      //----------------------------------Niels van Eldik patch
      if (reverted_P && std::abs(St - last_St) <= DBL_EPSILON) {
        // inputs are not changed will get same result.
        break;
      }
      last_St = St;
      last_InS = InS;
      //----------------------------------
 
      S = straightLineStep(useJac, St, Pn);
    }
    //----------------------------------Niels van Eldik patch
    reverted_P = false;
    //----------------------------------
 
    bool next{ false };
    SN = Trk::RungeKuttaUtils::stepEstimator(DS, DN, Po, Pn, W, cache.m_straightStep, Nveto, next);
    if (next) {
      for (int i = 0; i != 45; ++i)
        Po[i] = Pn[i];
      W += S;
      Nveto = -1;
    } else {
      for (int i = 0; i != 45; ++i)
        Pn[i] = Po[i];
      reverted_P = true;
      cache.m_newfield = true;
    }
 
    if (std::abs(S) + 1. < std::abs(St))
      Sl = S;
    InS ? St = 2. * S : St = S;
 
    if (SN.second >= 0) {
 
      const double Sa = std::abs(SN.first);

      flips += last_surface == SN.second ? std::abs(last_St + SN.first) < 1.e-6
                                         : -flips;
      last_surface = SN.second;
 
 
      if (Sa > cache.m_straightStep) {
        if (std::abs(St) > Sa)
          St = SN.first;
      } else {
        Path = W + SN.first;
        if (auto To{ crossPoint(Tp, DS, Sol, Pn, SN) }; To){
          return To;
        }
        Nveto = SN.second;
        St = Sl;
      }
    } else if (std::abs(S) < DBL_EPSILON){
      return nullptr;
    }
 
    if (flips > max_back_forth_flips) {
      return nullptr;
    }
  }
  return nullptr;
}

propagate() [4/6]

bool Trk::RungeKuttaPropagator::propagate ( const EventContext & ctx, Trk::PatternTrackParameters & Ta, const Surface & Su, Trk::PatternTrackParameters & Tb, Trk::PropDirection D, const MagneticFieldProperties & M, double & S, ParticleHypothesis particle = pion ) const

finaloverridevirtual

Main propagation method with step to surface calculation.

Implements Trk::IPatternParametersPropagator.

Definition at line 1849 of file RungeKuttaPropagator.cxx.

{
  Cache cache = getInitializedCache(ctx);
  return propagateRungeKutta(cache, true, Ta, Su, Tb, D, M, S);
}

propagate() [5/6]

bool Trk::RungeKuttaPropagator::propagate ( const EventContext & ctx, Trk::PatternTrackParameters & Ta, const Surface & Su, Trk::PatternTrackParameters & Tb, Trk::PropDirection D, const MagneticFieldProperties & M, ParticleHypothesis particle = pion ) const

finaloverridevirtual

Main propagation method.

Implements Trk::IPatternParametersPropagator.

Definition at line 1831 of file RungeKuttaPropagator.cxx.

{
  double S = 0;
  Cache cache = getInitializedCache(ctx);
  return propagateRungeKutta(cache, true, Ta, Su, Tb, D, M, S);
}

propagate() [6/6]

std::unique_ptr< Trk::NeutralParameters > Trk::RungeKuttaPropagator::propagate ( const NeutralParameters & Tp, const Surface & Su, Trk::PropDirection D, const BoundaryCheck & B, bool returnCurv ) const

finaloverridevirtual

Main propagation method for NeutralParameters.

Implements Trk::IPropagator.

Definition at line 1402 of file RungeKuttaPropagator.cxx.

{
  double J[25];
  Cache cache{};
  cache.m_dlt = m_dlt;
  cache.m_helixStep = m_helixStep;
  cache.m_straightStep = m_straightStep;
  cache.m_usegradient = m_usegradient;
  return propagateStraightLine(cache, true, Tp, Su, D, B, J, returnCurv);
}

propagateM()

virtual std::unique_ptr< Trk::TrackParameters > Trk::RungeKuttaPropagator::propagateM ( const EventContext & , const TrackParameters & , std::vector< DestSurf > & , PropDirection , const MagneticFieldProperties & , ParticleHypothesis , std::vector< unsigned int > & , std::vector< const Trk::TrackStateOnSurface * > * , std::vector< std::pair< std::unique_ptr< Trk::TrackParameters >, int > > * , double & , bool , bool , const Trk::TrackingVolume * , Trk::ExtrapolationCache *  ) const

inlinefinaloverridevirtual

unimplemented propagateM

Implements Trk::IPropagator.

Definition at line 325 of file RungeKuttaPropagator.h.

  {
    ATH_MSG_ERROR("Call to non-implemented propagateM");
    return nullptr;
  }

propagateParameters() [1/4]

std::unique_ptr< Trk::TrackParameters > Trk::RungeKuttaPropagator::propagateParameters ( const EventContext & ctx, const TrackParameters & Tp, const Surface & Su, const PropDirection D, const BoundaryCheck & B, const MagneticFieldProperties & M, ParticleHypothesis , bool returnCurv, const TrackingVolume *  ) const

finaloverridevirtual

Main propagation method for parameters only.

Without transport jacobian production

Implements Trk::IPropagator.

Definition at line 1718 of file RungeKuttaPropagator.cxx.

{
  double J[25];
  Cache cache = getInitializedCache(ctx);
  return propagateRungeKutta(cache, false, Tp, Su, D, B, M, J, returnCurv);
}

propagateParameters() [2/4]

std::unique_ptr< Trk::TrackParameters > Trk::RungeKuttaPropagator::propagateParameters ( const EventContext & ctx, const TrackParameters & Tp, const Surface & Su, const PropDirection D, const BoundaryCheck & B, const MagneticFieldProperties & M, std::optional< TransportJacobian > & Jac, ParticleHypothesis , bool returnCurv, const TrackingVolume *  ) const

finaloverridevirtual

Main propagation method for parameters only with transport jacobian production.

Implements Trk::IPropagator.

Definition at line 1738 of file RungeKuttaPropagator.cxx.

{
  double J[25];
  Cache cache = getInitializedCache(ctx);
  auto Tpn{ propagateRungeKutta(cache, true, Tp, Su, D, B, M, J, returnCurv) };
 
  if (Tpn) {
    J[24] = J[20];
    J[23] = 0.;
    J[22] = 0.;
    J[21] = 0.;
    J[20] = 0.;
    Jac = std::make_optional<Trk::TransportJacobian>(J);
  } else
    Jac.reset();
  return Tpn;
}

propagateParameters() [3/4]

bool Trk::RungeKuttaPropagator::propagateParameters ( const EventContext & ctx, Trk::PatternTrackParameters & Ta, const Surface & Su, Trk::PatternTrackParameters & Tb, Trk::PropDirection D, const MagneticFieldProperties & M, double & S, ParticleHypothesis particle = pion ) const

finaloverridevirtual

Main propagation method for parameters only with step to surface calculation.

Implements Trk::IPatternParametersPropagator.

Definition at line 1885 of file RungeKuttaPropagator.cxx.

{
  Cache cache = getInitializedCache(ctx);
  return propagateRungeKutta(cache, false, Ta, Su, Tb, D, M, S);
}

propagateParameters() [4/4]

bool Trk::RungeKuttaPropagator::propagateParameters ( const EventContext & ctx, Trk::PatternTrackParameters & Ta, const Surface & Su, Trk::PatternTrackParameters & Tb, Trk::PropDirection D, const MagneticFieldProperties & M, ParticleHypothesis particle = pion ) const

finaloverridevirtual

Main propagation method for parameters only.

Implements Trk::IPatternParametersPropagator.

Definition at line 1867 of file RungeKuttaPropagator.cxx.

{
  double S = 0;
  Cache cache = getInitializedCache(ctx);
  return propagateRungeKutta(cache, false, Ta, Su, Tb, D, M, S);
}

propagateT()

virtual std::unique_ptr< Trk::TrackParameters > Trk::RungeKuttaPropagator::propagateT ( const EventContext & , const TrackParameters & , std::vector< DestSurf > & , PropDirection , const MagneticFieldProperties & , ParticleHypothesis , std::vector< unsigned int > & , PathLimit & , TimeLimit & , bool , const Trk::TrackingVolume * , std::vector< Trk::HitInfo > *&  ) const

inlinefinaloverridevirtual

unimplemented propagateT

Implements Trk::IPropagator.

Definition at line 306 of file RungeKuttaPropagator.h.

  {
    ATH_MSG_ERROR("Call to non-implemented propagateT");
    return nullptr;
  }

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, and AthCheckedComponent<::AthAlgTool >.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_dlt

DoubleProperty Trk::RungeKuttaPropagator::m_dlt {this, "AccuracyParameter", 0.0002}

private

Definition at line 394 of file RungeKuttaPropagator.h.

{this, "AccuracyParameter", 0.0002};

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_fieldCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> Trk::RungeKuttaPropagator::m_fieldCondObjInputKey

private

Initial value:

{
    this,
    "AtlasFieldCacheCondObj",
    "fieldCondObj",
    "Name of the Magnetic Field conditions object key"
  }

Definition at line 387 of file RungeKuttaPropagator.h.

                                                                    {
    this,
    "AtlasFieldCacheCondObj",
    "fieldCondObj",
    "Name of the Magnetic Field conditions object key"
  };

m_helixStep

DoubleProperty Trk::RungeKuttaPropagator::m_helixStep {this, "MaxHelixStep", 1.}

private

Definition at line 395 of file RungeKuttaPropagator.h.

{this, "MaxHelixStep", 1.};

m_straightStep

DoubleProperty Trk::RungeKuttaPropagator::m_straightStep {this, "MaxStraightLineStep", 0.01}

private

Definition at line 396 of file RungeKuttaPropagator.h.

{this, "MaxStraightLineStep", 0.01};

m_usegradient

BooleanProperty Trk::RungeKuttaPropagator::m_usegradient

private

Initial value:

{this, "IncludeBgradients", false,
    "use magnetic field gradient into the error propagation"}

Definition at line 397 of file RungeKuttaPropagator.h.

                               {this, "IncludeBgradients", false,
    "use magnetic field gradient into the error propagation"};

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

---

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

• RungeKuttaPropagator.h
• RungeKuttaPropagator.cxx