Trk::STEP_Propagator Class Reference

STEP (Simultaneous Track and Error Propagation ) is an algorithm for track parameters propagation through magnetic field. More...

#include <STEP_Propagator.h>

Inheritance diagram for Trk::STEP_Propagator:

Collaboration diagram for Trk::STEP_Propagator:

Classes
struct	Cache
	stuct to pass information to the heavy lifting calculation internal methods More...

Public Member Functions
	STEP_Propagator (const std::string &, const std::string &, const IInterface *)
virtual	~STEP_Propagator ()
virtual StatusCode	initialize () override final
	AlgTool initialize method.
virtual StatusCode	finalize () override final
	AlgTool finalize method.
virtual std::unique_ptr< Trk::NeutralParameters >	propagate (const Trk::NeutralParameters &, const Trk::Surface &, Trk::PropDirection, const Trk::BoundaryCheck &, bool rC=false) const override final
	Main propagation method NeutralParameters.
virtual std::unique_ptr< Trk::TrackParameters >	propagate (const EventContext &ctx, const Trk::TrackParameters &trackParameters, const Trk::Surface &targetSurface, Trk::PropDirection propagationDirection, const Trk::BoundaryCheck &boundaryCheck, const MagneticFieldProperties &magneticFieldProperties, ParticleHypothesis particle, bool returnCurv=false, const Trk::TrackingVolume *tVol=nullptr) const override final
	Propagate parameters and covariance without returning the Jacobian.
virtual std::unique_ptr< Trk::TrackParameters >	propagate (const EventContext &ctx, const Trk::TrackParameters &trackParameters, std::vector< Trk::DestSurf > &targetSurfaces, Trk::PropDirection propagationDirection, const MagneticFieldProperties &magneticFieldProperties, ParticleHypothesis particle, std::vector< unsigned int > &solutions, double &path, bool usePathLimit=false, bool returnCurv=false, const Trk::TrackingVolume *tVol=nullptr) const override final
	Propagate parameters and covariance with search of closest surface.
virtual std::unique_ptr< Trk::TrackParameters >	propagateT (const EventContext &ctx, const Trk::TrackParameters &trackParameters, std::vector< Trk::DestSurf > &targetSurfaces, Trk::PropDirection propagationDirection, const MagneticFieldProperties &magneticFieldProperties, ParticleHypothesis particle, std::vector< unsigned int > &solutions, Trk::PathLimit &path, Trk::TimeLimit &time, bool returnCurv, const Trk::TrackingVolume *tVol, std::vector< Trk::HitInfo > *&hitVector) const override final
	Propagate parameters and covariance with search of closest surface time included.
virtual std::unique_ptr< Trk::TrackParameters >	propagateM (const EventContext &ctx, const Trk::TrackParameters &trackParameters, std::vector< Trk::DestSurf > &targetSurfaces, Trk::PropDirection propagationDirection, const MagneticFieldProperties &magneticFieldProperties, ParticleHypothesis particle, std::vector< unsigned int > &solutions, std::vector< const Trk::TrackStateOnSurface * > *matstates, std::vector< std::pair< std::unique_ptr< Trk::TrackParameters >, int > > *intersections, double &path, bool usePathLimit=false, bool returnCurv=false, const Trk::TrackingVolume *tVol=nullptr, Trk::ExtrapolationCache *=nullptr) const override final
	Propagate parameters and covariance with search of closest surface and material collection.
virtual std::unique_ptr< Trk::TrackParameters >	propagate (const EventContext &ctx, const Trk::TrackParameters &trackParameters, const Trk::Surface &targetSurface, Trk::PropDirection propagationDirection, const Trk::BoundaryCheck &boundaryCheck, const MagneticFieldProperties &magneticFieldProperties, std::optional< Trk::TransportJacobian > &jacobian, double &pathLimit, ParticleHypothesis particle, bool returnCurv=false, const Trk::TrackingVolume *tVol=nullptr) const override final
	Propagate parameters and covariance, and return the Jacobian.
virtual std::unique_ptr< Trk::TrackParameters >	propagateParameters (const EventContext &ctx, const Trk::TrackParameters &trackParameters, const Trk::Surface &targetSurface, Trk::PropDirection propagationDirection, const Trk::BoundaryCheck &boundaryCheck, const MagneticFieldProperties &magneticFieldProperties, ParticleHypothesis particle, bool returnCurv=false, const Trk::TrackingVolume *tVol=nullptr) const override final
	Propagate parameters only.
virtual std::unique_ptr< Trk::TrackParameters >	propagateParameters (const EventContext &ctx, const Trk::TrackParameters &trackParameters, const Trk::Surface &targetSurface, Trk::PropDirection propagationDirection, const Trk::BoundaryCheck &boundaryCheck, const MagneticFieldProperties &magneticFieldProperties, std::optional< Trk::TransportJacobian > &jacobian, ParticleHypothesis particle, bool returnCurv=false, const Trk::TrackingVolume *tVol=nullptr) const override final
	Propagate parameters and return Jacobian.
