d3/d5b/IExtrapolator_8h_source.html

/*

  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,

    std::vector<const Trk::TrackStateOnSurface*>*& material,

    int destination = 3) const = 0;


  virtual const TrackingGeometry* trackingGeometry() const = 0;


};

} // end of namespace


#endif // TRKEXINTERFACES_ITRKEXTRAPOLATOR_H