Feature cmesh vertex connectivity

src/CMakeLists.txt

@@ -133,6 +133,9 @@ target_sources( T8 PRIVATE
     t8_cmesh/t8_cmesh_examples.cxx 
     t8_cmesh/t8_cmesh_helpers.cxx 
     t8_cmesh/t8_cmesh_offset.c 
+    t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_tree_to_vertex.cxx 
+    t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_vertex_to_tree.cxx 
+    t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_connectivity.cxx 
     t8_cmesh/t8_cmesh_readmshfile.cxx 
     t8_data/t8_shmem.c 
     t8_data/t8_containers.cxx 

src/Makefile.am

@@ -98,6 +98,9 @@ libt8_internal_headers = \
   src/t8_cmesh/t8_cmesh_trees.h src/t8_cmesh/t8_cmesh_partition.h \
   src/t8_cmesh/t8_cmesh_copy.h \
   src/t8_cmesh/t8_cmesh_offset.h \
+  src/t8_cmesh/t8_cmesh_vertex_connectivity.hxx \
+  src/t8_cmesh/t8_cmesh_vertex_conn_tree_to_vertex.hxx \
+  src/t8_cmesh/t8_cmesh_vertex_conn_vertex_to_tree.hxx \
   src/t8_vtk/t8_vtk_polydata.hxx \
   src/t8_vtk/t8_vtk_unstructured.hxx \
   src/t8_vtk/t8_vtk_parallel.hxx \
@@ -119,7 +122,10 @@ libt8_compiled_sources = \
   src/t8_cmesh/t8_cmesh_save.cxx \
   src/t8_cmesh/t8_cmesh_netcdf.c \
   src/t8_cmesh/t8_cmesh_trees.cxx src/t8_cmesh/t8_cmesh_commit.cxx \
-  src/t8_cmesh/t8_cmesh_partition.cxx\
+  src/t8_cmesh/t8_cmesh_vertex_conn_tree_to_vertex.cxx \
+  src/t8_cmesh/t8_cmesh_vertex_conn_vertex_to_tree.cxx \
+  src/t8_cmesh/t8_cmesh_vertex_connectivity.cxx \
+  src/t8_cmesh/t8_cmesh_partition.cxx \
   src/t8_cmesh/t8_cmesh_copy.c src/t8_data/t8_shmem.c \
   src/t8_cmesh/t8_cmesh_geometry.cxx \
   src/t8_cmesh/t8_cmesh_examples.cxx \

src/t8_cmesh/t8_cmesh.cxx

@@ -24,6 +24,7 @@
 #include <t8_cmesh.h>
 #include <t8_cmesh/t8_cmesh_geometry.h>
 #include <t8_geometry/t8_geometry_handler.hxx>
+#include <t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_connectivity.hxx>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_linear.h>
 #include <t8_geometry/t8_geometry_implementations/t8_geometry_linear_axis_aligned.h>
 #include <t8_schemes/t8_scheme.hxx>
@@ -204,6 +205,7 @@ t8_cmesh_init (t8_cmesh_t *pcmesh)
    * It will get initialized either when a geometry is registered
    * or when the cmesh gets committed. */
   cmesh->geometry_handler = NULL;
+  cmesh->vertex_connectivity = new t8_cmesh_vertex_connectivity ();
 
   T8_ASSERT (t8_cmesh_is_initialized (cmesh));
 }

src/t8_cmesh/t8_cmesh_commit.cxx

@@ -36,6 +36,7 @@
 #include <t8_cmesh/t8_cmesh_copy.h>
 #include <t8_cmesh/t8_cmesh_geometry.h>
 #include <t8_geometry/t8_geometry_handler.hxx>
+#include <t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_connectivity.hxx>
 
 typedef struct ghost_facejoins_struct
 {
@@ -582,6 +583,15 @@ t8_cmesh_commit (t8_cmesh_t cmesh, sc_MPI_Comm comm)
   }
   T8_ASSERT (cmesh->set_partition || cmesh->tree_offsets == NULL);
 