virtual std::optional< TrackSurfaceIntersection >	intersect (const EventContext &ctx, const Trk::TrackParameters &trackParameters, const Trk::Surface &targetSurface, const Trk::MagneticFieldProperties &magneticFieldProperties, ParticleHypothesis particle, const Trk::TrackingVolume *tVol=nullptr) const override final
	Propagate parameters and return path (Similar to propagateParameters.
virtual std::optional< TrackSurfaceIntersection >	intersectSurface (const EventContext &ctx, const Surface &surface, const TrackSurfaceIntersection &trackIntersection, const double qOverP, const MagneticFieldProperties &mft, ParticleHypothesis particle) const override final
	Intersection and propagation:
virtual void	globalPositions (const EventContext &ctx, std::deque< Amg::Vector3D > &positionsList, const TrackParameters &trackParameters, const MagneticFieldProperties &magneticFieldProperties, const CylinderBounds &cylinderBounds, double maxStepSize, ParticleHypothesis particle, const Trk::TrackingVolume *tVol=0) const override final
	Return a list of positions along the track.
virtual Trk::MultiComponentState	multiStatePropagate (const EventContext &, const MultiComponentState &, const Surface &, const MagneticFieldProperties &, const PropDirection, const BoundaryCheck &, const ParticleHypothesis) const override final
	unimplemented multiStatePropagate
virtual std::unique_ptr< TrackParameters >	propagate (const EventContext &ctx, const TrackParameters &parm, const Surface &sf, PropDirection dir, const BoundaryCheck &bcheck, const MagneticFieldProperties &mprop, std::optional< TransportJacobian > &jacob, double &pathLength, ParticleHypothesis particle=pion, bool returnCurv=false, const TrackingVolume *tVol=nullptr) const=0
	Main propagation method with transport jacobian production.
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
virtual std::unique_ptr< TrackParameters >	propagateParameters (const EventContext &ctx, const TrackParameters &parm, const Surface &sf, PropDirection dir, const BoundaryCheck &bcheck, const MagneticFieldProperties &mprop, std::optional< TransportJacobian > &jacob, ParticleHypothesis particle=pion, bool returnCurv=false, const TrackingVolume *tVol=nullptr) const =0
	Main propagation method for parameters only with transport jacobian production.

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	AlgTool and IAlgTool interface methods.

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
void	setCacheFromProperties (Cache &cache) const
	initialize cache with the variables we need to take from
std::unique_ptr< Trk::TrackParameters >	propagateRungeKutta (Cache &cache, bool errorPropagation, const Trk::TrackParameters &trackParameters, std::vector< DestSurf > &targetSurfaces, Trk::PropDirection propagationDirection, const MagneticFieldProperties &magneticFieldProperties, ParticleHypothesis particle, std::vector< unsigned int > &solutions, double &path, bool returnCurv=false) const
bool	propagateWithJacobian (Cache &cache, bool errorPropagation, std::vector< DestSurf > &sfs, double *P, Trk::PropDirection propDir, std::vector< unsigned int > &solutions, double &path, double sumPath) const
void	dumpMaterialEffects (Cache &cache, const Trk::CurvilinearParameters *trackParameters, double path) const
void	smear (Cache &cache, double &phi, double &theta, const Trk::TrackParameters *parms, double radDist) const
void	sampleBrem (Cache &cache, double mom) const
void	getFieldCacheObject (Cache &cache, const EventContext &ctx) const
CLHEP::HepRandomEngine *	getRandomEngine (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
DoubleProperty	m_tolerance
BooleanProperty	m_materialEffects
BooleanProperty	m_includeBgradients
BooleanProperty	m_includeGgradient
DoubleProperty	m_momentumCutOff
BooleanProperty	m_multipleScattering
BooleanProperty	m_energyLoss {this, "EnergyLoss", true, "Include energy loss?"}
BooleanProperty	m_detailedEloss
BooleanProperty	m_straggling
BooleanProperty	m_MPV
DoubleProperty	m_stragglingScale
DoubleProperty	m_scatteringScale
DoubleProperty	m_maxPath
IntegerProperty	m_maxSteps
DoubleProperty	m_layXmax
BooleanProperty	m_simulation
ToolHandle< ITimedMatEffUpdator >	m_simMatUpdator {this, "SimMatEffUpdator", ""}
	secondary interactions (brem photon emission)
ServiceHandle< IAthRNGSvc >	m_rndGenSvc
	Random Generator service.
ATHRNG::RNGWrapper *	m_rngWrapper = nullptr
	Random engine.
StringProperty	m_randomEngineName
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
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

STEP (Simultaneous Track and Error Propagation ) is an algorithm for track parameters propagation through magnetic field.

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.

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

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.

The STEP_Propagator includes material effects in the equation of motion and applies corrections to the covariance matrices continuously during the parameter transport. It is designed for the propagation of a particle going through a dense block of material (e.g a muon transversing the calorimeter).

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 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 |

V Global->Local transformation

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

For propagation using Runge Kutta method we use global coordinate, direction, inverse momentum and Jacobian of transformation. All this parameters we save in 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 local presentation

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

in case global 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

The Runge-Kutta method:

The equations of motion are solved using an embedded pair of Runge-Kutta formulas. This method, Runge-Kutta-Fehlberg, calculates a number of points along the step and adds them up in different ways to get two different solutions, of different order, for the integration. The higher order solution is used for the propagation and the lower order solution for error control. The difference between these solutions is used to estimate the quality of the integration (propagation), and to calculate the step size for the next step. If the quality is below a given tolerance then the step is rejected and repeated with a shorter step length. This propagator uses the TP43 (Tsitouras-Papakostas 4th and 3rd order) Runge-Kutta pair.

The step size algoritm by L.P.Endresen and J.Myrheim was choosen for its low step rejection and effective step size calculation. The low step rejection is achieved by letting the step size oscillate around the optimal value instead of repeating steps every time they fall below the tolerance level.

Units are mm, MeV and kiloGauss.

Author

esben.nosp@m..lun.nosp@m.d@fys.nosp@m..uio.nosp@m..no

Definition at line 163 of file STEP_Propagator.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

STEP_Propagator()

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

Definition at line 1173 of file STEP_Propagator.cxx.

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

~STEP_Propagator()

Trk::STEP_Propagator::~STEP_Propagator ( )

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; }

dumpMaterialEffects()

void Trk::STEP_Propagator::dumpMaterialEffects ( Cache & cache, const Trk::CurvilinearParameters * trackParameters, double path ) const

private

Definition at line 2702 of file STEP_Propagator.cxx.

                                                                  {
 
  // kinematics
  double mom = parms->momentum().mag();
 
  // first update to make sure all material counted
  updateMaterialEffects(cache, mom, sin(parms->momentum().theta()), path);
 
  if (cache.m_extrapolationCache) {
    cache.m_extrapolationCache->updateX0(cache.m_combinedThickness);
    cache.m_extrapolationCache->updateEloss(
        cache.m_combinedEloss.meanIoni(), cache.m_combinedEloss.sigmaIoni(), cache.m_combinedEloss.meanRad(),
        cache.m_combinedEloss.sigmaRad());
  }
  // output
  if (cache.m_matstates) {
    auto eloss = !m_detailedEloss
                     ? std::make_unique<Trk::EnergyLoss>(cache.m_combinedEloss.deltaE(),
                                                         cache.m_combinedEloss.sigmaDeltaE())
                     : std::make_unique<Trk::EnergyLoss>(
                           cache.m_combinedEloss.deltaE(), cache.m_combinedEloss.sigmaDeltaE(),
                           cache.m_combinedEloss.sigmaDeltaE(), cache.m_combinedEloss.sigmaDeltaE(),
                           cache.m_combinedEloss.meanIoni(), cache.m_combinedEloss.sigmaIoni(),
                           cache.m_combinedEloss.meanRad(), cache.m_combinedEloss.sigmaRad(), path);
 
    auto sa = Trk::ScatteringAngles(0., 0., std::sqrt(cache.m_covariance(2, 2)),
                                    std::sqrt(cache.m_covariance(3, 3)));
 
    auto cvlTP = parms->uniqueClone();
    auto mefot = std::make_unique<Trk::MaterialEffectsOnTrack>(cache.m_combinedThickness, sa,
                                                               std::move(eloss), cvlTP->associatedSurface());
 
    cache.m_matstates->push_back(new TrackStateOnSurface(nullptr, std::move(cvlTP), std::move(mefot)));
  }
 
  cache.m_matdump_lastpath = path;
 
  // clean-up
  cache.m_combinedCovariance += cache.m_covariance;
  cache.m_covariance.setZero();
  cache.m_combinedThickness = 0.;
  cache.m_combinedEloss.set(0., 0., 0., 0., 0., 0.);
}

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

finalize()

StatusCode Trk::STEP_Propagator::finalize ( )

finaloverridevirtual

AlgTool finalize method.

Definition at line 1214 of file STEP_Propagator.cxx.

                                        {
  return StatusCode::SUCCESS;
}

getFieldCacheObject()

void Trk::STEP_Propagator::getFieldCacheObject ( Cache & cache, const EventContext & ctx ) const

private

Definition at line 2800 of file STEP_Propagator.cxx.

                                                                                        {
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
  if (fieldCondObj == nullptr) {
    ATH_MSG_ERROR("extrapolate: Failed to retrieve AtlasFieldCacheCondObj with key "
                  << m_fieldCacheCondObjInputKey.key());
    return;
  }
  fieldCondObj->getInitializedCache(cache.m_fieldCache);
}

getRandomEngine()

CLHEP::HepRandomEngine * Trk::STEP_Propagator::getRandomEngine ( const EventContext & ctx ) const

private

Definition at line 2812 of file STEP_Propagator.cxx.

{
  if (!m_simulation || !m_rngWrapper) {
    return nullptr;
  }
  if (m_rngWrapper->evtSeeded(ctx) != ctx.evt()) {
    // Ok, the wrappers are unique to this algorithm and a given slot,
    // so cannot be accessed concurrently.
    ATHRNG::RNGWrapper* wrapper_nc ATLAS_THREAD_SAFE = m_rngWrapper;
    wrapper_nc->setSeed (this->name(), ctx);
  }
  return m_rngWrapper->getEngine (ctx);
}

globalPositions()

void Trk::STEP_Propagator::globalPositions ( const EventContext & ctx, std::deque< Amg::Vector3D > & positionsList, const TrackParameters & trackParameters, const MagneticFieldProperties & magneticFieldProperties, const CylinderBounds & cylinderBounds, double maxStepSize, ParticleHypothesis particle, const Trk::TrackingVolume * tVol = 0 ) const

finaloverridevirtual

Return a list of positions along the track.

Implements Trk::IPropagator.

Definition at line 1774 of file STEP_Propagator.cxx.

                                                                                {
  Cache cache(ctx);
 
  // Get field cache object
  getFieldCacheObject(cache, ctx);
  setCacheFromProperties(cache);
  clearMaterialEffects(cache);
 
  cache.m_particle = particle;  // Store for later use
 
  // Check for tracking volume (materialproperties)
  cache.m_trackingVolume = tVol;
  cache.m_material = tVol;
  cache.m_matPropOK = tVol != nullptr;
 
  // Check for empty volumes. If x != x then x is not a number.
  if (cache.m_matPropOK && ((cache.m_material->zOverAtimesRho() == 0.) || (cache.m_material->x0() == 0.) ||
                            (cache.m_material->zOverAtimesRho() != cache.m_material->zOverAtimesRho()))) {
    cache.m_matPropOK = false;
  }
 
  mft.magneticFieldMode() == Trk::FastField ? cache.m_solenoid = true : cache.m_solenoid = false;
 
  // Check inputvalues
  if (cache.m_tolerance <= 0.)
    return;
 
  double PP[7];
  if (!Trk::RungeKuttaUtils::transformLocalToGlobal(false, trackParameters, PP))
    return;
 
  double maxPath = cache.m_maxPath;  // Max path allowed
  double dDir[3] = {0., 0., 0.};     // Start directions derivs. Zero in case of no RK steps
  double distanceStepped = 0.;
  double BG1[12] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};  // Bx, By, Bz, dBx/dx, dBx/dy, dBx/dz,
  // dBy/dx, dBy/dy, dBy/dz, dBz/dx, dBz/dy, dBz/dz
  bool firstStep = true;                                        // Poll B1, else recycle B4
  double path = 0.;                                             // path of the trajectory
  double radius2Max = cylinderBounds.r() * cylinderBounds.r();  // max. radius**2 of region
  double zMax = cylinderBounds.halflengthZ();                   // max. Z of region
  double radius2 = PP[0] * PP[0] + PP[1] * PP[1];               // Start radius**2
  double direction = PP[0] * PP[3] + PP[1] * PP[4];             // Direction
  double h = maxStepSize;                                       // max step allowed
 
  // Test position of the track
  if ((std::abs(PP[2]) > zMax) || (radius2 > radius2Max))
    return;
 
  // Store initial position
  Amg::Vector3D initialPosition(PP[0], PP[1], PP[2]);
  positionsList.push_back(initialPosition);
 
  bool perigee = false;
  if (std::abs(direction) < 0.00001) {
    perigee = true;
  }
 
  for (int i = 0; i != 2; ++i) {
    if (i) {
      if (perigee)
        return;
      h = -h;
    }
    double p[7] = {PP[0], PP[1], PP[2], PP[3], PP[4], PP[5], PP[6]};
 
    while (std::abs(path) < maxPath) {
      // Do the step.
      if (!rungeKuttaStep(cache, false, h, p, dDir, BG1, firstStep, distanceStepped))
        break;
      path = path + distanceStepped;
 
      // Keep h within max stepsize
      if (h > maxStepSize) {
        h = maxStepSize;
      } else if (h < -maxStepSize) {
        h = -maxStepSize;
      }
 
      // store current step
      Amg::Vector3D globalPosition(p[0], p[1], p[2]);
      if (!i) {
        positionsList.push_back(globalPosition);
      } else {
        positionsList.push_front(globalPosition);
      }
 
      // Test position of the track
      radius2 = p[0] * p[0] + p[1] * p[1];
      if ((std::abs(p[2]) > zMax) || (radius2 > radius2Max))
        break;
 
      // Test perigee
      if ((p[0] * p[3] + p[1] * p[4]) * direction < 0.) {
        if (i)
          return;
        perigee = true;
      }
    }
  }
}

initialize()

StatusCode Trk::STEP_Propagator::initialize ( )

finaloverridevirtual

AlgTool initialize method.

