Manifold.hpp

Go to the documentation of this file.

/*******************************************************************************
 Causal Dynamical Triangulations in C++ using CGAL
 
 Copyright © 2018 Adam Getchell
 ******************************************************************************/

 
#ifndef CDT_PLUSPLUS_MANIFOLD_HPP
#define CDT_PLUSPLUS_MANIFOLD_HPP
 
#include <cstddef>
#include <type_traits>
#include <unordered_set>
 
#include "Geometry.hpp"
#include "Random.hpp"
 
namespace cdt::manifolds
{
  template <int dimension>
  [[nodiscard]] auto make_causal_vertices(
      std::span<Point_t<dimension> const> vertices,
      std::span<size_t const> const timevalues) -> Causal_vertices_t<dimension>
  {
    return foliated_triangulations::make_causal_vertices<dimension>(vertices,
                                                                    timevalues);
  }

  template <int dimension>
  class Manifold;

  template <>
  class [[nodiscard("This contains data!")]] Manifold<3>
  {
    using Triangulation = foliated_triangulations::FoliatedTriangulation_3;
    using Geometry      = Geometry_3;
 
    static_assert(std::is_nothrow_swappable_v<Triangulation>,
                  "Manifold swap requires a non-throwing triangulation swap.");
    static_assert(std::is_nothrow_swappable_v<Geometry>,
                  "Manifold swap requires a non-throwing geometry swap.");
    static_assert(
        std::is_nothrow_move_constructible_v<Triangulation> &&
            std::is_nothrow_move_constructible_v<Geometry>,
        "Manifold move construction requires non-throwing member moves.");
    Triangulation m_triangulation;

    Geometry m_geometry;
 
   public:
    static constexpr int dimension                     = 3;

    static constexpr Topology topology                 = Topology::SPHERICAL;

    ~Manifold()                                        = default;

    Manifold()                                         = default;

    Manifold(Manifold const& other)                    = default;

    auto operator=(Manifold const& other) -> Manifold& = default;

    Manifold(Manifold&& other) noexcept                = default;

    auto operator=(Manifold&& other) noexcept -> Manifold&
    {
      if (this != &other) { swap(other, *this); }
      return *this;
    }

    friend void swap(Manifold& swap_from, Manifold& swap_into) noexcept
    {
      using std::swap;
      swap(swap_from.m_triangulation, swap_into.m_triangulation);
      swap(swap_from.m_geometry, swap_into.m_geometry);
    }  // swap

    explicit Manifold(Triangulation t_foliated_triangulation)
        : m_triangulation{std::move(t_foliated_triangulation)}
        , m_geometry{m_triangulation}
    {}

    Manifold(Int_precision const t_desired_simplices,
             Int_precision const t_desired_timeslices, cdt::Random& generator,
             double const t_initial_radius    = INITIAL_RADIUS,
             double const t_foliation_spacing = FOLIATION_SPACING)
        : Manifold{
              Triangulation{t_desired_simplices, t_desired_timeslices,
                            generator, t_initial_radius, t_foliation_spacing}
    }
    {}

    Manifold(Int_precision const t_desired_simplices,
             Int_precision const t_desired_timeslices, cdt::Random&& generator,
             double const t_initial_radius    = INITIAL_RADIUS,
             double const t_foliation_spacing = FOLIATION_SPACING)
        : Manifold{t_desired_simplices, t_desired_timeslices, generator,
                   t_initial_radius, t_foliation_spacing}
    {}

    explicit Manifold(Causal_vertices_t<3> const& causal_vertices,
                      double const t_initial_radius    = INITIAL_RADIUS,
                      double const t_foliation_spacing = FOLIATION_SPACING)
        : Manifold{
              Triangulation{causal_vertices, t_initial_radius,
                            t_foliation_spacing}
    }
    {}

    [[nodiscard]] auto updated() const -> Manifold
    {
#ifndef NDEBUG
      spdlog::debug("{} called.\n", CDT_PRETTY_FUNCTION);
#endif
      if (m_triangulation.number_of_vertices() == 0) { return Manifold{}; }
      return Manifold{
          Triangulation{m_triangulation.delaunay_snapshot(),
                        m_triangulation.initial_radius(),
                        m_triangulation.foliation_spacing()}
      };
    }  // updated

    [[nodiscard]] auto delaunay_snapshot() const -> Delaunay_t<3>
    { return m_triangulation.delaunay_snapshot(); }

    [[nodiscard]] auto geometry() const -> Geometry const&
    { return m_geometry; }  // geometry

