MultiStepperAborters.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2021 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/StandardAborters.hpp"
#include "Acts/Surfaces/Surface.hpp"

namespace Acts {

struct MultiStepperSurfaceReached {
  MultiStepperSurfaceReached() = default;

  bool averageOnSurface = true;

  double averageOnSurfaceTolerance = 0.2;

  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 {
    bool reached = true;
    const auto oldCurrentSurface = navigator.currentSurface(state.navigation);

    for (auto cmp : stepper.componentIterable(state.stepping)) {
      auto singleState = cmp.singleState(state);
      const auto& singleStepper = cmp.singleStepper(stepper);

      if (!SurfaceReached{}(singleState, singleStepper, navigator,
                            targetSurface, logger)) {
        reached = false;
      } else {
        cmp.status() = Acts::Intersection3D::Status::onSurface;
      }
    }

    // However, if mean of all is on surface, we are happy as well
    if (averageOnSurface) {
      const auto sIntersection =
          targetSurface
              .intersect(
                  state.geoContext, stepper.position(state.stepping),
                  state.options.direction * stepper.direction(state.stepping),
                  true, averageOnSurfaceTolerance)
              .closest();

      if (sIntersection.status() == Intersection3D::Status::onSurface) {
        ACTS_VERBOSE("Reached target in average mode");
        navigator.currentSurface(state.navigation, &targetSurface);
        navigator.targetReached(state.navigation, true);

        for (auto cmp : stepper.componentIterable(state.stepping)) {
          cmp.status() = Intersection3D::Status::onSurface;
        }

        return true;
      }
    }

    // These values are changed by the single component aborters but must be
    // reset if not all components are on the target
    if (!reached) {
      navigator.currentSurface(state.navigation, oldCurrentSurface);
      navigator.targetReached(state.navigation, false);
    }

    return reached;
  }
};
}  // namespace Acts