Definition at line 1187 of file STEP_Propagator.cxx.

                                          {
 
  // Read handle for AtlasFieldCacheCondObj
  ATH_CHECK(m_fieldCacheCondObjInputKey.initialize());
 
  if (!m_materialEffects) {  // override all material interactions
    m_multipleScattering = false;
    m_energyLoss = false;
    m_straggling = false;
  } else if (!m_energyLoss) {  // override straggling
    m_straggling = false;
  }
 
  if (m_simulation && m_simMatUpdator.retrieve().isFailure()) {
    ATH_MSG_WARNING("Simulation mode requested but material updator not found - no brem photon emission.");
  }
 
  if (m_simulation) {
    // get the random generator serice
    ATH_CHECK(m_rndGenSvc.retrieve());
    m_rngWrapper = m_rndGenSvc->getEngine(this, m_randomEngineName);
  }
 
  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()

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

inlinestaticinherited

AlgTool and IAlgTool interface methods.

Definition at line 61 of file IPropagator.h.

{ return IID_IPropagator; }

intersect()

std::optional< Trk::TrackSurfaceIntersection > Trk::STEP_Propagator::intersect ( const EventContext & ctx, const Trk::TrackParameters & trackParameters, const Trk::Surface & targetSurface, const Trk::MagneticFieldProperties & magneticFieldProperties, ParticleHypothesis particle, const Trk::TrackingVolume * tVol = nullptr ) const

finaloverridevirtual

Propagate parameters and return path (Similar to propagateParameters.

Implements Trk::IPropagator.

Definition at line 1606 of file STEP_Propagator.cxx.

                                       {
 
  Cache cache(ctx);
 
  // Get field cache object
  getFieldCacheObject(cache, ctx);
  setCacheFromProperties(cache);
  clearMaterialEffects(cache);
 
  cache.m_particle = particle;  // Store for later use
 
  // Check for tracking volume (materialproperties)
  cache.m_trackingVolume = tVol;
  cache.m_material = tVol;
  cache.m_matPropOK = tVol != nullptr;
 
  // no identified intersections needed/ no material dump
  cache.m_identifiedParameters = nullptr;
  cache.m_matstates = nullptr;
  cache.m_extrapolationCache = nullptr;
  cache.m_hitVector = nullptr;
 
  // Bfield mode
  mft.magneticFieldMode() == Trk::FastField ? cache.m_solenoid = true : cache.m_solenoid = false;
 
  // Check inputvalues
  if (cache.m_tolerance <= 0.) {
    return std::nullopt;
  }
  if (cache.m_momentumCutOff < 0.) {
    return std::nullopt;
  }
  if (std::abs(1. / trackParameters.parameters()[Trk::qOverP]) <= cache.m_momentumCutOff) {
    return std::nullopt;
  }
 
  // Check for empty volumes. If x != x then x is not a number.
  if (cache.m_matPropOK && ((cache.m_material->zOverAtimesRho() == 0.) || (cache.m_material->x0() == 0.) ||
                            (cache.m_material->zOverAtimesRho() != cache.m_material->zOverAtimesRho()))) {
    cache.m_matPropOK = false;
  }
 
  // double P[45];
  if (!Trk::RungeKuttaUtils::transformLocalToGlobal(false, trackParameters, cache.m_P)) {
      return std::nullopt;
  }
  double path = 0.;
 
  const Amg::Transform3D& T = targetSurface.transform();
  Trk::SurfaceType ty = targetSurface.type();
 
  if (ty == Trk::SurfaceType::Plane || ty == Trk::SurfaceType::Disc) {
    double s[4];
    double d = T(0, 3) * T(0, 2) + T(1, 3) * T(1, 2) + T(2, 3) * T(2, 2);
 
    if (d >= 0.) {
      s[0] = T(0, 2);
      s[1] = T(1, 2);
      s[2] = T(2, 2);
      s[3] = d;
    } else {
      s[0] = -T(0, 2);
      s[1] = -T(1, 2);
      s[2] = -T(2, 2);
      s[3] = -d;
    }
    if (!propagateWithJacobianImpl(cache, false, ty, s, cache.m_P, path)){
      return std::nullopt;
    }
  }
 
  else if (ty == Trk::SurfaceType::Line) {
 
    double s[6] = {T(0, 3), T(1, 3), T(2, 3), T(0, 2), T(1, 2), T(2, 2)};
    if (!propagateWithJacobianImpl(cache, false, ty, s, cache.m_P, path)) {
      return std::nullopt;
    }
  }
 
  else if (ty == Trk::SurfaceType::Cylinder) {
 
    const Trk::CylinderSurface* cyl = static_cast<const Trk::CylinderSurface*>(&targetSurface);
    double s[9] = {
        T(0, 3), T(1, 3), T(2, 3), T(0, 2), T(1, 2), T(2, 2), cyl->bounds().r(), Trk::alongMomentum, 0.};
    if (!propagateWithJacobianImpl(cache, false, ty, s, cache.m_P, path)) {
      return std::nullopt;
    }
  }
 
  else if (ty == Trk::SurfaceType::Cone) {
 
    double k = static_cast<const Trk::ConeSurface*>(&targetSurface)->bounds().tanAlpha();
    k = k * k + 1.;
    double s[9] = {T(0, 3), T(1, 3), T(2, 3), T(0, 2), T(1, 2), T(2, 2), k, Trk::alongMomentum, 0.};
    if (!propagateWithJacobianImpl(cache, false, ty, s, cache.m_P, path)) {
      return std::nullopt;
    }
  }
 
  else if (ty == Trk::SurfaceType::Perigee) {
 
    double s[6] = {T(0, 3), T(1, 3), T(2, 3), 0., 0., 1.};
    if (!propagateWithJacobianImpl(cache, false, ty, s, cache.m_P, path)) {
      return std::nullopt;
    }
  }
 
  else {  // presumably curvilinear
 
    double s[4];
    double d = T(0, 3) * T(0, 2) + T(1, 3) * T(1, 2) + T(2, 3) * T(2, 2);
 
    if (d >= 0.) {
      s[0] = T(0, 2);
      s[1] = T(1, 2);
      s[2] = T(2, 2);
      s[3] = d;
    } else {
      s[0] = -T(0, 2);
      s[1] = -T(1, 2);
      s[2] = -T(2, 2);
      s[3] = -d;
    }
    if (!propagateWithJacobianImpl(cache, false, ty, s, cache.m_P, path)) {
      return std::nullopt;
    }
  }
 
  Amg::Vector3D globalPosition(cache.m_P[0], cache.m_P[1], cache.m_P[2]);
  Amg::Vector3D direction(cache.m_P[3], cache.m_P[4], cache.m_P[5]);
  return std::make_optional<Trk::TrackSurfaceIntersection>(globalPosition, direction, path);
}

intersectSurface()

std::optional< Trk::TrackSurfaceIntersection > Trk::STEP_Propagator::intersectSurface ( const EventContext & ctx, const Surface & surface, const TrackSurfaceIntersection & trackIntersection, const double qOverP, const MagneticFieldProperties & mft, ParticleHypothesis particle ) const

finaloverridevirtual

Intersection and propagation:

Implements Trk::IPropagator.

Definition at line 1746 of file STEP_Propagator.cxx.

                                       {
 
  const Amg::Vector3D& origin = trackIntersection.position();
  const Amg::Vector3D& direction = trackIntersection.direction();
 
  auto perigeeSurface = PerigeeSurface(origin);
  perigeeSurface.setOwner(Trk::userOwn);  // tmp ones
 
  auto tmpTrackParameters =
      Trk::Perigee(0., 0., direction.phi(), direction.theta(), qOverP, perigeeSurface, std::nullopt);
 
  std::optional<Trk::TrackSurfaceIntersection> solution =
      qOverP == 0
          ? intersect(ctx, tmpTrackParameters, surface,
                      Trk::MagneticFieldProperties(Trk::NoField), particle)
          : intersect(ctx, tmpTrackParameters, surface, mft, particle, nullptr);
 
  return solution;
}

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

virtual Trk::MultiComponentState Trk::STEP_Propagator::multiStatePropagate ( const EventContext & , const MultiComponentState & , const Surface & , const MagneticFieldProperties & , const PropDirection , const BoundaryCheck & , const ParticleHypothesis  ) const

inlinefinaloverridevirtual

unimplemented multiStatePropagate

Implements Trk::IPropagator.

Definition at line 325 of file STEP_Propagator.h.

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

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/5]

virtual std::unique_ptr< TrackParameters > Trk::IPropagator::propagate ( const EventContext & ctx, const TrackParameters & parm, const Surface & sf, PropDirection dir, const BoundaryCheck & bcheck, const MagneticFieldProperties & mprop, std::optional< TransportJacobian > & jacob, double & pathLength, ParticleHypothesis particle = pion, bool returnCurv = false, const TrackingVolume * tVol = nullptr ) const

virtual

Main propagation method with transport jacobian production.

Implements Trk::IPropagator.

propagate() [2/5]

std::unique_ptr< Trk::TrackParameters > Trk::STEP_Propagator::propagate ( const EventContext & ctx, const Trk::TrackParameters & trackParameters, const Trk::Surface & targetSurface, Trk::PropDirection propagationDirection, const Trk::BoundaryCheck & boundaryCheck, const MagneticFieldProperties & magneticFieldProperties, ParticleHypothesis particle, bool returnCurv = false, const Trk::TrackingVolume * tVol = nullptr ) const

finaloverridevirtual

Propagate parameters and covariance without returning the Jacobian.

Implements Trk::IPropagator.

Definition at line 1232 of file STEP_Propagator.cxx.

                                         {
 
  // ATH_MSG_WARNING( "[STEP_Propagator] enter 1");
 
  double Jacobian[25];
  Cache cache(ctx);
 
  // Get field cache object
  getFieldCacheObject(cache, ctx);
  setCacheFromProperties(cache);
  clearMaterialEffects(cache);
 
  // Check for tracking volume (materialproperties)
  cache.m_trackingVolume = tVol;
  cache.m_material = tVol;
  cache.m_matPropOK = tVol != nullptr;
 
  cache.m_matupd_lastmom = trackParameters.momentum().mag();
  cache.m_matupd_lastpath = 0.;
  cache.m_matdump_lastpath = 0.;
 
  // no identified intersections needed/ no material dump / no path cache
  cache.m_identifiedParameters = nullptr;
  cache.m_matstates = nullptr;
  cache.m_extrapolationCache = nullptr;
  cache.m_hitVector = nullptr;
 
  return propagateRungeKuttaImpl(cache, true, trackParameters, targetSurface, propagationDirection,
                                 magneticFieldProperties, particle, boundaryCheck, Jacobian, returnCurv);
}

propagate() [3/5]

std::unique_ptr< Trk::TrackParameters > Trk::STEP_Propagator::propagate ( const EventContext & ctx, const Trk::TrackParameters & trackParameters, const Trk::Surface & targetSurface, Trk::PropDirection propagationDirection, const Trk::BoundaryCheck & boundaryCheck, const MagneticFieldProperties & magneticFieldProperties, std::optional< Trk::TransportJacobian > & jacobian, double & pathLimit, ParticleHypothesis particle, bool returnCurv = false, const Trk::TrackingVolume * tVol = nullptr ) const

finaloverridevirtual

Propagate parameters and covariance, and return the Jacobian.

WARNING: Multiple Scattering is not included in the Jacobian!

Definition at line 1464 of file STEP_Propagator.cxx.

                                         {
 
  double Jacobian[25];
  Cache cache(ctx);
 
  // Get field cache object
  getFieldCacheObject(cache, ctx);
  setCacheFromProperties(cache);
  clearMaterialEffects(cache);
 
  // Check for tracking volume (materialproperties)
  cache.m_trackingVolume = tVol;
  cache.m_material = tVol;
  cache.m_matPropOK = tVol != nullptr;
 
  // no identified intersections needed/ no material dump
  cache.m_identifiedParameters = nullptr;
  cache.m_matstates = nullptr;
  cache.m_extrapolationCache = nullptr;
  cache.m_hitVector = nullptr;
 
  cache.m_matupd_lastmom = trackParameters.momentum().mag();
  cache.m_matupd_lastpath = 0.;
  cache.m_matdump_lastpath = 0.;
 
  std::unique_ptr<Trk::TrackParameters> parameters =
      propagateRungeKuttaImpl(cache, true, trackParameters, targetSurface, propagationDirection,
                              magneticFieldProperties, particle, boundaryCheck, Jacobian, returnCurv);
 
  if (parameters) {
    Jacobian[24] = Jacobian[20];
    Jacobian[23] = 0.;
    Jacobian[22] = 0.;
    Jacobian[21] = 0.;
    Jacobian[20] = 0.;
    jacobian = std::make_optional<Trk::TransportJacobian>(Jacobian);
  } else {
    jacobian.reset();
  }
 
  return parameters;
}

propagate() [4/5]

std::unique_ptr< Trk::TrackParameters > Trk::STEP_Propagator::propagate ( const EventContext & ctx, const Trk::TrackParameters & trackParameters, std::vector< Trk::DestSurf > & targetSurfaces, Trk::PropDirection propagationDirection, const MagneticFieldProperties & magneticFieldProperties, ParticleHypothesis particle, std::vector< unsigned int > & solutions, double & path, bool usePathLimit = false, bool returnCurv = false, const Trk::TrackingVolume * tVol = nullptr ) const

finaloverridevirtual

Propagate parameters and covariance with search of closest surface.

Implements Trk::IPropagator.

Definition at line 1271 of file STEP_Propagator.cxx.

                                         {
 
  Cache cache(ctx);
 
  // Get field cache object
  getFieldCacheObject(cache, ctx);
  setCacheFromProperties(cache);
  clearMaterialEffects(cache);
 
  // Check for tracking volume (materialproperties)
  cache.m_trackingVolume = tVol;
  cache.m_material = tVol;
  cache.m_matPropOK = tVol != nullptr;
 
  // no identified intersections needed/ no material dump
  cache.m_identifiedParameters = nullptr;
  cache.m_matstates = nullptr;
  cache.m_extrapolationCache = nullptr;
  cache.m_hitVector = nullptr;
 
  cache.m_matupd_lastmom = trackParameters.momentum().mag();
  cache.m_matupd_lastpath = 0.;
  cache.m_matdump_lastpath = 0.;
 
  // resolve path limit input
  if (path > 0.) {
    cache.m_propagateWithPathLimit = usePathLimit ? 1 : 0;
    cache.m_pathLimit = path;
    path = 0.;
  } else {
    cache.m_propagateWithPathLimit = 0;
    cache.m_pathLimit = -1.;
    path = 0.;
  }
  if (particle == Trk::neutron || particle == Trk::photon || particle == Trk::pi0 || particle == Trk::k0)
    return propagateNeutral(trackParameters, targetSurfaces, propagationDirection, solutions, path,
                            usePathLimit, returnCurv);
 
  return propagateRungeKutta(cache, true, trackParameters, targetSurfaces, propagationDirection,
                             magneticFieldProperties, particle, solutions, path, returnCurv);
}

propagate() [5/5]

std::unique_ptr< Trk::NeutralParameters > Trk::STEP_Propagator::propagate ( const Trk::NeutralParameters & , const Trk::Surface & , Trk::PropDirection , const Trk::BoundaryCheck & , bool rC = false ) const

finaloverridevirtual

Main propagation method NeutralParameters.

It is not implemented for STEP propagator.

Use StraightLinePropagator for neutrals

Implements Trk::IPropagator.

Definition at line 1219 of file STEP_Propagator.cxx.

                                                                                    {
  ATH_MSG_WARNING("[STEP_Propagator] STEP_Propagator does not handle neutral track parameters."
                  << "Use the StraightLinePropagator instead.");
  return nullptr;
}

propagateM()

std::unique_ptr< Trk::TrackParameters > Trk::STEP_Propagator::propagateM ( const EventContext & ctx, const Trk::TrackParameters & trackParameters, std::vector< Trk::DestSurf > & targetSurfaces, Trk::PropDirection propagationDirection, const MagneticFieldProperties & magneticFieldProperties, ParticleHypothesis particle, std::vector< unsigned int > & solutions, std::vector< const Trk::TrackStateOnSurface * > * matstates, std::vector< std::pair< std::unique_ptr< Trk::TrackParameters >, int > > * intersections, double & path, bool usePathLimit = false, bool returnCurv = false, const Trk::TrackingVolume * tVol = nullptr, Trk::ExtrapolationCache * extrapCache = nullptr ) const

finaloverridevirtual

Propagate parameters and covariance with search of closest surface and material collection.

Implements Trk::IPropagator.

Definition at line 1408 of file STEP_Propagator.cxx.

                                              {
 
  Cache cache(ctx);
 
  // Get field cache object
  getFieldCacheObject(cache, ctx);
  setCacheFromProperties(cache);
  clearMaterialEffects(cache);
 
  // Check for tracking volume (materialproperties)
  cache.m_trackingVolume = tVol;
  cache.m_material = tVol;
  cache.m_matPropOK = tVol != nullptr;
 
  cache.m_matstates = matstates;
  cache.m_identifiedParameters = intersections;
  cache.m_extrapolationCache = extrapCache;
  cache.m_hitVector = nullptr;
 
  cache.m_matupd_lastmom = trackParameters.momentum().mag();
  cache.m_matupd_lastpath = 0.;
  cache.m_matdump_lastpath = 0.;
  cache.m_extrapolationCache = extrapCache;
 
  // switch on the detailed energy loss
  if (cache.m_extrapolationCache) {
    cache.m_detailedElossFlag = true;
  }
  // resolve path limit input
  if (path > 0.) {
    cache.m_propagateWithPathLimit = usePathLimit ? 1 : 0;
    cache.m_pathLimit = path;
    path = 0.;
  } else {
    cache.m_propagateWithPathLimit = 0;
    cache.m_pathLimit = -1.;
    path = 0.;
  }
  if (particle == Trk::neutron || particle == Trk::photon || particle == Trk::pi0 || particle == Trk::k0) {
    return propagateNeutral(trackParameters, targetSurfaces, propagationDirection, solutions, path,
                            usePathLimit, returnCurv);
  }
  return propagateRungeKutta(cache, true, trackParameters, targetSurfaces, propagationDirection,
                             magneticFieldProperties, particle, solutions, path, returnCurv);
}

propagateParameters() [1/3]

virtual std::unique_ptr< TrackParameters > Trk::IPropagator::propagateParameters ( const EventContext & ctx, const TrackParameters & parm, const Surface & sf, PropDirection dir, const BoundaryCheck & bcheck, const MagneticFieldProperties & mprop, std::optional< TransportJacobian > & jacob, ParticleHypothesis particle = pion, bool returnCurv = false, const TrackingVolume * tVol = nullptr ) const

pure virtualinherited

Main propagation method for parameters only with transport jacobian production.

Implemented in Trk::IntersectorWrapper, and Trk::RungeKuttaPropagator.

propagateParameters() [2/3]

std::unique_ptr< Trk::TrackParameters > Trk::STEP_Propagator::propagateParameters ( const EventContext & ctx, const Trk::TrackParameters & trackParameters, const Trk::Surface & targetSurface, Trk::PropDirection propagationDirection, const Trk::BoundaryCheck & boundaryCheck, const MagneticFieldProperties & magneticFieldProperties, ParticleHypothesis particle, bool returnCurv = false, const Trk::TrackingVolume * tVol = nullptr ) const

finaloverridevirtual

Propagate parameters only.

Implements Trk::IPropagator.

Definition at line 1522 of file STEP_Propagator.cxx.

                                         {
 
  double Jacobian[25];
  Cache cache(ctx);
 
  // Get field cache object
  getFieldCacheObject(cache, ctx);
  setCacheFromProperties(cache);
  clearMaterialEffects(cache);
 
  // Check for tracking volume (materialproperties)
  cache.m_trackingVolume = tVol;
  cache.m_material = tVol;
  cache.m_matPropOK = tVol != nullptr;
 
  // no identified intersections needed/ no material dump
  cache.m_identifiedParameters = nullptr;
  cache.m_matstates = nullptr;
  cache.m_hitVector = nullptr;
 
  return propagateRungeKuttaImpl(cache, false, trackParameters, targetSurface, propagationDirection,
                                 magneticFieldProperties, particle, boundaryCheck, Jacobian, returnCurv);
}

propagateParameters() [3/3]

std::unique_ptr< Trk::TrackParameters > Trk::STEP_Propagator::propagateParameters ( const EventContext & ctx, const Trk::TrackParameters & trackParameters, const Trk::Surface & targetSurface, Trk::PropDirection propagationDirection, const Trk::BoundaryCheck & boundaryCheck, const MagneticFieldProperties & magneticFieldProperties, std::optional< Trk::TransportJacobian > & jacobian, ParticleHypothesis particle, bool returnCurv = false, const Trk::TrackingVolume * tVol = nullptr ) const

finaloverridevirtual

Propagate parameters and return Jacobian.

WARNING: Multiple Scattering is not included in the Jacobian!

Definition at line 1553 of file STEP_Propagator.cxx.

                                         {
 
  double Jacobian[25];
 
  Cache cache(ctx);
 
  // Get field cache object
  getFieldCacheObject(cache, ctx);
  setCacheFromProperties(cache);
  clearMaterialEffects(cache);
 
  // Check for tracking volume (materialproperties)
  cache.m_trackingVolume = tVol;
  cache.m_material = tVol;
  cache.m_matPropOK = tVol != nullptr;
 
  // no identified intersections needed/ no material dump
  cache.m_identifiedParameters = nullptr;
  cache.m_matstates = nullptr;
  cache.m_extrapolationCache = nullptr;
  cache.m_hitVector = nullptr;
 
  std::unique_ptr<Trk::TrackParameters> parameters =
      propagateRungeKuttaImpl(cache, true, trackParameters, targetSurface, propagationDirection,
                              magneticFieldProperties, particle, boundaryCheck, Jacobian, returnCurv);
 
  if (parameters) {
    Jacobian[24] = Jacobian[20];
    Jacobian[23] = 0.;
    Jacobian[22] = 0.;
    Jacobian[21] = 0.;
    Jacobian[20] = 0.;
    jacobian = std::make_optional<Trk::TransportJacobian>(Jacobian);
  } else {
    jacobian.reset();
  }
 
  return parameters;
}

propagateRungeKutta()

std::unique_ptr< Trk::TrackParameters > Trk::STEP_Propagator::propagateRungeKutta ( Cache & cache, bool errorPropagation, const Trk::TrackParameters & trackParameters, std::vector< DestSurf > & targetSurfaces, Trk::PropDirection propagationDirection, const MagneticFieldProperties & magneticFieldProperties, ParticleHypothesis particle, std::vector< unsigned int > & solutions, double & path, bool returnCurv = false ) const

private

Check first that the jacobian does not have crazy entries

Definition at line 1884 of file STEP_Propagator.cxx.

                                                                                  {
  // Store for later use
  cache.m_particle = particle;
  cache.m_charge = inputTrackParameters.charge();
  cache.m_inputThetaVariance = 0.;
 
  std::unique_ptr<Trk::TrackParameters> trackParameters{};
 
  // Bfield mode
  mft.magneticFieldMode() == Trk::FastField ? cache.m_solenoid = true : cache.m_solenoid = false;
 
  // Check inputvalues
  if (cache.m_tolerance <= 0.)
    return nullptr;
  if (cache.m_momentumCutOff < 0.)
    return nullptr;
 
  // Set momentum to 1e10 (straight line) and charge to + if q/p is zero
  if (inputTrackParameters.parameters()[Trk::qOverP] == 0) {
    trackParameters = createStraightLine(&inputTrackParameters);
    if (!trackParameters) {
      return nullptr;
    }
  } else {
    trackParameters.reset(inputTrackParameters.clone());
  }
 
  if (std::abs(1. / trackParameters->parameters()[Trk::qOverP]) <= cache.m_momentumCutOff) {
    return nullptr;
  }
 
  // Check for empty volumes. If x != x then x is not a number.
  if (cache.m_matPropOK && ((cache.m_material->zOverAtimesRho() == 0.) || (cache.m_material->x0() == 0.) ||
                            (cache.m_material->zOverAtimesRho() != cache.m_material->zOverAtimesRho()))) {
    cache.m_matPropOK = false;
  }
 
  if (errorPropagation && !trackParameters->covariance()) {
    errorPropagation = false;
  }
 
  if (cache.m_matPropOK && errorPropagation && cache.m_straggling)
    cache.m_stragglingVariance = 0.;
  cache.m_combinedCovariance.setZero();
  cache.m_covariance.setZero();
 
  if (errorPropagation || cache.m_matstates) {
    // this needs debugging
    cache.m_inputThetaVariance = trackParameters->covariance() ? (*trackParameters->covariance())(3, 3) : 0.;
    cache.m_combinedEloss.set(0., 0., 0., 0., 0., 0.);
    cache.m_combinedThickness = 0.;
  }
 
  // double P[45]; // Track parameters and jacobian
  if (!Trk::RungeKuttaUtils::transformLocalToGlobal(errorPropagation, *trackParameters, cache.m_P)) {
    return nullptr;
  }
 
  double path = 0.;
 
  // activate brem photon emission if required
  cache.m_brem = m_simulation && particle == Trk::electron && m_simMatUpdator;
 
  // loop while valid solutions
  bool validStep = true;
  totalPath = 0.;
  cache.m_timeOfFlight = 0.;
  // Common transformation for all surfaces (angles and momentum)
  double localp[5];
  double Jacobian[21];
  while (validStep) {
    // propagation to next surface
    validStep = propagateWithJacobian(cache, errorPropagation, targetSurfaces, cache.m_P,
                                      propagationDirection, solutions, path, totalPath);
    if (!validStep) {
      return nullptr;
    }
    if (propagationDirection * path <= 0.) {
      return nullptr;
    }
    totalPath += path;
    cache.m_timeOfFlight += cache.m_timeStep;
    if (cache.m_propagateWithPathLimit > 1 || cache.m_binMat) {
      // make sure that for sliding surfaces the result does not get distorted
      // return curvilinear parameters
      std::unique_ptr<Trk::CurvilinearParameters> cPar = nullptr;
      Trk::RungeKuttaUtils::transformGlobalToLocal(cache.m_P, localp);
      if (!errorPropagation) {
        cPar = std::make_unique<Trk::CurvilinearParameters>(
            Amg::Vector3D(cache.m_P[0], cache.m_P[1], cache.m_P[2]), localp[2], localp[3], localp[4]);
      } else {
        double useless[2];
        Trk::RungeKuttaUtils::transformGlobalToCurvilinear(true, cache.m_P, useless, Jacobian);
        AmgSymMatrix(5) measurementCovariance =
            Trk::RungeKuttaUtils::newCovarianceMatrix(Jacobian, *trackParameters->covariance());
        // Calculate multiple scattering and straggling covariance contribution.
        if (cache.m_matPropOK && (cache.m_multipleScattering || cache.m_straggling) &&
            std::abs(totalPath) > 0.) {
          covarianceContribution(cache, trackParameters.get(), totalPath, std::abs(1. / cache.m_P[6]),
                                 measurementCovariance);
        }
        cPar = std::make_unique<Trk::CurvilinearParameters>(
            Amg::Vector3D(cache.m_P[0], cache.m_P[1], cache.m_P[2]), localp[2], localp[3], localp[4],
            std::move(measurementCovariance));
      }
      // material collection : first iteration, bin material averaged
      // collect material
      if (cache.m_binMat && (cache.m_matstates || (errorPropagation && cache.m_extrapolationCache)) &&
          std::abs(totalPath - cache.m_matdump_lastpath) > 1.) {
        dumpMaterialEffects(cache, cPar.get(), totalPath);
      }
      return cPar;
    }
    if (cache.m_propagateWithPathLimit > 0)
      cache.m_pathLimit -= path;
    // boundary check
    // take into account that there may be many identical surfaces with different boundaries
    Amg::Vector3D gp(cache.m_P[0], cache.m_P[1], cache.m_P[2]);
    bool solution = false;
    std::vector<unsigned int> valid_solutions;
    valid_solutions.reserve(solutions.size());
 
    std::vector<unsigned int>::iterator iSol = solutions.begin();
    while (iSol != solutions.end()) {
      if (targetSurfaces[*iSol].first->isOnSurface(gp, targetSurfaces[*iSol].second, 0.001, 0.001)) {
        if (!solution) {
          Trk::RungeKuttaUtils::transformGlobalToLocal(cache.m_P, localp);
          if (returnCurv || targetSurfaces[*iSol].first->type() == Trk::SurfaceType::Cone) {
            Trk::RungeKuttaUtils::transformGlobalToCurvilinear(errorPropagation, cache.m_P, localp, Jacobian);
          } else
            Trk::RungeKuttaUtils::transformGlobalToLocal(targetSurfaces[*iSol].first, errorPropagation,
                                                         cache.m_P, localp, Jacobian);
          solution = true;
        }
        valid_solutions.push_back(*iSol);
      }
      ++iSol;
    }
    solutions = std::move(valid_solutions);
    if (solution)
      break;
  }
 
  if (solutions.empty()) {
    return nullptr;
  }
 
  // simulation mode : smear momentum
  if (m_simulation && cache.m_matPropOK) {
    double radDist = totalPath / cache.m_material->x0();
    smear(cache, localp[2], localp[3], trackParameters.get(), radDist);
  }
 
  std::unique_ptr<Trk::TrackParameters> onTargetSurf =
      (returnCurv || targetSurfaces[solutions[0]].first->type() == Trk::SurfaceType::Cone)
          ? nullptr
          : targetSurfaces[solutions[0]].first->createUniqueTrackParameters(
                localp[0], localp[1], localp[2], localp[3], localp[4], std::nullopt);
 
  if (!errorPropagation) {
    if (returnCurv || targetSurfaces[solutions[0]].first->type() == Trk::SurfaceType::Cone) {
      Amg::Vector3D gp(cache.m_P[0], cache.m_P[1], cache.m_P[2]);
      return std::make_unique<Trk::CurvilinearParameters>(gp, localp[2], localp[3], localp[4]);
    }
    return onTargetSurf;
  }
 
  // Errormatrix is included. Use Jacobian to calculate new covariance
  for (double i : Jacobian) {
    if (!Amg::saneCovarianceElement(i)) {
      return nullptr;
    }
  }
 
  AmgSymMatrix(5) measurementCovariance =
      Trk::RungeKuttaUtils::newCovarianceMatrix(Jacobian, *trackParameters->covariance());
  if (!Amg::hasPositiveOrZeroDiagElems(measurementCovariance))
    return nullptr;
 
  // Calculate multiple scattering and straggling covariance contribution.
  if (cache.m_matPropOK && (cache.m_multipleScattering || cache.m_straggling) && std::abs(totalPath) > 0.) {
    if (returnCurv || targetSurfaces[solutions[0]].first->type() == Trk::SurfaceType::Cone) {
      covarianceContribution(cache, trackParameters.get(), totalPath, std::abs(1. / cache.m_P[6]),
                             measurementCovariance);
    } else {
      covarianceContribution(cache, trackParameters.get(), totalPath, onTargetSurf.get(),
                             measurementCovariance);
    }
  }
 
  if (returnCurv || targetSurfaces[solutions[0]].first->type() == Trk::SurfaceType::Cone) {
    Amg::Vector3D gp(cache.m_P[0], cache.m_P[1], cache.m_P[2]);
    return std::make_unique<Trk::CurvilinearParameters>(gp, localp[2], localp[3], localp[4],
                                                        std::move(measurementCovariance));
  }
 
  // delete onTargetSurf;          // the covariance matrix can be just added instead of recreating ?
  return targetSurfaces[solutions[0]].first->createUniqueTrackParameters(
      localp[0], localp[1], localp[2], localp[3], localp[4], std::move(measurementCovariance));
}

propagateT()

std::unique_ptr< Trk::TrackParameters > Trk::STEP_Propagator::propagateT ( const EventContext & ctx, const Trk::TrackParameters & trackParameters, std::vector< Trk::DestSurf > & targetSurfaces, Trk::PropDirection propagationDirection, const MagneticFieldProperties & magneticFieldProperties, ParticleHypothesis particle, std::vector< unsigned int > & solutions, Trk::PathLimit & path, Trk::TimeLimit & time, bool returnCurv, const Trk::TrackingVolume * tVol, std::vector< Trk::HitInfo > *& hitVector ) const

finaloverridevirtual

Propagate parameters and covariance with search of closest surface time included.

Implements Trk::IPropagator.

Definition at line 1322 of file STEP_Propagator.cxx.

                                                                            {
 
  Cache cache(ctx);
 
  // Get field cache object
  getFieldCacheObject(cache, ctx);
  setCacheFromProperties(cache);
  clearMaterialEffects(cache);
 
  // cache particle mass
  cache.m_particleMass = Trk::ParticleMasses::mass[particle];  // Get particle mass from ParticleHypothesis
 
  // cache input timing - for secondary track emission
  cache.m_timeIn = timeLim.time;
 
  // Check for tracking volume (materialproperties)
  cache.m_trackingVolume = tVol;
  cache.m_material = tVol;
  cache.m_matPropOK = tVol != nullptr;
 
  // no identified intersections needed/ no material dump
  cache.m_identifiedParameters = nullptr;
  cache.m_matstates = nullptr;
  cache.m_extrapolationCache = nullptr;
  cache.m_hitVector = hitVector;
 
  cache.m_matupd_lastmom = trackParameters.momentum().mag();
  cache.m_matupd_lastpath = 0.;
  cache.m_matdump_lastpath = 0.;
 
  // convert time/path limits into trajectory limit (in mm)
  double dMat = pathLim.x0Max - pathLim.x0Collected;
  double path =
      dMat > 0 && cache.m_matPropOK && cache.m_material->x0() > 0. ? dMat * cache.m_material->x0() : -1.;
 
  double dTim = timeLim.tMax - timeLim.time;
  double beta = 1.;
  if (dTim > 0.) {
    double mom = trackParameters.momentum().mag();
    beta = mom / std::sqrt(mom * mom + cache.m_particleMass * cache.m_particleMass);
  }
  double timMax = dTim > 0 ? dTim * beta * Gaudi::Units::c_light : -1.;
 
  if (timMax > 0. && timMax < path)
    path = timMax;
  bool usePathLimit = (path > 0.);
 
  // resolve path limit input
  if (path > 0.) {
    cache.m_propagateWithPathLimit = usePathLimit ? 1 : 0;
    cache.m_pathLimit = path;
    path = 0.;
  } else {
    cache.m_propagateWithPathLimit = 0;
    cache.m_pathLimit = -1.;
    path = 0.;
  }
 
  std::unique_ptr<Trk::TrackParameters> nextPar{};
 
  if (particle == Trk::neutron || particle == Trk::photon || particle == Trk::pi0 || particle == Trk::k0) {
    nextPar = propagateNeutral(trackParameters, targetSurfaces, propagationDirection, solutions, path,
                               usePathLimit, returnCurv);
  } else {
    nextPar = propagateRungeKutta(cache, true, trackParameters, targetSurfaces, propagationDirection,
                                  magneticFieldProperties, particle, solutions, path, returnCurv);
  }
  // update material path
  if (cache.m_matPropOK && cache.m_material->x0() > 0. && path > 0.) {
    pathLim.updateMat(path / cache.m_material->x0(), cache.m_material->averageZ(), 0.);
  }
  // return value
  timeLim.time += cache.m_timeOfFlight;
  return nextPar;
}

propagateWithJacobian()

bool Trk::STEP_Propagator::propagateWithJacobian ( Cache & cache, bool errorPropagation, std::vector< DestSurf > & sfs, double * P, Trk::PropDirection propDir, std::vector< unsigned int > & solutions, double & path, double sumPath ) const

private

Definition at line 2094 of file STEP_Propagator.cxx.

                                                                       {
  double maxPath = cache.m_maxPath;  // Max path allowed
  double* pos = &P[0];               // Start coordinates
  double* dir = &P[3];               // Start directions
  double dDir[3] = {0., 0., 0.};     // Start directions derivs. Zero in case of no RK steps
  // int          targetPassed = 0;                 // how many times have we passed the target?
  double previousDistance = 0.;
  double distanceStepped = 0.;
  double BG1[12] = {0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.};  // Bx, By, Bz, dBx/dx, dBx/dy, dBx/dz,
  // dBy/dx, dBy/dy, dBy/dz, dBz/dx, dBz/dy, dBz/dz at first point
  bool firstStep = true;  // Poll BG1, else recycle BG4
  int steps = 0;
  path = 0.;              // path of the trajectory
  cache.m_timeStep = 0.;  // time separation corresponding to the trajectory
  double mom = 0.;        // need momentum and beta for timing
  double beta = 1.;       // need momentum and beta for timing
 
  // factor to stabilize iteration for soft tracks
  double helpSoft = 1.;
 
  // limit number of recovery attempts
  int restartLimit = 10;
 
  Amg::Vector3D position(P[0], P[1], P[2]);
  Amg::Vector3D direction0(P[3], P[4], P[5]);
 
  // binned material ?
  cache.m_binMat = nullptr;
  if (cache.m_trackingVolume && cache.m_trackingVolume->isAlignable()) {
    const Trk::AlignableTrackingVolume* aliTV =
        static_cast<const Trk::AlignableTrackingVolume*>(cache.m_trackingVolume);
    cache.m_binMat = aliTV->binnedMaterial();
  }
 
  // closest distance estimate
  // maintain count of oscilations and previous distance for each surface;
  // skip initial trivial solutions (input parameters at surface) - should be treated before call to the
  // propagator
  // !
  double tol = 0.001;
  solutions.clear();
  double distanceToTarget = propDir * maxPath;
  cache.m_currentDist.resize(sfs.size());  // keep size through the call
 
  int nextSf = sfs.size();
  int nextSfCand = nextSf;
  std::vector<DestSurf>::iterator sIter = sfs.begin();
  std::vector<DestSurf>::iterator sBeg = sfs.begin();
  unsigned int numSf = 0;
  unsigned int iCurr = 0;  // index for m_currentDist
  int startSf = -99;
  for (; sIter != sfs.end(); ++sIter) {
    Trk::DistanceSolution distSol = (*sIter).first->straightLineDistanceEstimate(position, direction0);
    double distEst = -propDir * maxPath;
    double dist1Est = distEst;
    if (distSol.numberOfSolutions() > 0) {
      distEst = distSol.first();
      dist1Est = distSol.first();
      if (distSol.numberOfSolutions() > 1 &&
          (std::abs(distEst) < tol || (propDir * distEst < -tol && propDir * distSol.second() > tol)))
        distEst = distSol.second();
    }
    // select input surfaces;
    // do not accept trivial solutions (at the surface)
    // but include them into further distance estimate (aca return to the same surface)
    if (distEst * propDir > -tol) {
      if (distSol.currentDistance() > 500.) {
        cache.m_currentDist[iCurr] = std::pair<int, std::pair<double, double>>(
            0, std::pair<double, double>(distEst, distSol.currentDistance(true)));
      } else {
        cache.m_currentDist[iCurr] = std::pair<int, std::pair<double, double>>(
            1, std::pair<double, double>(distEst, distSol.currentDistance(true)));
      }
      if (tol < propDir * distEst && propDir * distEst < propDir * distanceToTarget) {
        distanceToTarget = distEst;
        nextSf = iCurr;
      }
      ++numSf;
    } else {
      // save the nearest distance to surface
      cache.m_currentDist[iCurr] = std::pair<int, std::pair<double, double>>(
          -1, std::pair<double, double>(distSol.currentDistance(), distSol.currentDistance(true)));
    }
    if (std::abs(dist1Est) < tol)
      startSf = (int)iCurr;
    ++iCurr;
  }
 
  if (distanceToTarget == maxPath || numSf == 0)
    return false;
 
  // these do not change
  std::vector<std::pair<int, std::pair<double, double>>>::iterator vsBeg = cache.m_currentDist.begin();
  std::vector<std::pair<int, std::pair<double, double>>>::iterator vsEnd = cache.m_currentDist.end();
  const int num_vs_dist = cache.m_currentDist.size();
 
  // Set initial step length to 100mm or the distance to the target surface.
  double h = 0;
  double absPath = 0.;
  distanceToTarget > 100. ? h = 100. : distanceToTarget < -100. ? h = -100. : h = distanceToTarget;
 
  const Trk::IdentifiedMaterial* binIDMat = nullptr;
  // Adapt step size to the material binning : change of bin layer triggers dump of material effects
  if (cache.m_binMat) {
    const Trk::BinUtility* lbu = cache.m_binMat->layerBinUtility(position);
    if (lbu) {
      cache.m_currentLayerBin = cache.m_binMat->layerBin(position);
      binIDMat = cache.m_binMat->material(position);
      std::pair<size_t, float> dist2next = lbu->distanceToNext(position, propDir * direction0);
      if (dist2next.first < lbu->bins() && std::abs(dist2next.second) > 1. &&
          std::abs(dist2next.second) < std::abs(h)) {
        h = dist2next.second * propDir;
      }
      if (binIDMat)
        cache.m_material = binIDMat->first.get();
    }
  }
 
  // Step to within distanceTolerance, then do the rest as a Taylor expansion.
  // Keep distanceTolerance within [1 nanometer, 10 microns].
  // This means that no final Taylor expansions beyond 10 microns and no
  // Runge-Kutta steps less than 1 nanometer are allowed.
  double distanceTolerance = std::min(std::max(std::abs(distanceToTarget) * cache.m_tolerance, 1e-6), 1e-2);
 
  // bremstrahlung : sample if activated
  if (cache.m_brem) {
    mom = std::abs(1. / P[6]);
    sampleBrem(cache, mom);
  }
 
  while (numSf > 0 && (std::abs(distanceToTarget) > distanceTolerance ||
                       std::abs(path + distanceStepped) < tol)) {  // Step until within tolerance
    // Do the step. Stop the propagation if the energy goes below m_momentumCutOff
    if (!rungeKuttaStep(cache, errorPropagation, h, P, dDir, BG1, firstStep, distanceStepped)) {
      // emit brem photon before stopped ?
      if (cache.m_brem) {
        if (m_momentumCutOff < cache.m_bremEmitThreshold && m_simMatUpdator) {
          Amg::Vector3D position(P[0], P[1], P[2]);
          Amg::Vector3D direction(P[3], P[4], P[5]);
          m_simMatUpdator->recordBremPhoton(cache.m_timeIn + cache.m_timeOfFlight + cache.m_timeStep,
                                            m_momentumCutOff, cache.m_bremMom, position, direction,
                                            cache.m_particle);
          // the recoil can be skipped here
          for (int i = 0; i < 3; ++i)
            P[3 + i] = direction[i];
          // end recoil ( momentum not adjusted here ! continuous energy loss maintained for the moment)
        }
      }
      // collect material and update timing
      path = path + distanceStepped;
      // timing
      mom = std::abs(1. / P[6]);
      beta = mom / std::sqrt(mom * mom + cache.m_particleMass * cache.m_particleMass);
      cache.m_timeStep += distanceStepped / beta / Gaudi::Units::c_light;
 
      if (std::abs(distanceStepped) > 0.001) {
        cache.m_sigmaIoni = cache.m_sigmaIoni - cache.m_kazL * log(std::abs(distanceStepped));
      }
      // update straggling covariance
      if (errorPropagation && cache.m_straggling) {
        // 15% of the Radition moves the MOP value thus only 85% is accounted for by the Mean-MOP shift
        double sigTot2 = cache.m_sigmaIoni * cache.m_sigmaIoni + cache.m_sigmaRad * cache.m_sigmaRad;
        // /(beta*beta*p*p*p*p) transforms Var(E) to Var(q/p)
        double bp2 = beta * mom * mom;
        cache.m_stragglingVariance += sigTot2 / (bp2 * bp2) * distanceStepped * distanceStepped;
      }
      if (cache.m_matstates || errorPropagation) {
        cache.m_combinedEloss.update(
            cache.m_delIoni * distanceStepped, cache.m_sigmaIoni * std::abs(distanceStepped),
            cache.m_delRad * distanceStepped, cache.m_sigmaRad * std::abs(distanceStepped), cache.m_MPV);
      }
      if (cache.m_material && cache.m_material->x0() != 0.) {
        cache.m_combinedThickness += propDir * distanceStepped / cache.m_material->x0();
      }
 
      return false;
    }
    path = path + distanceStepped;
    absPath += std::abs(distanceStepped);
 
    // timing
    mom = std::abs(1. / P[6]);
    beta = mom / std::sqrt(mom * mom + cache.m_particleMass * cache.m_particleMass);
    cache.m_timeStep += distanceStepped / beta / Gaudi::Units::c_light;
 
    if (std::abs(distanceStepped) > 0.001)
      cache.m_sigmaIoni = cache.m_sigmaIoni - cache.m_kazL * log(std::abs(distanceStepped));
    // update straggling covariance
    if (errorPropagation && cache.m_straggling) {
      // 15% of the Radition moves the MOP value thus only 85% is accounted for by the Mean-MOP shift
      double sigTot2 = cache.m_sigmaIoni * cache.m_sigmaIoni + cache.m_sigmaRad * cache.m_sigmaRad;
      // /(beta*beta*p*p*p*p) transforms Var(E) to Var(q/p)
      double bp2 = beta * mom * mom;
      cache.m_stragglingVariance += sigTot2 / (bp2 * bp2) * distanceStepped * distanceStepped;
    }
    if (cache.m_matstates || errorPropagation) {
      cache.m_combinedEloss.update(
          cache.m_delIoni * distanceStepped, cache.m_sigmaIoni * std::abs(distanceStepped),
          cache.m_delRad * distanceStepped, cache.m_sigmaRad * std::abs(distanceStepped), cache.m_MPV);
    }
    if (cache.m_material && cache.m_material->x0() != 0.) {
      cache.m_combinedThickness += propDir * distanceStepped / cache.m_material->x0();
    }
 
    if (absPath > maxPath)
      return false;
 
    // path limit implemented
    if (cache.m_propagateWithPathLimit > 0 && cache.m_pathLimit <= path) {
      ++cache.m_propagateWithPathLimit;
      return true;
    }
 
    bool restart = false;
    // in case of problems, make shorter steps
    if (propDir * path < -tol || absPath - std::abs(path) > 10.) {
      helpSoft = std::abs(path) / absPath > 0.5 ? std::abs(path) / absPath : 0.5;
    }
 
    Amg::Vector3D position(P[0], P[1], P[2]);
    Amg::Vector3D direction(P[3], P[4], P[5]);
 
    // Adapt step size to the material binning : change of bin layer triggers dump of material effects
    float distanceToNextBin = h;  // default
    if (cache.m_binMat) {
      const Trk::BinUtility* lbu = cache.m_binMat->layerBinUtility(position);
      if (lbu) {
        size_t layerBin = cache.m_binMat->layerBin(position);
        const Trk::IdentifiedMaterial* iMat = cache.m_binMat->material(position);
        std::pair<size_t, float> dist2next = lbu->distanceToNext(position, propDir * direction);
        distanceToNextBin = dist2next.second;
        if (layerBin != cache.m_currentLayerBin) {  // step into new bin
          // check the overshoot
          std::pair<size_t, float> dist2previous = lbu->distanceToNext(position, -propDir * direction);
          float stepOver = dist2previous.second;
          double localp[5];
          Trk::RungeKuttaUtils::transformGlobalToLocal(P, localp);
          auto cPar = std::make_unique<Trk::CurvilinearParameters>(Amg::Vector3D(P[0], P[1], P[2]), localp[2],
                                                                   localp[3], localp[4]);
          if (cache.m_identifiedParameters) {
            if (binIDMat && binIDMat->second > 0 && !iMat) {  // exit from active layer
              cache.m_identifiedParameters->emplace_back(cPar->clone(), -binIDMat->second);
            } else if (binIDMat && binIDMat->second > 0 &&
                       (iMat->second == 0 || iMat->second == binIDMat->second)) {  // exit from active layer
              cache.m_identifiedParameters->emplace_back(cPar->clone(), -binIDMat->second);
            } else if (iMat && iMat->second > 0) {  // entry active layer
              cache.m_identifiedParameters->emplace_back(cPar->clone(), iMat->second);
            }
          }
          if (cache.m_hitVector) {
            double hitTiming = cache.m_timeIn + cache.m_timeOfFlight + cache.m_timeStep;
            if (binIDMat && binIDMat->second > 0 && !iMat) {  // exit from active layer
              cache.m_hitVector->emplace_back(cPar->uniqueClone(), hitTiming, -binIDMat->second, 0.);
            } else if (binIDMat && binIDMat->second > 0 &&
                       (iMat->second == 0 || iMat->second == binIDMat->second)) {  // exit from active layer
              cache.m_hitVector->emplace_back(cPar->uniqueClone(), hitTiming, -binIDMat->second, 0.);
            } else if (iMat && iMat->second > 0) {  // entry active layer
              cache.m_hitVector->emplace_back(cPar->uniqueClone(), hitTiming, iMat->second, 0.);
            }
          }
 
          cache.m_currentLayerBin = layerBin;
          binIDMat = iMat;
          if (binIDMat) {
            // change of material triggers update of the cache
            // @TODO Coverity complains about a possible NULL pointer dereferencing here
            //  because the code above does not explicitly forbid m_material to be NULL and m_material is used
            //  unchecked inside updateMaterialEffects.
            //  Can m_material be NULL at this point ?
            if (cache.m_material) {
              updateMaterialEffects(cache, mom, sin(direction.theta()), sumPath + path - stepOver);
            }
            cache.m_material = binIDMat->first.get();
          }
          // recalculate distance to next bin
          if (distanceToNextBin < h) {
            Amg::Vector3D probe = position + (distanceToNextBin + h) * propDir * direction;
            std::pair<size_t, float> d2n = lbu->distanceToNext(probe, propDir * direction);
            distanceToNextBin += d2n.second + h;
          }
        } else if (dist2next.first < lbu->bins() && std::abs(distanceToNextBin) < 0.01 &&
                   h > 0.01) {  // tolerance 10 microns ?
          double localp[5];
          Trk::RungeKuttaUtils::transformGlobalToLocal(P, localp);
          auto cPar = std::make_unique<Trk::CurvilinearParameters>(Amg::Vector3D(P[0], P[1], P[2]), localp[2],
                                                                   localp[3], localp[4]);
 
          const Trk::IdentifiedMaterial* nextMat = binIDMat;
          // need to know what comes next
          Amg::Vector3D probe = position + (distanceToNextBin + 0.01) * propDir * direction.normalized();
          nextMat = cache.m_binMat->material(probe);
 
          if (cache.m_identifiedParameters) {
            if (binIDMat && binIDMat->second > 0 && !nextMat) {  // exit from active layer
              cache.m_identifiedParameters->emplace_back(cPar->clone(), -binIDMat->second);
            } else if (binIDMat && binIDMat->second > 0 &&
                       (nextMat->second == 0 || nextMat->second == binIDMat->second)) {
              // exit from active layer
              cache.m_identifiedParameters->emplace_back(cPar->clone(), -binIDMat->second);
            } else if (nextMat && nextMat->second > 0) {  // entry active layer
              cache.m_identifiedParameters->emplace_back(cPar->clone(), nextMat->second);
            }
          }
          if (cache.m_hitVector) {
            double hitTiming = cache.m_timeIn + cache.m_timeOfFlight + cache.m_timeStep;
            if (binIDMat && binIDMat->second > 0 && !nextMat) {  // exit from active layer
              cache.m_hitVector->emplace_back(cPar->uniqueClone(), hitTiming, -binIDMat->second, 0.);
            } else if (binIDMat && binIDMat->second > 0 &&
                       (nextMat->second == 0 ||
                        nextMat->second == binIDMat->second)) {  // exit from active layer
              cache.m_hitVector->emplace_back(cPar->uniqueClone(), hitTiming, -binIDMat->second, 0.);
            } else if (nextMat && nextMat->second > 0) {  // entry active layer
              cache.m_hitVector->emplace_back(cPar->uniqueClone(), hitTiming, nextMat->second, 0.);
            }
          }
 
          cache.m_currentLayerBin = dist2next.first;
          if (binIDMat != nextMat) {  // change of material triggers update of the cache
            binIDMat = nextMat;
            if (binIDMat) {
              assert(cache.m_material);
              updateMaterialEffects(cache, mom, sin(direction.theta()), sumPath + path);
              cache.m_material = binIDMat->first.get();
            }
          }
          // recalculate distance to next bin
          std::pair<size_t, float> d2n = lbu->distanceToNext(probe, propDir * direction.normalized());
          distanceToNextBin += d2n.second + 0.01;
        }
        // TODO: trigger the update of material properties and recalculation of distance to the target sliding
        // surface
      }
    }
 
    // Calculate new distance to targets
    bool flipDirection = false;
    numSf = 0;
    nextSfCand = nextSf;
    double dev = direction0.dot(direction);
    std::vector<DestSurf>::iterator sIter = sBeg;
    std::vector<std::pair<int, std::pair<double, double>>>::iterator vsIter = vsBeg;
    int ic = 0;
    int numRestart = 0;
 
    if (cache.m_brem) {
      if (mom < cache.m_bremEmitThreshold && m_simMatUpdator) {
        // ST : strictly speaking, the emission point should be shifted backwards a bit
        // (mom-m_bremEmitThreshold) this seems to be a minor point
        m_simMatUpdator->recordBremPhoton(cache.m_timeIn + cache.m_timeOfFlight + cache.m_timeStep, mom,
                                          cache.m_bremMom, position, direction, cache.m_particle);
        cache.m_bremEmitThreshold = 0.;
      }
      if (mom < cache.m_bremSampleThreshold)
        sampleBrem(cache, cache.m_bremSampleThreshold);
    }
 
    for (; vsIter != vsEnd; ++vsIter) {
      if (restart) {
        ++numRestart;
        if (numRestart > restartLimit)
          return false;
 
        vsIter = vsBeg;
        ic = 0;
        sIter = sBeg;
        distanceToTarget = propDir * maxPath;
        nextSf = -1;
        nextSfCand = -1;
        restart = false;
        helpSoft = 1.;
      }
      if ((*vsIter).first != -1 &&
          (ic == nextSf || (*vsIter).first == 1 || nextSf < 0 || std::abs((*vsIter).second.first) < 500. ||
           std::abs(path) > 0.5 * std::abs((*vsIter).second.second))) {
        previousDistance = (*vsIter).second.first;
        Trk::DistanceSolution distSol =
            (*sIter).first->straightLineDistanceEstimate(position, propDir * direction);
        double distanceEst = -propDir * maxPath;
        if (distSol.numberOfSolutions() > 0) {
          distanceEst = distSol.first();
          if (distSol.numberOfSolutions() > 1 &&
              std::abs(distSol.first() * propDir + distanceStepped - previousDistance) >
                  std::abs(distSol.second() * propDir + distanceStepped - previousDistance)) {
            distanceEst = distSol.second();
          }
          // Peter Kluit: avoid jumping into other (distSol.first->second) distance solution for start surface
          // with negative distance solution
          //              negative distanceEst will trigger flipDirection = true and will iterate to the start
          //              surface this will lead to very similar positions for multiple propagator calls and
          //              many tiny X0 scatterers
          if (ic == startSf && distanceEst < 0 && distSol.first() > 0)
            distanceEst = distSol.first();
        }
        // eliminate close surface if path too small
        if (ic == nextSf && std::abs(distanceEst) < tol && std::abs(path) < tol) {
          (*vsIter).first = -1;
          vsIter = vsBeg;
          restart = true;
          distanceToTarget = maxPath;
          nextSf = -1;
          continue;
        }
 
        // If h and distance are in opposite directions, target is passed. Flip propagation direction
        // Verify if true intersection
        //  if (  h * propDir * distanceEst < 0. &&  std::abs(distanceEst)>distanceTolerance ) {
        if ((*vsIter).second.first * propDir * distanceEst < 0. &&
            std::abs(distanceEst) > distanceTolerance) {
          // verify change of sign in signedDistance ( after eliminating situations where this is meaningless
          // )
          if (!distSol.signedDistance() || std::abs(distSol.currentDistance(true)) < tol ||
              std::abs((*vsIter).second.second) < tol ||
              (*vsIter).second.second * distSol.currentDistance(true) < 0) {  // true intersection
            if (ic == nextSf) {
              ((*vsIter).first)++;
              // eliminate surface if diverging
              if ((*vsIter).first > 3) {
                helpSoft = fmax(0.05, 1. - 0.05 * (*vsIter).first);
                if ((*vsIter).first > 20)
                  helpSoft = 1. / (*vsIter).first;
              }
              // take care of eliminating when number of flips even - otherwise it may end up at the start !
              if ((*vsIter).first > 50 && h * propDir > 0) {
                // std::abs(distanceEst) >= std::abs(previousDistance) )  {
                (*vsIter).first = -1;
                vsIter = vsBeg;
                restart = true;
                continue;
              }
              if ((*vsIter).first != -1)
                flipDirection = true;
            } else if (std::abs((*vsIter).second.second) > tol &&
                       std::abs(distSol.currentDistance(true)) > tol) {
              // here we need to compare with distance from current closest
              if (ic > nextSf && nextSf != -1) {  // easy case, already calculated
                if (propDir * distanceEst < (cache.m_currentDist.at(nextSf)).second.first - tol) {
                  if ((*vsIter).first != -1) {
                    ((*vsIter).first)++;
                    flipDirection = true;
                    nextSf = ic;
                  }
                }
              } else if (distanceToTarget >
                         0.) {  // set as nearest (if not iterating already), will be rewritten later
                if ((*vsIter).first != -1) {
                  ((*vsIter).first)++;
                  flipDirection = true;
                  nextSf = ic;
                }
              }
            }
          } else if (ic == nextSf) {
            vsIter = vsBeg;
            restart = true;
            continue;
          }
        }
 
        // save current distance to surface
        (*vsIter).second.first = propDir * distanceEst;
        (*vsIter).second.second = distSol.currentDistance(true);
 
        //  find closest surface: the step may have been beyond several surfaces
        //  from all surfaces with 'negative' distance, consider only the one currently designed as 'closest'
        //  mw  if ((*vsIter).first!=-1 && ( distanceEst>-tol || ic==nextSf ) ) {
        if ((*vsIter).first != -1 && (distanceEst > 0. || ic == nextSf)) {
          ++numSf;
          if (distanceEst < std::abs(distanceToTarget)) {
            distanceToTarget = propDir * distanceEst;
            nextSfCand = ic;
          }
        }
      } else if (std::abs(path) > std::abs((*vsIter).second.second) || dev < 0.985 ||
                 nextSf < 0) {  // keep an eye on surfaces with negative distance; tracks are curved !
        Trk::DistanceSolution distSol =
            (*sIter).first->straightLineDistanceEstimate(position, propDir * direction);
        double distanceEst = -propDir * maxPath;
        if (distSol.numberOfSolutions() > 0) {
          distanceEst = distSol.first();
        }
        // save current distance to surface
        (*vsIter).second.first = propDir * distanceEst;
        (*vsIter).second.second = distSol.currentDistance(true);
        // reactivate surface
        if (distanceEst > tol && distanceEst < maxPath) {
          (*vsIter).first = 0;
        } else {
          (*vsIter).second.first = distSol.currentDistance() + std::abs(path);
        }
        if ((*vsIter).first != -1 && distanceEst > 0.) {
          ++numSf;
          if (distanceEst < std::abs(distanceToTarget)) {
            distanceToTarget = propDir * distanceEst;
            nextSfCand = ic;
          }
        }
      }
      // additional protection - return to the same surface
      // eliminate the surface and restart the search
      // 04/10/10 ST:infinite loop due to distanceTolerance>tol fixed;
      if (std::abs(distanceToTarget) <= distanceTolerance && path * propDir < distanceTolerance) {
        (*vsIter).first = -1;
        vsIter = vsBeg;
        restart = true;
        continue;
      }
      ++sIter;
      ++ic;
    }
    // if next closest not found, propagation failed
    if (nextSf < 0 && nextSfCand < 0)
      return false;
    // flip direction
    if (flipDirection) {
      // Out of bounds protection
      if (nextSf < 0 || nextSf >= num_vs_dist)
        return false;
      distanceToTarget = (*(vsBeg + nextSf)).second.first;
      h = -h;
    } else if (nextSfCand != nextSf) {
      nextSf = nextSfCand;
      // Out of bounds protection
      if (nextSf < 0 || nextSf >= num_vs_dist)
        return false;
      if (cache.m_currentDist[nextSf].first < 3)
        helpSoft = 1.;
    }
 
    // don't step beyond surfaces - adjust step
    if (std::abs(h) > std::abs(distanceToTarget))
      h = distanceToTarget;
 
    // don't step beyond bin boundary - adjust step
    if (cache.m_binMat && std::abs(h) > std::abs(distanceToNextBin) + 0.001) {
      if (distanceToNextBin > 0) {  // TODO : investigate source of negative distance in BinningData
        h = distanceToNextBin * propDir;
      }
    }
 
    if (helpSoft < 1.)
      h *= helpSoft;
 
    // don't step much beyond path limit
    if (cache.m_propagateWithPathLimit > 0 && h > cache.m_pathLimit)
      h = cache.m_pathLimit + tol;
 
    // Abort if maxPath is reached
    if (std::abs(path) > maxPath)
      return false;
 
    if (steps++ > cache.m_maxSteps)
      return false;  // Too many steps, something is wrong
  }
 
  if (!numSf)
    return false;
 
  // Use Taylor expansions to step the remaining distance (typically microns).
  path = path + distanceToTarget;
 
  // timing
  mom = std::abs(1. / P[6]);
  beta = mom / std::sqrt(mom * mom + cache.m_particleMass * cache.m_particleMass);
  cache.m_timeStep += distanceToTarget / beta / Gaudi::Units::c_light;
 
  // pos = pos + h*dir + 1/2*h*h*dDir. Second order Taylor expansion.
  pos[0] = pos[0] + distanceToTarget * (dir[0] + 0.5 * distanceToTarget * dDir[0]);
  pos[1] = pos[1] + distanceToTarget * (dir[1] + 0.5 * distanceToTarget * dDir[1]);
  pos[2] = pos[2] + distanceToTarget * (dir[2] + 0.5 * distanceToTarget * dDir[2]);
 
  // dir = dir + h*dDir. First order Taylor expansion (Euler).
  dir[0] = dir[0] + distanceToTarget * dDir[0];
  dir[1] = dir[1] + distanceToTarget * dDir[1];
  dir[2] = dir[2] + distanceToTarget * dDir[2];
 
  // Normalize dir
  double norm = 1. / std::sqrt(dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2]);
  dir[0] = norm * dir[0];
  dir[1] = norm * dir[1];
  dir[2] = norm * dir[2];
  P[42] = dDir[0];
  P[43] = dDir[1];
  P[44] = dDir[2];
 
  // collect all surfaces with distance below tolerance
  std::vector<std::pair<int, std::pair<double, double>>>::iterator vsIter = vsBeg;
 
  int index = 0;
  for (; vsIter != vsEnd; ++vsIter) {
    if ((*vsIter).first != -1 && propDir * (*vsIter).second.first >= propDir * distanceToTarget - tol &&
        propDir * (*vsIter).second.first < 0.01 && index != nextSf) {
      solutions.push_back(index);
    }
    if (index == nextSf)
      solutions.push_back(index);
    ++index;
  }
 
  return true;
}

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();
  }

