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 <boost/algorithm/string.hpp>
#include <iomanip>
#include <iterator>
#include <sstream>
#include <string>
#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"

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 surfaceSequence = {};

    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.surfaceSequence = surfaceSequence;
        state.navigation.nextSurfaceIter =
            state.navigation.surfaceSequence.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 surfaceSequence = {};

    SurfaceIter nextSurfaceIter = surfaceSequence.begin();

    const Surface* startSurface = nullptr;
    const Surface* currentSurface = nullptr;
    const Surface* targetSurface = 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 {
    // Screen output
    debugLog(state, [&] { return std::string("Entering navigator::status."); });

    // Navigator status always resets the current surface
    state.navigation.currentSurface = nullptr;
    // Output the position in the sequence
    debugLog(state, [&] {
      std::stringstream dstream;
      dstream << std::distance(state.navigation.nextSurfaceIter,
                               state.navigation.surfaceSequence.end());
      dstream << " out of " << state.navigation.surfaceSequence.size();
      dstream << " surfaces remain to try.";
      return dstream.str();
    });
    // Check if we are on surface
    if (state.navigation.nextSurfaceIter !=
        state.navigation.surfaceSequence.end()) {
      // Establish the surface status
      auto surfaceStatus = stepper.updateSurfaceStatus(
          state.stepping, **state.navigation.nextSurfaceIter, false);
      if (surfaceStatus == Intersection::Status::onSurface) {
        // Set the current surface
        state.navigation.currentSurface = *state.navigation.nextSurfaceIter;
        debugLog(state, [&] {
          std::stringstream dstream;
          dstream << "Current surface set to  "
                  << state.navigation.currentSurface->geoID();
          return dstream.str();
        });
        // Move the sequence to the next surface
        ++state.navigation.nextSurfaceIter;
        if (state.navigation.nextSurfaceIter !=
            state.navigation.surfaceSequence.end()) {
          debugLog(state, [&] {
            std::stringstream dstream;
            dstream << "Next surface candidate is  "
                    << (*state.navigation.nextSurfaceIter)->geoID();
            return dstream.str();
          });
          stepper.releaseStepSize(state.stepping);
        }
      } else if (surfaceStatus == Intersection::Status::reachable) {
        debugLog(state, [&] {
          std::stringstream dstream;
          dstream << "Next surface reachable at distance  "
                  << stepper.outputStepSize(state.stepping);
          return dstream.str();
        });
      }
    }
  }

  template <typename propagator_state_t, typename stepper_t>
  void target(propagator_state_t& state, const stepper_t& stepper) const {
    // Screen output
    debugLog(state, [&] { return std::string("Entering navigator::target."); });

    // Navigator target always resets the current surface
    state.navigation.currentSurface = nullptr;
    // Output the position in the sequence
    debugLog(state, [&] {
      std::stringstream dstream;
      dstream << std::distance(state.navigation.nextSurfaceIter,
                               state.navigation.surfaceSequence.end());
      dstream << " out of " << state.navigation.surfaceSequence.size();
      dstream << " surfaces remain to try.";
      return dstream.str();
    });
    if (state.navigation.nextSurfaceIter !=
        state.navigation.surfaceSequence.end()) {
      // Establish & update the surface status
      auto surfaceStatus = stepper.updateSurfaceStatus(
          state.stepping, **state.navigation.nextSurfaceIter, false);
      if (surfaceStatus == Intersection::Status::unreachable) {
        debugLog(state, [&] {
          std::stringstream dstream;
          dstream << "Surface not reachable anymore, switching to next one in "
                     "sequence";
          return dstream.str();
        });
        // Move the sequence to the next surface
        ++state.navigation.nextSurfaceIter;
      } else {
        debugLog(state, [&] {
          std::stringstream dstream;
          dstream << "Navigation stepSize set to ";
          dstream << stepper.outputStepSize(state.stepping);
          return dstream.str();
        });
      }
    } 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
        debugLog(state,
                 [&] { return std::string("No target Surface, job done."); });
      }
    }
  }

 private:
  template <typename propagator_state_t>
  void debugLog(propagator_state_t& state,
                const std::function<std::string()>& logAction) const {
    if (state.options.debug) {
      std::string vName = "Direct Navigator";
      std::vector<std::string> lines;
      std::string input = logAction();
      boost::split(lines, input, boost::is_any_of("\n"));
      for (const auto& line : lines) {
        std::stringstream dstream;
        dstream << ">>>" << std::setw(state.options.debugPfxWidth) << vName
                << " | ";
        dstream << std::setw(state.options.debugMsgWidth) << line << '\n';
        state.options.debugString += dstream.str();
      }
    }
  }
};

}  // namespace Acts