Utilities.hpp

Go to the documentation of this file.

/*******************************************************************************
 Causal Dynamical Triangulations in C++ using CGAL
 
 Copyright © 2017 Adam Getchell
 ******************************************************************************/
 
 
#ifndef INCLUDE_UTILITIES_HPP_
#define INCLUDE_UTILITIES_HPP_
 
#include <filesystem>
#include <fstream>
#include <gsl/gsl>
#include <mutex>
#include <random>
#include <span>
#include <stdexcept>
#include <string>
// H. Hinnant date and time library
#include <date/tz.h>
 
// #include <format>
 
// M. O'Neill Permutation Congruential Generator library
#include "pcg_random.hpp"
 
// V. Zverovich {fmt} library
#include <fmt/ostream.h>
 
// G. Melman spdlog library
#include <spdlog/sinks/basic_file_sink.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/spdlog.h>
 
// Global project settings
#include "Settings.hpp"
 
enum class topology_type
{
  TOROIDAL,
  SPHERICAL
};
 
inline auto operator<<(std::ostream&        t_os,
                       topology_type const& t_topology) -> std::ostream&
{
  switch (t_topology)
  {
    case topology_type::SPHERICAL: return t_os << "spherical";
    case topology_type::TOROIDAL: return t_os << "toroidal";
    default: return t_os << "none";
  }
}  // operator<<
 
namespace utilities
{
  [[nodiscard]] inline auto current_date_time()
  {
    //    auto time = std::chrono::zoned_time(std::chrono::current_zone(),
    //    std::chrono::system_clock::now());
    //    return std::formatter<std::chrono::system_clock::time_point,
    //                          char>::format(time, "{:%Y-%m-%d.%X%Z}");
    date::zoned_time const time(date::current_zone(),
                                std::chrono::system_clock::now());
    return format("%Y-%m-%d.%X%Z", time);
  }  // current_date_time
 
  [[nodiscard]] inline auto make_filename(
      topology_type const& t_topology, Int_precision t_dimension,
      Int_precision t_number_of_simplices, Int_precision t_number_of_timeslices,
      double t_initial_radius,
      double t_foliation_spacing) noexcept -> std::filesystem::path
  {
    std::string filename;
    if (t_topology == topology_type::SPHERICAL) { filename += "S"; }
    else { filename += "T"; }
    // std::to_string() works in C++11, but not earlier
    filename += std::to_string(t_dimension);
 
    filename += "-";
 
    filename += std::to_string(t_number_of_timeslices);
 
    filename += "-";
 
    filename += std::to_string(t_number_of_simplices);
 
    filename += "-I";
 
    filename += std::to_string(t_initial_radius);
 
    filename += "-R";
 
    filename += std::to_string(t_foliation_spacing);
 
    // Append current time
    filename += "-";
    filename += current_date_time();
 
    // Append .off file extension
    filename += ".off";
    return filename;
  }  // make_filename
 
  template <typename ManifoldType>
  [[nodiscard]] auto make_filename(ManifoldType const& manifold)
  {
    return make_filename(ManifoldType::topology, ManifoldType::dimension,
                         manifold.N3(), manifold.max_time(),
                         manifold.initial_radius(),
                         manifold.foliation_spacing());
  }  // make_filename
 
  template <typename TriangulationType>
  void print_delaunay(TriangulationType const& t_triangulation)
  {
    fmt::print(
        "Triangulation has {} vertices and {} edges and {} faces and {} "
        "simplices.\n",
        t_triangulation.number_of_vertices(),
        t_triangulation.number_of_finite_edges(),
        t_triangulation.number_of_finite_facets(),
        t_triangulation.number_of_finite_cells());
  }  // print_delaunay
 
  template <typename TriangulationType>
  void write_file(std::filesystem::path const& filename,
                  TriangulationType            triangulation)
  {
    static std::mutex mutex;
    fmt::print("Writing to file {}\n", filename.string());
    std::scoped_lock const lock(mutex);
    std::ofstream          file(filename, std::ios::out);
    if (!file.is_open())
    {
      throw std::filesystem::filesystem_error(
          "Could not open file for writing", filename,
          std::make_error_code(std::errc::bad_file_descriptor));
    }
    file << triangulation;
  }  // write_file
 
  template <typename ManifoldType>
  void write_file(ManifoldType const& t_universe)
  {
    std::filesystem::path filename;
    filename.assign(make_filename(t_universe));
    write_file(filename, t_universe.get_delaunay());
  }  // write_file
 
  template <typename TriangulationType>
  auto read_file(std::filesystem::path const& filename) -> TriangulationType
  {
    static std::mutex mutex;
    fmt::print("Reading from file {}\n", filename.string());
    std::scoped_lock const lock(mutex);
    std::ifstream          file(filename, std::ios::in);
    if (!file.is_open())
    {
      throw std::filesystem::filesystem_error(
          "Could not open file for reading", filename,
          std::make_error_code(std::errc::bad_file_descriptor));
    }
    TriangulationType triangulation;
    file >> triangulation;
    return triangulation;
  }  // read_file
 
  [[nodiscard]] inline auto die_roll() noexcept
  {
    pcg_extras::seed_seq_from<std::random_device> seed_source;
 
    // Make a random number generator
    pcg64 rng(seed_source);
 
    // Choose random number from 1 to 6
    std::uniform_int_distribution uniform_dist(1, 6);  // NOLINT
    Int_precision const           roll = uniform_dist(rng);
    return roll;
  }  // die_roll()
 