sampleBrem()

void Trk::STEP_Propagator::sampleBrem ( Cache & cache, double mom ) const

private

Definition at line 2786 of file STEP_Propagator.cxx.

                                                                  {
  if (!cache.m_randomEngine) {
    cache.m_randomEngine = getRandomEngine(cache.m_ctx);
  }
  double rndx = CLHEP::RandFlat::shoot(cache.m_randomEngine);
  double rnde = CLHEP::RandFlat::shoot(cache.m_randomEngine);
 
  // sample visible fraction of the mother momentum taken according to 1/f
  double eps = cache.m_momentumCutOff / mom;
  cache.m_bremMom = pow(eps, pow(rndx, exp(1.))) * mom;  // adjustment here ?
  cache.m_bremSampleThreshold = mom - cache.m_bremMom;
  cache.m_bremEmitThreshold = mom - rnde * cache.m_bremMom;
}

setCacheFromProperties()

void Trk::STEP_Propagator::setCacheFromProperties ( Cache & cache ) const

inlineprivate

initialize cache with the variables we need to take from

Definition at line 421 of file STEP_Propagator.h.

  {
    cache.m_includeBgradients = m_includeBgradients;
    cache.m_includeGgradient = m_includeGgradient;
    cache.m_energyLoss = m_energyLoss;
    cache.m_detailedElossFlag = m_detailedEloss;
    cache.m_MPV = m_MPV;
    cache.m_multipleScattering = m_multipleScattering;
    cache.m_straggling = m_straggling;
    cache.m_tolerance = m_tolerance;
    cache.m_momentumCutOff = m_momentumCutOff;
    cache.m_scatteringScale = m_scatteringScale;
    cache.m_maxPath = m_maxPath;
    cache.m_maxSteps = m_maxSteps;
    cache.m_layXmax = m_layXmax;
  }

