DirectNavigator.hpp

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

// This file is part of the Acts project.
//
// Copyright (C) 2019 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/Geometry/BoundarySurfaceT.hpp"
#include "Acts/Geometry/Layer.hpp"
#include "Acts/Geometry/TrackingGeometry.hpp"
#include "Acts/Geometry/TrackingVolume.hpp"
#include "Acts/Propagator/ConstrainedStep.hpp"
#include "Acts/Propagator/Propagator.hpp"
#include "Acts/Surfaces/Surface.hpp"

#include <iomanip>
#include <iterator>
#include <sstream>
#include <string>

#include <boost/algorithm/string.hpp>

namespace Acts {

class DirectNavigator {
 public:
  using SurfaceSequence = std::vector<const Surface*>;
  using SurfaceIter = std::vector<const Surface*>::iterator;

  DirectNavigator() = default;

  double tolerance = s_onSurfaceTolerance;

  struct Initializer {
    SurfaceSequence navSurfaces = {};

    struct this_result {
      bool initialized = false;
    };
    using result_type = this_result;

    Initializer() = default;

    template <typename propagator_state_t, typename stepper_t>
    void operator()(propagator_state_t& state, const stepper_t& /*unused*/,
                    result_type& r) const {
      // Only act once
      if (not r.initialized) {
        // Initialize the surface sequence
        state.navigation.navSurfaces = navSurfaces;
        state.navigation.navSurfaceIter =
            state.navigation.navSurfaces.begin();
        r.initialized = true;
      }
    }

    template <typename propagator_state_t, typename stepper_t>
    void operator()(propagator_state_t& /*unused*/,
                    const stepper_t& /*unused*/) const {}
  };

  struct State {
    SurfaceSequence navSurfaces = {};

    SurfaceIter navSurfaceIter = navSurfaces.begin();

    const Surface* startSurface = nullptr;
    const Surface* currentSurface = nullptr;
    const Surface* targetSurface = nullptr;  
    const Layer* startLayer = nullptr;
    const Layer* targetLayer = nullptr; 
    const TrackingVolume* startVolume = nullptr;
    const TrackingVolume* currentVolume = nullptr;
    const TrackingVolume* targetVolume = nullptr;

    bool targetReached = false;
    bool navigationBreak = false;
  };

  template <typename propagator_state_t, typename stepper_t>
  void status(propagator_state_t& state, const stepper_t& stepper) const {
    const auto& logger = state.options.logger;
    // Screen output
    ACTS_VERBOSE("Entering navigator::status.");

    // Navigator status always resets the current surface
    state.navigation.currentSurface = nullptr;
    // Output the position in the sequence
    ACTS_VERBOSE(std::distance(state.navigation.navSurfaceIter,
                               state.navigation.navSurfaces.end())
                 << " out of " << state.navigation.navSurfaces.size()
                 << " surfaces remain to try.");

    // Check if we are on surface
    if (state.navigation.navSurfaceIter !=
        state.navigation.navSurfaces.end()) {
      // Establish the surface status
      auto surfaceStatus = stepper.updateSurfaceStatus(
          state.stepping, **state.navigation.navSurfaceIter, false);
      if (surfaceStatus == Intersection3D::Status::onSurface) {
        // Set the current surface
        state.navigation.currentSurface = *state.navigation.navSurfaceIter;
        ACTS_VERBOSE("Current surface set to  "
                     << state.navigation.currentSurface->geometryId())
        // Move the sequence to the next surface
        ++state.navigation.navSurfaceIter;
        if (state.navigation.navSurfaceIter !=
            state.navigation.navSurfaces.end()) {
          ACTS_VERBOSE("Next surface candidate is  "
                       << (*state.navigation.navSurfaceIter)->geometryId());
          stepper.releaseStepSize(state.stepping);
        }
      } else if (surfaceStatus == Intersection3D::Status::reachable) {
        ACTS_VERBOSE("Next surface reachable at distance  "
                     << stepper.outputStepSize(state.stepping));
      }
    }
  }

  template <typename propagator_state_t, typename stepper_t>
  void target(propagator_state_t& state, const stepper_t& stepper) const {
    const auto& logger = state.options.logger;
    // Screen output
    ACTS_VERBOSE("Entering navigator::target.");

    // Navigator target always resets the current surface
    state.navigation.currentSurface = nullptr;
    // Output the position in the sequence
    ACTS_VERBOSE(std::distance(state.navigation.navSurfaceIter,
                               state.navigation.navSurfaces.end())
                 << " out of " << state.navigation.navSurfaces.size()
                 << " surfaces remain to try.");

    if (state.navigation.navSurfaceIter !=
        state.navigation.navSurfaces.end()) {
      // Establish & update the surface status
      auto surfaceStatus = stepper.updateSurfaceStatus(
          state.stepping, **state.navigation.navSurfaceIter, false);
      if (surfaceStatus == Intersection3D::Status::unreachable) {
        ACTS_VERBOSE(
            "Surface not reachable anymore, switching to next one in "
            "sequence");
        // Move the sequence to the next surface
        ++state.navigation.navSurfaceIter;
      } else {
        ACTS_VERBOSE("Navigation stepSize set to "
                     << stepper.outputStepSize(state.stepping));
      }
    } else {
      // Set the navigation break
      state.navigation.navigationBreak = true;
      // If no externally provided target is given, the target is reached
      if (state.navigation.targetSurface == nullptr) {
        state.navigation.targetReached = true;
        // Announce it then
        ACTS_VERBOSE("No target Surface, job done.");
      }
    }
  }
};

}  // namespace Acts