RungeKuttaPropagator.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
 */
 
//  Header file for class  RungeKuttaPropagator, (c) ATLAS Detector software
 
#ifndef RungeKuttaPropagator_H
#define RungeKuttaPropagator_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ServiceHandle.h"
#include "TrkEventPrimitives/ParticleHypothesis.h"
#include "TrkEventPrimitives/PropDirection.h"
#include "TrkExInterfaces/IPatternParametersPropagator.h"
#include "TrkExInterfaces/IPropagator.h"
#include "TrkNeutralParameters/NeutralParameters.h"
#include "TrkParameters/TrackParameters.h"
#include <list>
 
// MagField cache
#include "MagFieldConditions/AtlasFieldCacheCondObj.h"
#include "MagFieldElements/AtlasFieldCache.h"
 
namespace Trk {
 
class Surface;
class MagneticFieldProperties;
class CylinderBounds;
class CylinderSurface;
class PatternTrackParameters;
 
class RungeKuttaPropagator final
  : public AthAlgTool
  , virtual public IPropagator
  , virtual public IPatternParametersPropagator
{
 
public:
  RungeKuttaPropagator(const std::string&,
                       const std::string&,
                       const IInterface*);
  virtual StatusCode initialize() override final;
  virtual ~RungeKuttaPropagator() = default;
 
  virtual std::unique_ptr<NeutralParameters> propagate(
    const NeutralParameters&,
    const Surface&,
    PropDirection,
    const BoundaryCheck&,
    bool) const override final;
 
  virtual std::unique_ptr<TrackParameters> propagate(
    const EventContext& ctx,
    const TrackParameters&,
    const Surface&,
    const PropDirection,
    const BoundaryCheck&,
    const MagneticFieldProperties&,
    ParticleHypothesis /*not used*/,
    bool,
    const TrackingVolume*) const override final;
 
  virtual Trk::MultiComponentState multiStatePropagate(
    const EventContext& ctx,
    const MultiComponentState& multiComponentState,
    const Surface& surface,
    const MagneticFieldProperties& fieldProperties,
    const PropDirection direction = Trk::anyDirection,
    const BoundaryCheck& boundaryCheck = true,
    const ParticleHypothesis particleHypothesis =
      nonInteracting) const override final;
 
  virtual std::unique_ptr<TrackParameters> propagate(
    const EventContext& ctx,
    const TrackParameters&,
    const Surface&,
    const PropDirection,
    const BoundaryCheck&,
    const MagneticFieldProperties&,
    std::optional<TransportJacobian>&,
    double&,
    ParticleHypothesis /*not used*/,
    bool,
    const TrackingVolume*) const override final;
 
  virtual std::unique_ptr<TrackParameters> propagate(
    const EventContext& ctx,
    const TrackParameters&,
    std::vector<DestSurf>&,
    PropDirection,
    const MagneticFieldProperties&,
    ParticleHypothesis /*not used*/,
    std::vector<unsigned int>&,
    double&,
    bool,
    bool,
    const TrackingVolume*) const override final;
 
  virtual std::unique_ptr<TrackParameters> propagateParameters(
    const EventContext& ctx,
    const TrackParameters&,
    const Surface&,
    const PropDirection,
    const BoundaryCheck&,
    const MagneticFieldProperties&,
    ParticleHypothesis /*not used*/,
    bool,
    const TrackingVolume*) const override final;
 
  virtual std::unique_ptr<TrackParameters> propagateParameters(
    const EventContext& ctx,
    const TrackParameters&,
    const Surface&,
    const PropDirection,
    const BoundaryCheck&,
    const MagneticFieldProperties&,
    std::optional<TransportJacobian>&,
    ParticleHypothesis /*not used*/,
    bool,
    const TrackingVolume*) const override final;
 
  virtual std::optional<Trk::TrackSurfaceIntersection> intersect(
    const EventContext& ctx,
    const TrackParameters&,
    const Surface&,
    const MagneticFieldProperties&,
    ParticleHypothesis /*not used*/,
    const TrackingVolume* tvol = nullptr) const override final;
 
  virtual void globalPositions(
    const EventContext& ctx,
    std::deque<Amg::Vector3D>&,
    const TrackParameters&,
    const MagneticFieldProperties&,
    const CylinderBounds&,
    double,
    ParticleHypothesis /*not used*/,
    const TrackingVolume* tvol = nullptr) const override final;
 
  // Public methods for Trk::PatternTrackParameters (from IPattern'Propagator)
 
  virtual bool propagate(
    const EventContext& ctx,
    PatternTrackParameters&,
    const Surface&,
    PatternTrackParameters&,
    PropDirection,
    const MagneticFieldProperties&,
    ParticleHypothesis particle = pion) const override final;
 
  virtual bool propagate(
    const EventContext& ctx,
    PatternTrackParameters&,
    const Surface&,
    PatternTrackParameters&,
    PropDirection,
    const MagneticFieldProperties&,
    double&,
    ParticleHypothesis particle = pion) const override final;
 
  virtual bool propagateParameters(
    const EventContext& ctx,
    PatternTrackParameters&,
    const Surface&,
    PatternTrackParameters&,
    PropDirection,
    const MagneticFieldProperties&,
    ParticleHypothesis particle = pion) const override final;
 
  virtual bool propagateParameters(
    const EventContext& ctx,
    PatternTrackParameters&,
    const Surface&,
    PatternTrackParameters&,
    PropDirection,
    const MagneticFieldProperties&,
    double&,
    ParticleHypothesis particle = pion) const override final;
 
  virtual void globalPositions(
    const EventContext& ctx,
    const PatternTrackParameters&,
    std::vector<const Surface*>&,
    std::vector<std::pair<Amg::Vector3D, double>>&,
    const MagneticFieldProperties&,
    ParticleHypothesis particle = pion) const override final;
 
  virtual std::unique_ptr<Trk::TrackParameters> propagateT(
    const EventContext&,
    const TrackParameters&,
    std::vector<DestSurf>&,
    PropDirection,
    const MagneticFieldProperties&,
    ParticleHypothesis,
    std::vector<unsigned int>&,
    PathLimit&,
    TimeLimit&,
    bool,
    const Trk::TrackingVolume*,
    std::vector<Trk::HitInfo>*&) const override final
  {
    ATH_MSG_ERROR("Call to non-implemented propagateT");
    return nullptr;
  }
 
  virtual std::unique_ptr<Trk::TrackParameters> propagateM(
    const EventContext&,
    const TrackParameters&,
    std::vector<DestSurf>&,
    PropDirection,
    const MagneticFieldProperties&,
    ParticleHypothesis,
    std::vector<unsigned int>&,
    std::vector<const Trk::TrackStateOnSurface*>*&,
    std::vector<std::pair<std::unique_ptr<Trk::TrackParameters>, int>>*,
    double&,
    bool,
    bool,
    const Trk::TrackingVolume*,
    Trk::ExtrapolationCache*) const override final
  {
    ATH_MSG_ERROR("Call to non-implemented propagateM");
    return nullptr;
  }
 
  virtual std::optional<Trk::TrackSurfaceIntersection> intersectSurface(
    const EventContext&,
    const Surface&,
    const TrackSurfaceIntersection&,
    const double,
    const MagneticFieldProperties&,
    ParticleHypothesis) const override final
  {
    ATH_MSG_ERROR("Call to non-implemented intersectSurface");
    return std::nullopt;
  }
 
  virtual Trk::ExtrapolationCode propagate(
    const EventContext&,
    Trk::ExCellCharged&,
    Trk::TargetSurfaces&,
    Trk::TargetSurfaceVector&) const override final
  {
    return Trk::ExtrapolationCode::FailureConfiguration;
  }
 
  struct Cache
  {
    MagField::AtlasFieldCache m_fieldCache;
    double m_field[3];
    double m_direction;
    double m_step;
    double m_maxPath = 10000.;
    double m_dlt = .000200;
    double m_helixStep = 1;
    double m_straightStep = 0.01;
    bool m_maxPathLimit = false;
    bool m_mcondition = false;
    bool m_solenoid = true;
    bool m_needgradient = false;
    bool m_newfield = true;
    bool m_usegradient = false;
  };
 
private:
  // Private methods:
  Cache getInitializedCache(const EventContext& ctx) const;
 
  // Private data members:
 
  // Read handle for conditions object to get the field cache
  SG::ReadCondHandleKey<AtlasFieldCacheCondObj> m_fieldCondObjInputKey{
    this,
    "AtlasFieldCacheCondObj",
    "fieldCondObj",
    "Name of the Magnetic Field conditions object key"
  };
 
  double m_dlt;          // accuracy parameter
  double m_helixStep;    // max step whith helix model
  double m_straightStep; // max step whith srtaight line model
  bool m_usegradient;    // use magnetig field gradient into the error
                         // propagation
};
 
} // end namespace Trk
#endif // RungeKuttaPropagator_H