smear()

void Trk::STEP_Propagator::smear ( Cache & cache, double & phi, double & theta, const Trk::TrackParameters * parms, double radDist ) const

private

Definition at line 2749 of file STEP_Propagator.cxx.

                                                       {
  if (cache.m_particle == Trk::geantino)
    return;
  if (!parms)
    return;
 
  if (!cache.m_randomEngine) {
    cache.m_randomEngine = getRandomEngine(cache.m_ctx);
  }
 
  // Calculate polar angle
  double particleMass = Trk::ParticleMasses::mass[cache.m_particle];  // Get particle mass from
                                                                      // ParticleHypothesis
  double momentum = parms->momentum().mag();
  double energy = std::sqrt(momentum * momentum + particleMass * particleMass);
  double beta = momentum / energy;
  double th = std::sqrt(2.) * 15. * std::sqrt(radDist) / (beta * momentum) *
              CLHEP::RandGauss::shoot(cache.m_randomEngine);  // Moliere
  // double th = (sqrt(2.)*13.6*std::sqrt(radDist)/(beta*momentum)) *
  // (1.+0.038*log(radDist/(beta*beta))) * m_gaussian->shoot(); //Highland
 
  // Calculate azimuthal angle
  double ph = 2. * M_PI * CLHEP::RandFlat::shoot(cache.m_randomEngine);
 
  Amg::Transform3D rot(Amg::AngleAxis3D(-theta, Amg::Vector3D(0., 1., 0.)) *
                       Amg::AngleAxis3D(-phi, Amg::Vector3D(0., 0., 1.)));
  Amg::Vector3D dir0(0., 0., 1.);
  Amg::Vector3D rotated = rot.inverse() * Amg::AngleAxis3D(ph, Amg::Vector3D(0., 0., 1.)) *
                          Amg::AngleAxis3D(th, Amg::Vector3D(0., 1., 0.)) * dir0;
 
  theta = rotated.theta();
  phi = rotated.phi();
}

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 >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

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_detailedEloss

