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 <unordered_set>
 
#include "Geometry.hpp"
 
namespace manifolds
{
  template <int dimension>
  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;
 
    Triangulation m_triangulation;
 
    Geometry m_geometry;
 
   public:
    static int constexpr dimension          = 3;
 
    static topology_type constexpr topology = topology_type::SPHERICAL;
 
    ~Manifold()                             = default;
 
    Manifold()                              = default;
 
    Manifold(Manifold const& other)         = default;
 
    auto operator=(Manifold const& other) -> Manifold& = default;
 
    Manifold(Manifold&& other)                         = default;
 
    auto operator=(Manifold&& other) -> Manifold&      = default;
 
    friend void swap(Manifold& swap_from, Manifold& swap_into) noexcept
    {
#ifndef NDEBUG
      spdlog::debug("{} called.\n", __PRETTY_FUNCTION__);
#endif
      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{get_triangulation()}
    {}
 
    Manifold(Int_precision const t_desired_simplices,
             Int_precision const t_desired_timeslices,
             double const        t_initial_radius    = INITIAL_RADIUS,
             double const        t_foliation_spacing = FOLIATION_SPACING)
        : Manifold{
              Triangulation{t_desired_simplices, t_desired_timeslices,
                            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}
    }
    {}
 
    void update()
    try
    {
#ifndef NDEBUG
      spdlog::debug("{} called.\n", __PRETTY_FUNCTION__);
#endif
      update_triangulation();
      update_geometry();
    }
    catch (std::system_error const& ex)
    {
      spdlog::trace("Exception thrown: {}\n", ex.what());
    }  // update
 
    [[nodiscard]] auto get_triangulation() const noexcept
        -> Triangulation const&
    {
      return std::cref(m_triangulation);
    }  // get_triangulation
 
    [[nodiscard]] auto get_delaunay() const noexcept
    {
      return get_triangulation().get_delaunay();
    }  // get_delaunay
 
    [[nodiscard]] auto triangulation() -> Triangulation&
    {
      return m_triangulation;
    }  // triangulation
 
    [[nodiscard]] auto get_geometry() const -> Geometry const&
    {
      return m_geometry;
    }  // get_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_correct() const -> bool
    {
      return m_triangulation.is_correct();
    }  // is_correct
 
    template <typename VertexType>
    [[nodiscard]] auto is_vertex(VertexType&& t_vertex_candidate) const -> bool
    {
      return m_triangulation.get_delaunay().is_vertex(
          std::forward<VertexType>(t_vertex_candidate));
    }  // is_vertex
 
    [[nodiscard]] auto is_edge(
        Edge_handle_t<3> const& t_edge_candidate) const noexcept -> bool
    {
      return m_triangulation.get_delaunay().tds().is_edge(
          t_edge_candidate.first, t_edge_candidate.second,
          t_edge_candidate.third);
    }  // is_edge
 
    [[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.get_cells().size());
    }  // number_of_simplices
 
    [[nodiscard]] auto N2() const { return m_geometry.N2; }
 
    [[nodiscard]] auto N2_SL() const -> auto const&
    {
      return m_triangulation.N2_SL();
    }  // N2_SL
 
    [[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
 
    template <typename VertexHandle>
    [[nodiscard]] auto degree(VertexHandle&& t_vertex) const -> decltype(auto)
    {
      return m_triangulation.degree(std::forward<VertexHandle>(t_vertex));
    }  // degree
 
    template <typename... Ts>
    [[nodiscard]] auto incident_cells(Ts&&... args) const noexcept
        -> decltype(auto)
    {
      return m_triangulation.incident_cells(std::forward<Ts>(args)...);
    }  // incident_cells
 
    [[nodiscard]] auto get_timelike_edges() const noexcept -> auto const&
    {
      return m_triangulation.get_timelike_edges();
    }  // get_timelike_edges
 
    [[nodiscard]] auto get_spacelike_edges() const -> auto const&
    {
      return m_triangulation.get_spacelike_edges();
    }  // get_spacelike_edges
 
    [[nodiscard]] auto get_vertices() const noexcept -> auto const&
    {
      return m_triangulation.get_vertices();
    }  // get_vertices
 
    [[nodiscard]] auto get_vertices_span() const noexcept -> auto
    {
      return m_triangulation.get_vertices_span();
    }  // get_vertices_span
 
    [[nodiscard]] auto check_simplices() const -> bool
    {
      return this->simplices() == this->N3() &&
             m_triangulation.check_all_cells();
    }  // check_simplices
 
    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
 
    auto get_vertex(Point_t<3> const& point) const -> Vertex_handle_t<3>
    {
      Vertex_handle_t<3> result;
      m_triangulation.get_delaunay().is_vertex(point, result);
      return result;
    }  // get_vertex
 
    auto get_cell(Vertex_handle_t<3> const& vh1, Vertex_handle_t<3> const& vh2,
                  Vertex_handle_t<3> const& vh3,
                  Vertex_handle_t<3> const& vh4) const -> Cell_handle_t<3>
    {
      Cell_handle_t<3> result;
      m_triangulation.get_delaunay().is_cell(vh1, vh2, vh3, vh4, result);
      return result;
    }  // get_cell_handle
 
   private:
    void update_triangulation()
    try
    {
#ifndef NDEBUG
      spdlog::debug("{} called.\n", __PRETTY_FUNCTION__);
#endif
      // Constructing a new triangulation updates all data structures
      Triangulation local_triangulation(m_triangulation.get_delaunay());
      swap(local_triangulation, m_triangulation);
    }
    catch (std::system_error const& ex)
    {
      fmt::print("Exception thrown: {}\n", ex.what());
    }  // update_triangulation
 
    void update_geometry() noexcept
    {
#ifndef NDEBUG
      spdlog::debug("{} called.\n", __PRETTY_FUNCTION__);
#endif
      // constructing a new geometry updates all data structures
      Geometry geom(m_triangulation);
      swap(geom, m_geometry);
    }  // update_geometry
  };
 
  using Manifold_3 = Manifold<3>;
 
  template <>
  class [[nodiscard("This contains data!")]] Manifold<4>
  {
    Geometry_4 m_geometry;
 
   public:
    static int constexpr dimension          = 4;
 
    static topology_type constexpr topology = topology_type::SPHERICAL;
  };
 
  using Manifold_4 = Manifold<4>;
 
}  // namespace manifolds
 
#endif  // CDT_PLUSPLUS_MANIFOLD_HPP