+  /* Build vertex_to_tree instance from the cmesh and a tree_to_vertex instance,
+   * but only if the vertex_to_tree instance is not yet committed
+   * and if the tree_to_vertex instance is not empty.
+   */
+  if (cmesh->vertex_connectivity->get_vertex_to_tree_state () == 0
+      && cmesh->vertex_connectivity->get_tree_to_vertex_state () == 1) {
+    cmesh->vertex_connectivity->build_vertex_to_tree (cmesh);
+  }
+
 #if T8_ENABLE_DEBUG
   t8_debugf ("Cmesh is %spartitioned.\n", cmesh->set_partition ? "" : "not ");
   if (cmesh->set_partition) {

src/t8_cmesh/t8_cmesh_types.h

@@ -27,6 +27,7 @@
 #include <t8_refcount.h>
 #include <t8_data/t8_shmem.h>
 #include <t8_geometry/t8_geometry.h>
+#include <t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_connectivity.h>
 #include "t8_cmesh_stash.h"
 #include "t8_element.h"
 
@@ -51,9 +52,10 @@ typedef struct t8_cprofile t8_cprofile_t; /* Defined below */
 /* Definitions for attribute identifiers that are reserved for a special purpose. 
  * T8_CMESH_NEXT_POSSIBLE_KEY is the first unused key, hence it can be repurposed for different attributes.*/
 #define T8_CMESH_VERTICES_ATTRIBUTE_KEY 0            /* Used to store vertex coordinates. */
-#define T8_CMESH_GEOMETRY_ATTRIBUTE_KEY 1            /* Used to store the name of a tree's geometry. */
-#define T8_CMESH_CAD_EDGE_ATTRIBUTE_KEY 2            /* Used to store which edge is linked to which geometry */
-#define T8_CMESH_CAD_EDGE_PARAMETERS_ATTRIBUTE_KEY 3 /* Used to store edge parameters */
+#define T8_CMESH_GLOBAL_VERTICES_ATTRIBUTE_KEY 1     /* Used to store global vertex ids. */
+#define T8_CMESH_GEOMETRY_ATTRIBUTE_KEY 2            /* Used to store the name of a tree's geometry. */
+#define T8_CMESH_CAD_EDGE_ATTRIBUTE_KEY 3            /* Used to store which edge is linked to which geometry */
+#define T8_CMESH_CAD_EDGE_PARAMETERS_ATTRIBUTE_KEY 4 /* Used to store edge parameters */
 #define T8_CMESH_CAD_FACE_ATTRIBUTE_KEY \
   T8_CMESH_CAD_EDGE_PARAMETERS_ATTRIBUTE_KEY \
   +T8_ECLASS_MAX_EDGES /* Used to store which face is linked to which surface */
@@ -137,6 +139,9 @@ typedef struct t8_cmesh
 
   t8_geometry_handler_c *geometry_handler; /**< Handles all geometries that are used by trees in this cmesh. */
 
+  struct t8_cmesh_vertex_connectivity
+    *vertex_connectivity; /**< Structure that manages tree_to_vertex and vertex_to_tree connectivity. */
+
 #if T8_ENABLE_DEBUG
   t8_locidx_t inserted_trees;  /**< Count the number of inserted trees to
                                            check at commit if it equals the total number. */

src/t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_tree_to_vertex.cxx

@@ -0,0 +1,93 @@
+/*
+  This file is part of t8code.
+  t8code is a C library to manage a collection (a forest) of multiple
+  connected adaptive space-trees of general element classes in parallel.
+
+  Copyright (C) 2025 the developers
+
+  t8code is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  t8code is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with t8code; if not, write to the Free Software Foundation, Inc.,
+  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/** \file t8_cmesh_conn_tree_to_vertex.cxx
+ *  This file implements the routines for the t8_cmesh_conn_tree_to_vertex struct.
+ */
+
+#include <t8_cmesh.h>
+#include <t8_cmesh/t8_cmesh_types.h>
+#include <t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_tree_to_vertex.hxx>
+
+/* constructor from a given vertex to tree list. */
+t8_cmesh_vertex_conn_tree_to_vertex::t8_cmesh_vertex_conn_tree_to_vertex (
+  const t8_cmesh_t cmesh_from, const t8_cmesh_t cmesh, const t8_cmesh_vertex_conn_vertex_to_tree &vtt)
+  : t8_cmesh_vertex_conn_tree_to_vertex ()
+{
+  T8_ASSERT (t8_cmesh_is_committed (cmesh_from));
+  T8_ASSERT (t8_cmesh_is_initialized (cmesh));
+  T8_ASSERT (vtt.is_committed ());
+
+  /* Since we need to collect all global ids of a tree before we can add the tree,
+   * we need a temporary buffer structure.
+   * Note that this is very memory intensive, doubling the required memory. */
+
+  const t8_locidx_t num_local_trees = t8_cmesh_get_num_local_trees (cmesh_from);
+  const t8_locidx_t num_ghosts = t8_cmesh_get_num_ghosts (cmesh_from);
+  const t8_locidx_t num_local_trees_and_ghosts = num_local_trees + num_ghosts;
+
+  /* Stores an array of local indices and mapped global vertices for each tree.
+   * We need to store the local indices as well, since they will not be
+   * sorted. Hence we need to sort later. */
+  using global_local_index_pair = std::pair<t8_gloidx_t, t8_locidx_t>;
+  std::vector<std::vector<global_local_index_pair>> global_ids_per_tree (num_local_trees_and_ghosts);
+
+  /* Iterate over all entries of the vertex to tree list. */
+  for (auto &[global_vertex, vertex_list] : vtt) {
+    /* Iterate over all entries of the vertex list,
+     * thus, each entry is a local tree id and vertex index. */
+    for (auto &[tree_index, vertex_index] : vertex_list) {
+      global_local_index_pair new_pair (global_vertex, vertex_index);
+      global_ids_per_tree[tree_index].push_back (new_pair);
+    }
+  }
+  /* Now sort the list and add the global indices of each tree. */
+  for (t8_locidx_t itree = 0; itree < num_local_trees_and_ghosts; ++itree) {
+    auto &tree_indices = global_ids_per_tree[itree];
+    /* Sort according to local index. */
+    std::sort (tree_indices.begin (), tree_indices.end (),
+               [] (global_local_index_pair &a, global_local_index_pair &b) { return a.second < b.second; });
+
+    /* Compute number of vertices of this tree. */
+    /* Get the trees class depending on whether it is a local tree or ghost. */
+    const t8_eclass_t tree_class = itree < num_local_trees
+                                     ? t8_cmesh_get_tree_class (cmesh_from, itree)
+                                     : t8_cmesh_get_ghost_class (cmesh_from, itree - num_local_trees);
+
+    const int num_tree_vertices = t8_eclass_num_vertices[tree_class];
+
+    /* Size of list must match number of tree vertices. */
+    SC_CHECK_ABORTF (
+      tree_indices.size () == (size_t) num_tree_vertices,
+      "ERROR. Number of mapped local tree vertices for tree %i does not equal number of tree vertices. %zu != %i\n",
+      itree, tree_indices.size (), num_tree_vertices);
+    /* We now build the array of global indices of this tree, sorted 
+     * by the trees local indices. */
+    t8_gloidx_t *global_tree_indices = T8_ALLOC (t8_gloidx_t, num_tree_vertices);
+    for (int ivertex = 0; ivertex < num_tree_vertices; ++ivertex) {
+      global_tree_indices[ivertex] = tree_indices[ivertex].first;
+    }
+    const t8_gloidx_t global_tree_id = t8_cmesh_get_global_id (cmesh_from, itree);
+    set_global_vertex_ids_of_tree_vertices (cmesh, global_tree_id, global_tree_indices, num_tree_vertices);
+    T8_FREE (global_tree_indices);
+  }
+}

src/t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_tree_to_vertex.hxx

@@ -0,0 +1,188 @@
+/*
+  This file is part of t8code.
+  t8code is a C library to manage a collection (a forest) of multiple
+  connected adaptive space-trees of general element classes in parallel.
+
+  Copyright (C) 2025 the developers
+
+  t8code is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  t8code is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with t8code; if not, write to the Free Software Foundation, Inc.,
+  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+*/
+
+/** \file t8_cmesh_vertex_conn_tree_to_vertex.hxx
+ * Class to save data structure for tree_to_vertex_lists of the cmesh.
+ * When the cmesh stores global vertex numbers, we require a lookup that
+ * matches a tree and its local vertex to a global vertex id.
+ * This lookup is encoded in the t8_cmesh_vertex_conn_tree_to_vertex struct.
+ */
+
+/* TODO:
+ *  It is probably best to set all global ids of a single tree as one attribute.
+ * That way we can store it as a single arrays of id's.
+ * We will probably most often want to access all ids of one tree, so a function returning an array of ids
+ * is a good idea anyway and if we already store them as such then we do not need to do any data movement
+ * when accessing.
+ *
+ * On the downside we will only have a "set all ids of a tree" function and no "set this single id for this tree and this vertex" function.
+ */
+
+#ifndef T8_CMESH_VERTEX_CONN_TREE_TO_VERTEX_HXX
+#define T8_CMESH_VERTEX_CONN_TREE_TO_VERTEX_HXX
+
+#include <algorithm>
+#include <t8_cmesh.h>
+#include <t8_cmesh/t8_cmesh_types.h>
+#include <t8_cmesh/t8_cmesh_vertex_connectivity/t8_cmesh_vertex_conn_vertex_to_tree.hxx>
+
+/* forward declaration of ttv class needed since the two class headers include each other. */
+class t8_cmesh_vertex_conn_vertex_to_tree;
+
+class t8_cmesh_vertex_conn_tree_to_vertex {
+ public:
+  /** Standard constructor. Does nothing. */
+  t8_cmesh_vertex_conn_tree_to_vertex (): state (EMPTY)
+  {
+  }
+
+  /** Constructor from a cmesh where all the attributes are set.
+   * Currently unclear if we implement this eventually.
+   * If we do so: Should the cmesh be already committed, or in pre-commit state but attributes set?
+   * 
+   * \note This function is not implemented yet.
+   */
+  t8_cmesh_vertex_conn_tree_to_vertex ([[maybe_unused]] const t8_cmesh_t cmesh)
+  {
+    // TODO: Remove the [[maybe unused]] qualifier when implemented
+    SC_ABORT ("not implemented.");
+  }
+
+  /** Constructor from a cmesh and a given vertex to tree connectivity.
+   *
+   * \param [in] cmesh_from A committed cmesh.
+   * \param [in] cmesh      An initialized but not committed cmesh that is to be derived from \a cmesh_from.
+   * \param [in] vtt        A committed vertex to tree connectivity for \a cmesh_from.
+   * 
+   * As a result a tree to vertec connectivity for \a cmesh will be constructed.
+   * \note \a cmesh_from must be committed.
+   * \note \a cmesh must not be committed.
+   * \note \a vtt must be committed.
+   * \note This does not work until issue #923 https://github.com/DLR-AMR/t8code/issues/923 is resolved.
+   */
+  t8_cmesh_vertex_conn_tree_to_vertex (const t8_cmesh_t cmesh_from, const t8_cmesh_t cmesh,
+                                       const struct t8_cmesh_vertex_conn_vertex_to_tree &vtt);
+
+  /* Setter functions */
+  /** Set all global vertex ids of a local tree.
+   * \param [in] cmesh The considered cmesh
+   * \param [in] local_tree A local tree id of \a cmesh
+   * \param [in] global_vertex_id The ids of the global vertices in order of \a local_tree's vertices.
+   * \param [in] num_vertices Must match the number of vertices of \a local_tree
+   *
+   * \note \a cmesh must not be committed.
+  */
+  inline void
+  set_global_vertex_ids_of_tree_vertices (const t8_cmesh_t cmesh, const t8_gloidx_t global_tree,
+                                          const t8_gloidx_t *global_tree_vertices, const int num_vertices)
+  {
+    T8_ASSERT (t8_cmesh_is_initialized (cmesh));
+    T8_ASSERT (num_vertices >= 0);
+    T8_ASSERT (global_tree_vertices != NULL);
+
+    /* TODO: we currently do not check whether the num_vertices argument
+    *       matches the number of vertices of the tree.
+    *       We cannot do it here, since this function call happens before commit,
+    *       thus we might not even know the eclass of the tree.
+    *       Maybe it is possible to check this during t8_cmesh_add_attributes?
+    */
+
+    /* We copy the data directly, hence set data_persiss to 0 */
+    const int data_persists = 0;
+    t8_debugf ("Setting %i global vertices for global tree %li.\n", num_vertices, global_tree);
+    t8_cmesh_set_attribute_gloidx_array (cmesh, global_tree, t8_get_package_id (),
+                                         T8_CMESH_GLOBAL_VERTICES_ATTRIBUTE_KEY, global_tree_vertices, num_vertices,
+                                         data_persists);
+    state = FILLED;
+  }
+
+  /* TODO: What if the attribute is not set? error handling */
+  /** Return the global vertex indices of a local tree.
+   * \param [in] cmesh A committed cmesh.
+   * \param [in] local_tree A local tree in \a cmesh.
+   * \param [in] num_vertices The count of local vertices of \a local_tree
+   * \return An array of length \a num_vertices containing the global vertex ids of \a local_tree's vertices.
+  */
+  inline const t8_gloidx_t *
+  get_global_vertices (const t8_cmesh_t cmesh, const t8_locidx_t local_tree, const int num_vertices) const
+  {
+    T8_ASSERT (t8_cmesh_is_committed (cmesh));
+
+#if T8_ENABLE_DEBUG
+    /* Verify that num_vertices matches the number of tree vertices */
+    const t8_eclass_t tree_class = t8_cmesh_get_tree_class (cmesh, local_tree);
+    const int num_tree_vertices = t8_eclass_num_vertices[tree_class];
+
+    T8_ASSERT (num_vertices == num_tree_vertices);
+#endif
+
+    t8_debugf ("Getting %i global vertices for local tree %i.\n", num_vertices, local_tree);
+    const t8_gloidx_t *global_vertices = t8_cmesh_get_attribute_gloidx_array (
+      cmesh, t8_get_package_id (), T8_CMESH_GLOBAL_VERTICES_ATTRIBUTE_KEY, local_tree, num_vertices);
+    T8_ASSERT (global_vertices != NULL);
+    return global_vertices;
+  }
+
+  /* TODO: What if the attribute is not set? error handling */
+  /** Return a single global vertex id of a single local vertex.
+   * 
+   * 
+   * \param [in] cmesh A committed cmesh.
+   * \param [in] local_tree A local tree of \a cmesh.
+   * \param [in] local_tree_vertex A local vertex of \a local_tree
+   * \param [in] num_tree_vertices The count of vertices of \a local_tree
+   * \return The global id of the local vertex \a local_tree_vertex of \a local_tree. 
+   */
+  t8_gloidx_t
+  get_global_vertex (const t8_cmesh_t cmesh, const t8_locidx_t local_tree, const int local_tree_vertex,
+                     const int num_tree_vertices) const
+  {
+    T8_ASSERT (t8_cmesh_is_committed (cmesh));
+
+    /* Verify that local_tree_vertex is in fact a local vertex of the tree */
+    /* Note: We only perform this check in debugging mode.
+    *       In non-debugging mode, using a vertex index beyond the trees index allows
+    *       for a potential attacker to gain access to memory possibly not owned by the caller.
+    *       We do not check in non-debugging mode for (obvious) performance reasons. */
+    T8_ASSERT (0 <= local_tree_vertex);
+    T8_ASSERT (local_tree_vertex < num_tree_vertices);
+
+    return get_global_vertices (cmesh, local_tree, num_tree_vertices)[local_tree_vertex];
+  }
+
+  friend struct t8_cmesh_vertex_connectivity;
+
+ private:
+  enum state {
+    EMPTY, /*< Is initialized but empty. */
+    FILLED /*< Is filled with at least one entry. */
+  } state;
+
+  /** Return the state of this object. */
+  inline enum state
+  get_state ()
+  {
+    return state;
+  }
+};
+
+#endif /* !T8_CMESH_VERTEX_CONN_TREE_TO_VERTEX_HXX */