    [[nodiscard]] auto is_foliated() const -> bool
    { return m_triangulation.is_foliated(); }  // is_foliated

    [[nodiscard]] auto is_delaunay() const -> bool
    { return m_triangulation.is_delaunay(); }  // is_delaunay

    [[nodiscard]] auto is_valid() const -> bool
    { return m_triangulation.is_tds_valid(); }  // is_valid

    [[nodiscard]] auto is_structurally_correct() const -> bool
    { return m_triangulation.is_structurally_correct(); }

    [[nodiscard]] auto is_correct() const -> bool
    { return is_structurally_correct(); }  // is_correct

    [[nodiscard]] auto is_correct_with_diagnostics() const -> bool
    { return m_triangulation.is_correct_with_diagnostics(); }

    [[nodiscard]] auto dimensionality() const
    { return m_triangulation.dimension(); }

    [[nodiscard]] auto initial_radius() const
    { return m_triangulation.initial_radius(); }

    [[nodiscard]] auto foliation_spacing() const
    { return m_triangulation.foliation_spacing(); }

    [[nodiscard]] auto N3() const { return m_geometry.N3; }

    [[nodiscard]] auto N3_31() const { return m_geometry.N3_31; }

    [[nodiscard]] auto N3_22() const { return m_geometry.N3_22; }

    [[nodiscard]] auto N3_13() const { return m_geometry.N3_13; }

    [[nodiscard]] auto N3_31_13() const { return m_geometry.N3_31_13; }

    [[nodiscard]] auto simplices() const
    {
      return static_cast<Int_precision>(
          m_triangulation.number_of_finite_cells());
    }  // number_of_simplices

    [[nodiscard]] auto N2() const { return m_geometry.N2; }

    [[nodiscard]] auto spacelike_face_count(
        Int_precision const timevalue) const noexcept -> std::size_t
    { return m_triangulation.spacelike_face_count(timevalue); }

    [[nodiscard]] auto faces() const
    {
      return static_cast<Int_precision>(
          m_triangulation.number_of_finite_facets());
    }  // faces

    [[nodiscard]] auto N1() const { return m_geometry.N1; }

    [[nodiscard]] auto N1_SL() const { return m_triangulation.N1_SL(); }

    [[nodiscard]] auto N1_TL() const { return m_triangulation.N1_TL(); }

    [[nodiscard]] auto edges() const
    {
      return static_cast<Int_precision>(
          m_triangulation.number_of_finite_edges());
    }  // edges

    [[nodiscard]] auto N0() const { return m_geometry.N0; }

    [[nodiscard]] auto vertices() const
    {
      return static_cast<Int_precision>(m_triangulation.number_of_vertices());
    }  // vertices

    [[nodiscard]] auto min_time() const
    { return m_triangulation.min_time(); }  // min_time

    [[nodiscard]] auto max_time() const
    { return m_triangulation.max_time(); }  // max_time

    [[nodiscard]] auto check_simplices() const -> bool
    {
      return this->simplices() == this->N3() &&
             m_triangulation.check_all_cells();
    }  // check_simplices

    [[nodiscard]] auto check_vertices() const -> bool
    { return m_triangulation.check_all_vertices(); }

    void print_volume_per_timeslice() const
    {
      m_triangulation.print_volume_per_timeslice();
    }  // print_volume_per_timeslice

    void print_vertices() const { m_triangulation.print_vertices(); }

    void print_cells() const { m_triangulation.print_cells(); }

    void print() const
    try
    {
      fmt::print(
          "Manifold has {} vertices and {} edges and {} faces and {} "
          "simplices.\n",
          this->N0(), this->N1(), this->N2(), this->N3());
    }
    catch (...)
    {
      fmt::print(stderr, "print() went wrong ...\n");
      throw;
    }  // print

    void print_details() const
    try
    {
      fmt::print(
          "There are {} (3,1) simplices and {} (2,2) simplices and {} (1,3) "
          "simplices.\n",
          this->N3_31(), this->N3_22(), this->N3_13());
      fmt::print("There are {} timelike edges and {} spacelike edges.\n",
                 this->N1_TL(), this->N1_SL());
    }
    catch (...)
    {
      fmt::print(stderr, "print_details() went wrong ...\n");
      throw;
    }  // print_details
  };

  using Manifold_3 = Manifold<3>;
 
}  // namespace cdt::manifolds
 
#endif  // CDT_PLUSPLUS_MANIFOLD_HPP