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/Propagator/ConstrainedStep.hpp"
#include "Acts/Surfaces/BoundaryCheck.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Utilities/Definitions.hpp"
#include "Acts/Utilities/Intersection.hpp"
#include "Acts/Utilities/Logger.hpp"

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

namespace Acts {

struct TargetOptions {
  NavigationDirection navDir = forward;

  BoundaryCheck boundaryCheck = false;

  const Surface* startObject = nullptr;

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

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

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

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

struct SurfaceReached {
  SurfaceReached() = default;

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

  template <typename propagator_state_t, typename stepper_t>
  bool operator()(propagator_state_t& state, const stepper_t& stepper,
                  const Surface& targetSurface) const {
    const auto& logger = state.options.logger;
    if (state.navigation.targetReached) {
      return true;
    }
    // Check if the cache filled the currentSurface - or if we are on the
    // surface
    if ((state.navigation.currentSurface &&
         state.navigation.currentSurface == &targetSurface)) {
      ACTS_VERBOSE("Target: x | "
                   << "Target surface reached.");
      // reaching the target calls a navigation break
      state.navigation.targetReached = true;
      return true;
    }
    // Calculate the distance to the surface
    const double tolerance = state.options.targetTolerance;
    const auto sIntersection = targetSurface.intersect(
        state.geoContext, stepper.position(state.stepping),
        state.stepping.navDir * stepper.direction(state.stepping), true);

    // The target is reached
    bool targetReached = (sIntersection.intersection.status ==
                          Intersection3D::Status::onSurface);
    double distance = sIntersection.intersection.pathLength;

    // Return true if you fall below tolerance
    if (targetReached) {
      ACTS_VERBOSE("Target: x | "
                   << "Target surface reached at distance (tolerance) "
                   << distance << " (" << tolerance << ")");
      // assigning the currentSurface
      state.navigation.currentSurface = &targetSurface;
      ACTS_VERBOSE("Target: x | "
                   << "Current surface set to target surface  "
                   << state.navigation.currentSurface->geometryId());

      // reaching the target calls a navigation break
      state.navigation.targetReached = true;
    } else {
      // Target is not reached, update the step size
      const double overstepLimit = stepper.overstepLimit(state.stepping);
      // Check the alternative solution
      if (distance < overstepLimit and sIntersection.alternative) {
        // Update the distance to the alternative solution
        distance = sIntersection.alternative.pathLength;
      }
      state.stepping.stepSize.update(state.stepping.navDir * distance,
                                     ConstrainedStep::aborter);
      ACTS_VERBOSE("Target: 0 | "
                   << "Target stepSize (surface) updated to "
                   << state.stepping.stepSize.toString());
    }
    // path limit check
    return targetReached;
  }
};

struct EndOfWorldReached {
  EndOfWorldReached() = default;

  template <typename propagator_state_t, typename stepper_t>
  bool operator()(propagator_state_t& state,
                  const stepper_t& /*unused*/) const {
    if (state.navigation.currentVolume != nullptr) {
      return false;
    }
    state.navigation.targetReached = true;
    return true;
  }
};

}  // namespace Acts