d8/d00/IPropagator_8h_source.html

/*

  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration

*/


// IPropagator.h, (c) ATLAS Detector software


#ifndef TRKEXINTERFACES_IPROPAGATOR_H

#define TRKEXINTERFACES_IPROPAGATOR_H


// Gaudi

#include "GaudiKernel/EventContext.h"

#include "GaudiKernel/IAlgTool.h"

#include "GaudiKernel/ThreadLocalContext.h"


// Trk

#include "TrkEventPrimitives/ParticleHypothesis.h"

#include "TrkEventPrimitives/PropDirection.h"

#include "TrkExInterfaces/HelperStructs.h"

#include "TrkExUtils/ExtrapolationCache.h"

#include "TrkExUtils/TargetSurfaces.h"

#include "TrkExUtils/TrackSurfaceIntersection.h"

#include "TrkNeutralParameters/NeutralParameters.h"

#include "TrkParameters/ComponentParameters.h"

#include "TrkParameters/TrackParameters.h"

#include "TrkSurfaces/BoundaryCheck.h"

// STL

#include <utility>

#include <deque>

#include <optional>


namespace Trk {


class Surface;

class CylinderBounds;

class MagneticFieldProperties;

class TransportJacobian;

class TrackStateOnSurface;


typedef std::pair<const TrackParameters*, double> TrackParametersWithPath;


typedef std::pair<const Surface*, BoundaryCheck> DestSurf;


static const InterfaceID IID_IPropagator("IPropagator", 1, 0);


class IPropagator : virtual public IAlgTool

{

public:

  virtual ~IPropagator() = default;


  static const InterfaceID& interfaceID() { return IID_IPropagator; }


  virtual std::unique_ptr<NeutralParameters> propagate(

    const NeutralParameters& parameters,

    const Surface& sf,

    PropDirection dir,

    const BoundaryCheck& bcheck,

    bool returnCurv = false) const = 0;


  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 = pion,

    bool returnCurv = false,

    const TrackingVolume* tVol = nullptr) const = 0;


  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 = 0;


  virtual std::unique_ptr<TrackParameters> propagate(

    const EventContext& ctx,

    const TrackParameters& parm,

    std::vector<DestSurf>& sfs,

    PropDirection dir,

    const MagneticFieldProperties& mprop,

    ParticleHypothesis particle,

    std::vector<unsigned int>& solutions,

    double& path,

    bool usePathLim = false,

    bool returnCurv = false,

    const TrackingVolume* tVol = nullptr) const = 0;


  virtual std::unique_ptr<TrackParameters> propagateT(

    const EventContext& ctx,

    const TrackParameters& parm,

    std::vector<DestSurf>& sfs,

    PropDirection dir,

    const MagneticFieldProperties& mprop,

    ParticleHypothesis particle,

    std::vector<unsigned int>& solutions,

    PathLimit& pathLim,

    TimeLimit& timeLim,

    bool returnCurv,

    const TrackingVolume* tVol,

    std::vector<Trk::HitInfo>*& hitVector) const = 0;


  virtual std::unique_ptr<TrackParameters> propagateM(

    const EventContext& ctx,

    const TrackParameters& parm,

    std::vector<DestSurf>& sfs,

    PropDirection dir,

    const MagneticFieldProperties& mprop,

    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 usePathLim = false,

    bool returnCurv = false,

    const TrackingVolume* tVol = nullptr,

    Trk::ExtrapolationCache* cache = nullptr) const = 0;


  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;


  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 = 0;


  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;


  virtual std::optional<TrackSurfaceIntersection> intersect(

    const EventContext& ctx,

    const TrackParameters& parm,

    const Surface& sf,

    const MagneticFieldProperties& mprop,

    ParticleHypothesis particle = pion,

    const TrackingVolume* tVol = nullptr) const = 0;


  virtual std::optional<TrackSurfaceIntersection> intersectSurface(

    const EventContext& ctx,

    const Surface& surface,

    const TrackSurfaceIntersection& trackIntersection,

    const double qOverP,

    const MagneticFieldProperties& mft,

    ParticleHypothesis particle) const = 0;


  virtual void globalPositions(const EventContext& ctx,

                               std::deque<Amg::Vector3D>& positionslist,

                               const TrackParameters& parm,

                               const MagneticFieldProperties& mprop,

                               const CylinderBounds& cylbo,

                               double stepSize,

                               ParticleHypothesis particle = pion,

                               const TrackingVolume* tVol = nullptr) const = 0;


  virtual Trk::ExtrapolationCode propagate(

    const EventContext& ctx,

    Trk::ExCellCharged& eCell,

    Trk::TargetSurfaces& sfs,

    Trk::TargetSurfaceVector& solutions) const = 0;


};


} // end of namespace


#endif // TRKEXINTERFACES_PROPAGATOR_H