BooleanProperty Trk::STEP_Propagator::m_detailedEloss

private

Initial value:

{this, "DetailedEloss", true,
    "Provide the extended EnergyLoss object with MopIonization etc."}

Definition at line 499 of file STEP_Propagator.h.

                                 {this, "DetailedEloss", true,
    "Provide the extended EnergyLoss object with MopIonization etc."};

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_energyLoss

BooleanProperty Trk::STEP_Propagator::m_energyLoss {this, "EnergyLoss", true, "Include energy loss?"}

private

Definition at line 498 of file STEP_Propagator.h.

{this, "EnergyLoss", true, "Include energy loss?"};

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_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> Trk::STEP_Propagator::m_fieldCacheCondObjInputKey

private

Initial value:

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

Definition at line 531 of file STEP_Propagator.h.

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

m_includeBgradients

BooleanProperty Trk::STEP_Propagator::m_includeBgradients

private

Initial value:

{this, "IncludeBgradients", true,
    "Include B-field gradients in the error propagation"}

Definition at line 490 of file STEP_Propagator.h.

                                     {this, "IncludeBgradients", true,
    "Include B-field gradients in the error propagation"};

m_includeGgradient

BooleanProperty Trk::STEP_Propagator::m_includeGgradient

private

Initial value:

{this, "IncludeGgradient", false,
    "Include dg/dlambda into the error propagation? Only relevant when energy loss is true."}

