StandardAborters.hpp

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file StandardAborters.hpp

// This file is part of the Acts project.
//
// Copyright (C) 2017-2018 CERN for the benefit of the Acts project
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

#pragma once

#include "Acts/Definitions/Algebra.hpp"
#include "Acts/Definitions/Direction.hpp"
#include "Acts/Definitions/Units.hpp"
#include "Acts/Propagator/ConstrainedStep.hpp"
#include "Acts/Surfaces/BoundaryCheck.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/Intersection.hpp"
#include "Acts/Utilities/Logger.hpp"

#include <limits>
#include <optional>
#include <sstream>
#include <string>

namespace Acts {

struct TargetOptions {
  Direction navDir = Direction::Forward;

  BoundaryCheck boundaryCheck = false;

  const Surface* startObject = nullptr;

  double pathLimit = std::numeric_limits<double>::max();

  TargetOptions(Direction ndir) : navDir(ndir) {}
};

struct PathLimitReached {
  double internalLimit = std::numeric_limits<double>::max();

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool operator()(propagator_state_t& state, const stepper_t& stepper,
                  const navigator_t& navigator, const Logger& logger) const {
    if (navigator.targetReached(state.navigation)) {
      return true;
    }
    // Check if the maximum allowed step size has to be updated
    double distance =
        std::abs(internalLimit) - std::abs(state.stepping.pathAccumulated);
    double tolerance = state.options.targetTolerance;
    bool limitReached = (std::abs(distance) < std::abs(tolerance));
    if (limitReached) {
      ACTS_VERBOSE("Target: x | "
                   << "Path limit reached at distance " << distance);
      // reaching the target means navigation break
      navigator.targetReached(state.navigation, true);
      return true;
    }
    stepper.setStepSize(state.stepping, distance, ConstrainedStep::aborter,
                        false);
    ACTS_VERBOSE("Target: 0 | "
                 << "Target stepSize (path limit) updated to "
                 << stepper.outputStepSize(state.stepping));
    return false;
  }
};

struct SurfaceReached {
  std::optional<double> overstepLimit;

  SurfaceReached() = default;
  SurfaceReached(double oLimit) : overstepLimit(oLimit) {}

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool operator()(propagator_state_t& state, const stepper_t& stepper,
                  const navigator_t& navigator, const Logger& logger) const {
    return (*this)(state, stepper, navigator,
                   *navigator.targetSurface(state.navigation), logger);
  }

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool operator()(propagator_state_t& state, const stepper_t& stepper,
                  const navigator_t& navigator, const Surface& targetSurface,
                  const Logger& logger) const {
    if (navigator.targetReached(state.navigation)) {
      return true;
    }

    // Check if the cache filled the currentSurface - or if we are on the
    // surface
    if ((navigator.currentSurface(state.navigation) &&
         navigator.currentSurface(state.navigation) == &targetSurface)) {
      ACTS_VERBOSE("Target: x | "
                   << "Target surface reached.");
      // reaching the target calls a navigation break
      navigator.targetReached(state.navigation, true);
      return true;
    }

    // TODO the following code is mostly duplicated in updateSingleSurfaceStatus

    // Calculate the distance to the surface
    const double tolerance = state.options.targetTolerance;

    const auto sIntersection = targetSurface.intersect(
        state.geoContext, stepper.position(state.stepping),
        state.options.direction * stepper.direction(state.stepping), true,
        tolerance);
    const auto closest = sIntersection.closest();

    // Return true if you fall below tolerance
    if (closest.status() == Intersection3D::Status::onSurface) {
      const double distance = closest.pathLength();
      ACTS_VERBOSE("Target: x | "
                   << "Target surface reached at distance (tolerance) "
                   << distance << " (" << tolerance << ")");

      // assigning the currentSurface
      navigator.currentSurface(state.navigation, &targetSurface);
      ACTS_VERBOSE("Target: x | "
                   << "Current surface set to target surface  "
                   << navigator.currentSurface(state.navigation)->geometryId());

      // reaching the target calls a navigation break
      navigator.targetReached(state.navigation, true);

      return true;
    }

    const double pLimit =
        state.stepping.stepSize.value(ConstrainedStep::aborter);
    // not using the stepper overstep limit here because it does not always work
    // for perigee surfaces
    const double oLimit =
        overstepLimit.value_or(stepper.overstepLimit(state.stepping));

    for (const auto& intersection : sIntersection.split()) {
      if (intersection &&
          detail::checkIntersection(intersection.intersection(), pLimit, oLimit,
                                    tolerance, logger)) {
        stepper.setStepSize(state.stepping, intersection.pathLength(),
                            ConstrainedStep::aborter, false);
        break;
      }
    }

    ACTS_VERBOSE("Target: 0 | "
                 << "Target stepSize (surface) updated to "
                 << stepper.outputStepSize(state.stepping));

    return false;
  }
};

struct EndOfWorldReached {
  EndOfWorldReached() = default;

  template <typename propagator_state_t, typename stepper_t,
            typename navigator_t>
  bool operator()(propagator_state_t& state, const stepper_t& /*stepper*/,
                  const navigator_t& navigator,
                  const Logger& /*logger*/) const {
    bool endOfWorld = navigator.endOfWorldReached(state.navigation);
    navigator.targetReached(state.navigation, endOfWorld);
    return endOfWorld;
  }
};

}  // namespace Acts