IntersectorWrapper.h

Go to the documentation of this file.

/*
   Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
 */
 
// wrapper to IIntersector tool to provide IPropagator functionality
//   default configuration wraps the RungeKutta intersector
// (c) ATLAS Detector software
 
#ifndef TRKEXRUNGEKUTTAINTERSECTOR_INTERSECTORWRAPPER_H
#define TRKEXRUNGEKUTTAINTERSECTOR_INTERSECTORWRAPPER_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/ToolHandle.h"
#include "GeoPrimitives/GeoPrimitives.h"
#include "TrkExInterfaces/IPropagator.h"
 
namespace Trk {
class IIntersector;
class TrackSurfaceIntersection;
 
class IntersectorWrapper final
  : public AthAlgTool
  , virtual public IPropagator
{
 
public:
  IntersectorWrapper(const std::string& type,
                     const std::string& name,
                     const IInterface* parent);
  ~IntersectorWrapper(void); // destructor
 
  virtual StatusCode initialize() override final;
  virtual StatusCode finalize() override final;
 
  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& parm,
    const Surface& sf,
    PropDirection dir,
    const BoundaryCheck& bcheck,
    const MagneticFieldProperties& mprop,
    ParticleHypothesis particle,
    bool returnCurv,
    const TrackingVolume*) const override final;
 
  virtual std::unique_ptr<TrackParameters> propagate(
    const EventContext&,
    const TrackParameters&,
    std::vector<DestSurf>&,
    PropDirection,
    const MagneticFieldProperties&,
    ParticleHypothesis,
    std::vector<unsigned int>&,
    double&,
    bool,
    bool,
    const TrackingVolume*) const override final
  {
    ATH_MSG_ERROR("Call to non-implemented propagate");
    return nullptr;
  }
 
  // unimplemented propagateT
  virtual std::unique_ptr<TrackParameters> propagateT(
    const EventContext&,
    const TrackParameters&,
    std::vector<DestSurf>&,
    PropDirection,
    const MagneticFieldProperties&,
    ParticleHypothesis,
    std::vector<unsigned int>&,
    PathLimit&,
    TimeLimit&,
    bool,
    const TrackingVolume*,
    std::vector<Trk::HitInfo>*&) const override final
  {
    ATH_MSG_ERROR("Call to non-implemented propagate");
    return nullptr;
  }
 
  virtual std::unique_ptr<TrackParameters> propagate(
    const EventContext& ctx,
    const TrackParameters&,
    const Surface&,
    PropDirection,
    const BoundaryCheck&,
    const MagneticFieldProperties&,
    std::optional<TransportJacobian>&,
    double&,
    ParticleHypothesis,
    bool,
    const TrackingVolume*) const override final;
 
  virtual std::unique_ptr<TrackParameters> propagateParameters(
    const EventContext& ctx,
    const TrackParameters& parm,
    const Surface& sf,
    PropDirection dir,
    const BoundaryCheck& bcheck,
    const MagneticFieldProperties& mprop,
    ParticleHypothesis particle = pion,
    bool returnCurv = false,
    const TrackingVolume* tVol = nullptr) const override final;
 
  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>&,
    ParticleHypothesis particle = pion,
    bool returnCurv = false,
    const TrackingVolume* tVol = nullptr) const override final;
 
  virtual std::optional<Trk::TrackSurfaceIntersection> intersect(
    const EventContext& ctx,
    const TrackParameters& parm,
    const Surface& sf,
    const MagneticFieldProperties& mprop,
    ParticleHypothesis particle = pion,
    const TrackingVolume* tVol = nullptr) const override final;
 
  // unimplemented globalPositions
  virtual void globalPositions(const EventContext&,
                               std::deque<Amg::Vector3D>&,
                               const TrackParameters&,
                               const MagneticFieldProperties&,
                               const CylinderBounds&,
                               double,
                               ParticleHypothesis,
                               const TrackingVolume*) const override final
  {
    ATH_MSG_ERROR("Call to non-implemented globalPositions");
    return;
  }
 
  // unimplemented intersectSurface
  virtual std::optional<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 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 Trk::MultiComponentState multiStatePropagate(
    const EventContext&,
    const MultiComponentState&,
    const Surface&,
    const MagneticFieldProperties&,
    const PropDirection,
    const BoundaryCheck&,
    const ParticleHypothesis) const override final
  {
    ATH_MSG_ERROR("Call to non-implemented multiStatePropagate");
    return {};
  }
 
  virtual Trk::ExtrapolationCode propagate(
    const EventContext&,
    Trk::ExCellCharged&,
    Trk::TargetSurfaces&,
    Trk::TargetSurfaceVector&) const override final
  {
    return Trk::ExtrapolationCode::FailureConfiguration;
  }
 
private:
  struct Cache
  {
    double m_charge;
    double m_qOverP;
    std::optional<TrackSurfaceIntersection> m_intersection;
    std::unique_ptr<TrackParameters> m_parameters;
    Amg::Vector3D m_position;
    Amg::Vector3D m_momentum;
 
    Cache()
      : m_charge{}
      , m_qOverP{}
      , m_intersection{ std::nullopt }
      , m_parameters{ nullptr }
      , m_position{}
      , m_momentum{}
    {
    }
  };
  // private methods
  void createParameters(Cache& cache,
                        const Surface& surface,
                        const BoundaryCheck& boundsCheck,
                        bool curvilinear) const;
  void findIntersection(Cache& cache,
                        const TrackParameters& parameters,
                        const Surface& surface,
                        PropDirection dir = Trk::anyDirection) const;
 
  // helpers, managers, tools
  ToolHandle<IIntersector> m_intersector;
  ToolHandle<IPropagator> m_linePropagator;
};
 
} // end of namespace
 
#endif // TRKEXRUNGEKUTTAINTERSECTOR_INTERSECTORWRAPPER_H