IExtrapolator.h

Go to the documentation of this file.

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

// IExtrapolator.h, (c) ATLAS Detector software
 
#ifndef TRKEXINTERFACES_IEXTRAPOLATOR_H
#define TRKEXINTERFACES_IEXTRAPOLATOR_H
 
// Gaudi
#include "GaudiKernel/EventContext.h"
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/ThreadLocalContext.h"
 
// Trk
#include "TrkEventPrimitives/ParticleHypothesis.h"
#include "TrkEventPrimitives/PropDirection.h"
#include "TrkExUtils/ExtrapolationCache.h"
#include "TrkExUtils/MaterialUpdateMode.h"
#include "TrkMaterialOnTrack/MaterialEffectsOnTrack.h"
#include "TrkNeutralParameters/NeutralParameters.h"
#include "TrkParameters/TrackParameters.h"
#include "TrkParametersBase/ParametersBase.h"
#include "TrkSurfaces/BoundaryCheck.h"
 
// xAOD
#include "xAODTracking/NeutralParticle.h"
#include "xAODTracking/TrackParticle.h"
// STL
#include <memory>
#include <utility>
 
namespace Trk {
 
static const InterfaceID IID_IExtrapolator("IExtrapolator", 1, 0);

 
class INavigator;
class Track;
class Surface;
class TrackingVolume;
class TrackingGeometry;
class TrackStateOnSurface;
class Layer;
class Volume;
 
class IExtrapolator : virtual public IAlgTool
{
public:
  virtual ~IExtrapolator() {}

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

  virtual std::unique_ptr<NeutralParameters> extrapolate(
    const NeutralParameters& parameters,
    const Surface& sf,
    PropDirection dir = anyDirection,
    const BoundaryCheck& bcheck = true) const = 0;

  virtual std::unique_ptr<TrackParameters> extrapolate(
    const EventContext& ctx,
    const TrackParameters& parm,
    const Surface& sf,
    PropDirection dir = anyDirection,
    const BoundaryCheck& bcheck = true,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise,
    Trk::ExtrapolationCache* cache = nullptr) const = 0;

  virtual std::vector<std::unique_ptr<TrackParameters>>
  extrapolateStepwise(const EventContext& ctx,
                      const TrackParameters& parm,
                      const Surface& sf,
                      PropDirection dir = anyDirection,
                      const BoundaryCheck& bcheck = true,
                      ParticleHypothesis particle = pion) const = 0;

  virtual std::unique_ptr<TrackParameters> extrapolateTrack(
    const EventContext& ctx,
    const Track& trk,
    const Surface& sf,
    PropDirection dir = anyDirection,
    const BoundaryCheck& bcheck = true,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise,
    Trk::ExtrapolationCache* cache = nullptr) const = 0;

  virtual std::unique_ptr<TrackParameters> extrapolateDirectly(
    const EventContext& ctx,
    const TrackParameters& parm,
    const Surface& sf,
    PropDirection dir = anyDirection,
    const BoundaryCheck& bcheck = true,
    ParticleHypothesis particle = pion) const = 0;
 

  virtual std::vector<std::unique_ptr<TrackParameters>>
  extrapolateBlindly(const EventContext& ctx,
                     const TrackParameters& parm,
                     PropDirection dir = anyDirection,
                     const BoundaryCheck& bcheck = true,
                     ParticleHypothesis particle = pion,
                     const Volume* boundaryVol = nullptr) const = 0;

  virtual std::pair<std::unique_ptr<TrackParameters>, const Trk::Layer*>
  extrapolateToNextActiveLayerM(
    const EventContext& ctx,
    const TrackParameters& parm,
    PropDirection dir,
    const BoundaryCheck& bcheck,
    std::vector<const Trk::TrackStateOnSurface*>& material,
    ParticleHypothesis particle = pion,
    MaterialUpdateMode matupmode = addNoise) const = 0;

  virtual std::unique_ptr<TrackParameters> extrapolateToVolume(
    const EventContext& ctx,
    const TrackParameters& parm,
    const Trk::TrackingVolume& vol,
    PropDirection dir = anyDirection,
    ParticleHypothesis particle = pion) const = 0;

  virtual std::vector<const TrackStateOnSurface*>* extrapolateM(
    const EventContext& ctx,
    const TrackParameters& parameters,
    const Surface& sf,
    PropDirection dir,
    const BoundaryCheck& bcheck,
    ParticleHypothesis particle = pion,
    Trk::ExtrapolationCache* cache = nullptr) const = 0;

  virtual std::unique_ptr<
      std::vector<std::pair<std::unique_ptr<Trk::TrackParameters>, int>>>
  collectIntersections(
    const EventContext& ctx,
    const Trk::TrackParameters& parm,
    Trk::PropDirection dir,
    Trk::ParticleHypothesis particle,
    int destination = 3) const = 0;

  virtual const TrackingGeometry* trackingGeometry() const = 0;
 
};
} // end of namespace
 
#endif // TRKEXINTERFACES_ITRKEXTRAPOLATOR_H