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>
 
using namespace Acts::UnitLiterals;
 
namespace ActsTrk {
  class IExtrapolationTool : virtual public IAlgTool {
    public:
      DeclareInterfaceID(ActsTrk::IExtrapolationTool, 1, 0);
      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,
                        Acts::Direction navDir = Acts::Direction::Forward(),
                        double pathLimit = 1._km) const = 0;
      
      struct SurfaceRecordOptions {
          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
          };

          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};
          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,
                                                 Acts::Direction navDir = Acts::Direction::Forward(),
                                                 double pathLimit = 1._km) const = 0;
      virtual Acts::Result<Acts::BoundTrackParameters> propagate(const EventContext& ctx,
                                                                  const Acts::BoundTrackParameters& startParameters,
                                                                  const Acts::Surface& target,
                                                                  Acts::Direction navDir = Acts::Direction::Forward(),
                                                                  double pathLimit = 1._km) const = 0;
      virtual Acts::Result<Acts::BoundTrackParameters> propagate(const EventContext& ctx,
                                                                  const Acts::BoundTrackParameters& startParameters,
                                                                  Acts::Direction navDir = Acts::Direction::Forward(),
                                                                  double pathLimit = 1._km) const = 0;
  };
 
}
 
#endif