IExtrapolationTool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ACTSGEOMETRYINTERFACES_ActsTrkIExtrapolationTool_H
#define ACTSGEOMETRYINTERFACES_ActsTrkIExtrapolationTool_H
 
#include "AthenaBaseComps/AthAlgTool.h"
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/IAlgTool.h"
#include "GaudiKernel/EventContext.h"
#include "TrkEventPrimitives/ParticleHypothesis.h"
 
#include "ActsGeometryInterfaces/GeometryContext.h"
#include "Acts/MagneticField/MagneticFieldContext.hpp"
 
#include "Acts/Propagator/MaterialInteractor.hpp"
#include "Acts/Propagator/detail/SteppingLogger.hpp"
#include "Acts/EventData/BoundTrackParameters.hpp"
#include "Acts/Definitions/Units.hpp"
 
#include <variant>
 
 
namespace ActsTrk {
  using namespace Acts::UnitLiterals;

  class IExtrapolationTool : virtual public IAlgTool {
    public:
      DeclareInterfaceID(ActsTrk::IExtrapolationTool, 1, 0);

      enum class VolumeAbort: std::uint8_t{
        atEntrance, //Propagation stops at entrance of the target volume
        atExit, // Propagation stops as soon as the mother volume is entered
      };

      using RecordedMaterial = Acts::MaterialInteractor::result_type;
      using PropagationOutput = std::pair<std::vector<Acts::detail::Step>, 
                                          RecordedMaterial>;
      using BoundParamVec_t = std::vector<Acts::BoundTrackParameters>;
      virtual Acts::Result<PropagationOutput> propagationSteps(const EventContext& ctx,
                        const Acts::BoundTrackParameters& startParameters,
                        const Acts::Direction navDir = Acts::Direction::Forward(),
                        const double pathLimit = 1._km) const = 0;
      
      struct SurfaceRecordOptions {
          explicit SurfaceRecordOptions(const Acts::TrackingVolume* targetVol,
                                        VolumeAbort abordCond = VolumeAbort::atExit):
                    target{targetVol}, stopVolumeFlag{abordCond} {}
 
          explicit SurfaceRecordOptions(const Acts::Surface* targetSurf,
                                        double extraPath = 0.):
                    target{targetSurf}, extraPathLength{extraPath}{}

          std::variant<const Acts::TrackingVolume*,
                       const Acts::Surface*> target{};
          double extraPathLength{0.};
          double pathLimit{1._km};
          VolumeAbort stopVolumeFlag{VolumeAbort::atExit};
          Acts::Direction navDir{Acts::Direction::Forward()};
          bool recordSensitive{true};
          bool recordMaterial{false};
          bool recordPassive{false};
      };
      
      virtual Acts::Result<BoundParamVec_t> propagateAndRecord(const EventContext& ctx,
                                                               const Acts::BoundTrackParameters& startParameters,
                                                               const SurfaceRecordOptions& recordOpts) const = 0;
 
      virtual Acts::Result<PropagationOutput> propagationSteps(const EventContext& ctx,
                                                 const Acts::BoundTrackParameters& startParameters,
                                                 const Acts::Surface& target,
                                                 const Acts::Direction navDir = Acts::Direction::Forward(),
                                                 const double pathLimit = 1._km) const = 0;
      virtual Acts::Result<Acts::BoundTrackParameters> propagate(const EventContext& ctx,
                                                                 const Acts::BoundTrackParameters& startParameters,
                                                                 const Acts::Surface& target,
                                                                 const Acts::Direction navDir = Acts::Direction::Forward(),
                                                                 const double pathLimit = 1._km) const = 0;
      virtual Acts::Result<Acts::BoundTrackParameters> propagate(const EventContext& ctx,
                                                                 const Acts::BoundTrackParameters& startParameters,
                                                                 const Acts::TrackingVolume& target,
                                                                 const VolumeAbort stopVolumeFlag,
                                                                 const Acts::Direction navDir = Acts::Direction::Forward(),
                                                                 const double pathLimit = 1._km) const = 0;
      virtual Acts::Result<Acts::BoundTrackParameters> propagate(const EventContext& ctx,
                                                                 const Acts::BoundTrackParameters& startParameters,
                                                                 const Acts::Direction navDir = Acts::Direction::Forward(),
                                                                 const double pathLimit = 1._km) const = 0;
  };
 
}
 
#endif