Move_always.hpp

Go to the documentation of this file.

/*******************************************************************************
 Causal Dynamical Triangulations in C++ using CGAL
 
 Copyright © 2017 Adam Getchell
 ******************************************************************************/
 
 
#ifndef INCLUDE_MOVE_ALWAYS_HPP_
#define INCLUDE_MOVE_ALWAYS_HPP_
 
#include "Move_command.hpp"
#include "Move_strategy.hpp"
 
template <typename ManifoldType>
class MoveStrategy<Strategies::MOVE_ALWAYS, ManifoldType>  // NOLINT
{
  using Counter = move_tracker::MoveTracker<ManifoldType>;
 
  Int_precision m_passes{1};
 
  Int_precision m_checkpoint{1};
 
  Counter m_attempted_moves;
 
  Counter m_successful_moves;
 
  Counter m_failed_moves;
 
 public:
  MoveStrategy() = default;
 
  [[maybe_unused]] MoveStrategy(Int_precision const t_number_of_passes,
                                Int_precision const t_checkpoint)
      : m_passes{t_number_of_passes}, m_checkpoint{t_checkpoint}
  {}
 
  [[nodiscard]] auto passes() const { return m_passes; }
 
  [[nodiscard]] auto checkpoint() const { return m_checkpoint; }
 
  auto get_attempted() const { return m_attempted_moves; }
 
  auto get_succeeded() const { return m_successful_moves; }
 
  auto get_failed() const { return m_failed_moves; }
 
  auto operator()(ManifoldType const& t_manifold) -> ManifoldType
  {
#ifndef NDEBUG
    spdlog::debug("{} called.\n", __PRETTY_FUNCTION__);
#endif
    fmt::print("Starting Move Always algorithm in {}+1 dimensions ...\n",
               ManifoldType::dimension - 1);
 
    // Start the move command
    MoveCommand command(t_manifold);
 
    fmt::print("Making random moves ...\n");
 
    // Loop through passes
    for (auto pass_number = 1; pass_number <= m_passes; ++pass_number)
    {
      fmt::print("=== Pass {} ===\n", pass_number);
      auto total_simplices_this_pass = command.get_const_results().N3();
      // Make a random move per simplex
      for (auto move_attempt = 0; move_attempt < total_simplices_this_pass;
           ++move_attempt)
      {
        // Pick a move to attempt
        auto move_choice = utilities::generate_random_int(
            0, move_tracker::moves_per_dimension(ManifoldType::dimension) - 1);
#ifndef NDEBUG
        fmt::print("Move choice = {}\n", move_choice);
#endif
        if (move_choice == 0 && ManifoldType::dimension == 3)
        {
          command.enqueue(move_tracker::move_type::TWO_THREE);
        }
 
        if (move_choice == 1 && ManifoldType::dimension == 3)
        {
          command.enqueue(move_tracker::move_type::THREE_TWO);
        }
 
        if (move_choice == 2 && ManifoldType::dimension == 3)
        {
          command.enqueue(move_tracker::move_type::TWO_SIX);
        }
 
        if (move_choice == 3 && ManifoldType::dimension == 3)
        {
          command.enqueue(move_tracker::move_type::SIX_TWO);
        }
 
        if (move_choice == 4 && ManifoldType::dimension == 3)
        {
          command.enqueue(move_tracker::move_type::FOUR_FOUR);
        }
      }
      command.execute();
      // Update attempted, successful, and failed moves
      m_attempted_moves += command.get_attempted();
      m_successful_moves += command.get_succeeded();
      m_failed_moves += command.get_failed();
    }
    return command.get_results();
  }
 
  void print_results()
  {
    if (ManifoldType::dimension == 3)
    {
      fmt::print("=== Move Results ===\n");
      fmt::print("(2,3) moves: {} attempted = {} successful and {} failed.\n",
                 m_attempted_moves.two_three_moves(),
                 m_successful_moves.two_three_moves(),
                 m_failed_moves.two_three_moves());
      fmt::print("(3,2) moves: {} attempted = {} successful and {} failed.\n",
                 m_attempted_moves.three_two_moves(),
                 m_successful_moves.three_two_moves(),
                 m_failed_moves.three_two_moves());
      fmt::print("(2,6) moves: {} attempted = {} successful and {} failed.\n",
                 m_attempted_moves.two_six_moves(),
                 m_successful_moves.two_six_moves(),
                 m_failed_moves.two_six_moves());
      fmt::print("(6,2) moves: {} attempted = {} successful and {} failed.\n",
                 m_attempted_moves.six_two_moves(),
                 m_successful_moves.six_two_moves(),
                 m_failed_moves.six_two_moves());
      fmt::print("(4,4) moves: {} attempted = {} successful and {} failed.\n",
                 m_attempted_moves.four_four_moves(),
                 m_successful_moves.four_four_moves(),
                 m_failed_moves.four_four_moves());
    }
  }
};
 
using MoveAlways_3 =
    MoveStrategy<Strategies::MOVE_ALWAYS, manifolds::Manifold_3>;
using MoveAlways_4 =
    MoveStrategy<Strategies::MOVE_ALWAYS, manifolds::Manifold_4>;
 
#endif  // INCLUDE_MOVE_ALWAYS_HPP_