Definition at line 492 of file STEP_Propagator.h.

                                    {this, "IncludeGgradient", false,
    "Include dg/dlambda into the error propagation? Only relevant when energy loss is true."};

m_layXmax

DoubleProperty Trk::STEP_Propagator::m_layXmax

private

Initial value:

{this, "MSstepMax", 1.,
    "maximal layer thickness for multiple scattering calculations"}

Definition at line 513 of file STEP_Propagator.h.

                          {this, "MSstepMax", 1.,
    "maximal layer thickness for multiple scattering calculations"};

m_materialEffects

BooleanProperty Trk::STEP_Propagator::m_materialEffects

private

Initial value:

{this, "MaterialEffects", true,
    "Switch material effects on or off"}

Definition at line 488 of file STEP_Propagator.h.

                                   {this, "MaterialEffects", true,
    "Switch material effects on or off"};

m_maxPath

DoubleProperty Trk::STEP_Propagator::m_maxPath

private

Initial value:

{this, "MaxPath", 100000.,
    "Maximum propagation length in mm."}

Definition at line 509 of file STEP_Propagator.h.

                          {this, "MaxPath", 100000.,
    "Maximum propagation length in mm."};

m_maxSteps

IntegerProperty Trk::STEP_Propagator::m_maxSteps

private