  template <typename NumberType, class Distribution>
  [[nodiscard]] auto generate_random(NumberType t_min_value,
                                     NumberType t_max_value) noexcept
  {
    pcg_extras::seed_seq_from<std::random_device> seed_source;
    // Make a random number generator
    pcg64        generator(seed_source);
    Distribution distribution(t_min_value, t_max_value);
    return distribution(generator);
  }  // generate_random()
 
  inline auto make_random_generator() noexcept
  {
    pcg_extras::seed_seq_from<std::random_device> seed_source;
    pcg64                                         generator(seed_source);
    return generator;
  }  // make_random_generator()
 
  template <typename IntegerType>
  [[nodiscard]] auto constexpr generate_random_int(
      IntegerType t_min_value, IntegerType t_max_value) noexcept
  {
    using int_dist = std::uniform_int_distribution<IntegerType>;
    return generate_random<IntegerType, int_dist>(t_min_value, t_max_value);
  }  // generate_random_int()
 
  template <typename IntegerType>
  [[nodiscard]] auto generate_random_timeslice(
      IntegerType&& t_max_timeslice) noexcept -> decltype(auto)
  {
    return generate_random_int(static_cast<IntegerType>(1),
                               std::forward<IntegerType>(t_max_timeslice));
  }  // generate_random_timeslice()
 
  template <typename FloatingPointType>
  [[nodiscard]] auto constexpr generate_random_real(
      FloatingPointType t_min_value, FloatingPointType t_max_value) noexcept
  {
    using real_dist = std::uniform_real_distribution<FloatingPointType>;
    return generate_random<FloatingPointType, real_dist>(t_min_value,
                                                         t_max_value);
  }  // generate_random_real()
 
  [[nodiscard]] auto constexpr generate_probability() noexcept
  {
    auto constexpr min = 0.0L;
    auto constexpr max = 1.0L;
    return generate_random_real(min, max);
  }  // generate_probability()
 
  inline auto expected_points_per_timeslice(
      Int_precision const t_dimension, Int_precision t_number_of_simplices,
      Int_precision t_number_of_timeslices)
  {
#ifndef NDEBUG
    spdlog::debug("{} simplices on {} timeslices desired.\n",
                  t_number_of_simplices, t_number_of_timeslices);
#endif
 
    auto const simplices_per_timeslice =
        t_number_of_simplices / t_number_of_timeslices;
    if (t_dimension == 3)
    {
      // Avoid segfaults for small values
      if (t_number_of_simplices == t_number_of_timeslices)
      {
        return 2 * simplices_per_timeslice;
      }
      if (t_number_of_simplices < 1000)  // NOLINT
      {
        return static_cast<Int_precision>(
            0.4L *  // NOLINT
            static_cast<long double>(simplices_per_timeslice));
      }
      if (t_number_of_simplices < 10000)  // NOLINT
      {
        return static_cast<Int_precision>(
            0.2L *  // NOLINT
            static_cast<long double>(simplices_per_timeslice));
      }
      if (t_number_of_simplices < 100000)  // NOLINT
      {
        return static_cast<Int_precision>(
            0.15L *  // NOLINT
            static_cast<long double>(simplices_per_timeslice));
      }
 
      return static_cast<Int_precision>(
          0.1L * static_cast<long double>(simplices_per_timeslice));  // NOLINT
    }
    throw std::invalid_argument("Currently, dimensions cannot be >3.");
 
  }  // expected_points_per_timeslice
 
  [[nodiscard]] inline auto Gmpzf_to_double(Gmpzf const& t_value) -> double
  {
    return t_value.to_double();
  }  // Gmpzf_to_double
 
  inline void create_logger()
  try
  {
    auto const console_sink =
        std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
    console_sink->set_level(spdlog::level::info);
 
    auto const debug_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(
        "logs/debug-log.txt", true);
    debug_sink->set_level(spdlog::level::debug);
 
    auto const trace_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(
        "logs/trace-log.txt", true);
    trace_sink->set_level(spdlog::level::trace);
 
    spdlog::sinks_init_list sink_list = {console_sink, debug_sink, trace_sink};
 
    auto const              logger    = std::make_shared<spdlog::logger>(
        "multi_sink", sink_list.begin(), sink_list.end());
    // This allows the logger to capture all events
    logger->set_level(spdlog::level::trace);
    // The sinks will filter items further via should_log()
    logger->info("Multi-sink logger initialized.\n");
    logger->debug("Debug logger initialized.\n");
    logger->trace("Trace logger initialized.\n");
    logger->debug(
        "You must build in Debug mode for anything to be recorded in this "
        "file.\n");
 
    register_logger(logger);
    set_default_logger(logger);
  }
  catch (spdlog::spdlog_ex const& ex)
  {
    // Use default logger
    spdlog::error("Logger initialization failed: {}\n", ex.what());
    spdlog::warn("Default logger set.\n");
 
  }  // create_logger
 
  template <typename Point>
  auto point_to_str(Point const& t_point) -> std::string
  {
    std::stringstream stream;
    stream << t_point;
    return stream.str();
  }  // point_to_str
 
  inline auto topology_to_str(topology_type const& t_topology) -> std::string
  {
    std::stringstream stream;
    stream << t_topology;
    return stream.str();
  }  // topology_to_str
}  // namespace utilities
#endif  // INCLUDE_UTILITIES_HPP_