Initial value:

{this, "MaxSteps", 10000,
    "Maximum number of allowed steps (to avoid infinite loops)."}

Definition at line 511 of file STEP_Propagator.h.

                            {this, "MaxSteps", 10000,
    "Maximum number of allowed steps (to avoid infinite loops)."};

m_momentumCutOff

DoubleProperty Trk::STEP_Propagator::m_momentumCutOff

private

Initial value:

{this, "MomentumCutOff", 50.,
    "Stop propagation below this momentum in MeV"}

Definition at line 494 of file STEP_Propagator.h.

                                 {this, "MomentumCutOff", 50.,
    "Stop propagation below this momentum in MeV"};

m_MPV

BooleanProperty Trk::STEP_Propagator::m_MPV

private

Initial value:

{this, "MostProbableEnergyLoss", false,
    "Use the most probable value of the energy loss, else use the mean energy loss."}

Definition at line 503 of file STEP_Propagator.h.

                       {this, "MostProbableEnergyLoss", false,
    "Use the most probable value of the energy loss, else use the mean energy loss."};

m_multipleScattering

BooleanProperty Trk::STEP_Propagator::m_multipleScattering

private

Initial value:

{this, "MultipleScattering", true,
    "Add multiple scattering to the covariance matrix?"}

Definition at line 496 of file STEP_Propagator.h.

                                      {this, "MultipleScattering", true,
    "Add multiple scattering to the covariance matrix?"};

m_randomEngineName

StringProperty Trk::STEP_Propagator::m_randomEngineName

private

Initial value:

{this, "RandomStreamName", "FatrasRnd",
    "Name of the random number stream"}

Definition at line 527 of file STEP_Propagator.h.

                                   {this, "RandomStreamName", "FatrasRnd",
    "Name of the random number stream"};

m_rndGenSvc

ServiceHandle<IAthRNGSvc> Trk::STEP_Propagator::m_rndGenSvc

private

Initial value:

{this, "RandomNumberService", "AthRNGSvc",
    "Random number generator"}

Random Generator service.

Definition at line 523 of file STEP_Propagator.h.

                                       {this, "RandomNumberService", "AthRNGSvc",
    "Random number generator"};

m_rngWrapper

ATHRNG::RNGWrapper* Trk::STEP_Propagator::m_rngWrapper = nullptr

private

Random engine.

Definition at line 526 of file STEP_Propagator.h.

m_scatteringScale

DoubleProperty Trk::STEP_Propagator::m_scatteringScale

private

Initial value:

{this, "MultipleScatteringScale", 1.,
    "Scale for adjusting the multiple scattering contribution to the covariance matrix."}

Definition at line 507 of file STEP_Propagator.h.

                                  {this, "MultipleScatteringScale", 1.,
    "Scale for adjusting the multiple scattering contribution to the covariance matrix."};

m_simMatUpdator

ToolHandle<ITimedMatEffUpdator> Trk::STEP_Propagator::m_simMatUpdator {this, "SimMatEffUpdator", ""}

private

secondary interactions (brem photon emission)

Definition at line 521 of file STEP_Propagator.h.

{this, "SimMatEffUpdator", ""};

m_simulation

BooleanProperty Trk::STEP_Propagator::m_simulation

private

Initial value:

{this, "SimulationMode", false,
    "flag for simulation mode"}

Definition at line 518 of file STEP_Propagator.h.

                              {this, "SimulationMode", false,
    "flag for simulation mode"};

m_straggling

BooleanProperty Trk::STEP_Propagator::m_straggling

private

Initial value:

{this, "Straggling", true,
    "Add energy loss fluctuations (straggling) to the covariance matrix?"}

Definition at line 501 of file STEP_Propagator.h.

                              {this, "Straggling", true,
    "Add energy loss fluctuations (straggling) to the covariance matrix?"};

m_stragglingScale

DoubleProperty Trk::STEP_Propagator::m_stragglingScale

private

Initial value:

{this, "StragglingScale", 1.,
    "Scale for adjusting the width of the energy loss fluctuations."}

Definition at line 505 of file STEP_Propagator.h.

                                  {this, "StragglingScale", 1.,
    "Scale for adjusting the width of the energy loss fluctuations."};

m_tolerance

DoubleProperty Trk::STEP_Propagator::m_tolerance

private

Initial value:

{this, "Tolerance", 1e-05,
    "Error tolerance. Low tolerance gives igh accuracy"}

Definition at line 486 of file STEP_Propagator.h.

                            {this, "Tolerance", 1e-05,
    "Error tolerance. Low tolerance gives igh accuracy"};

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:

• STEP_Propagator.h
• STEP_Propagator.cxx