Start improving wmtk tests.

Author: daniel-zint

src/wmtk/TetMesh.cpp

@@ -19,9 +19,15 @@ int wmtk::TetMesh::get_next_empty_slot_t()
             }
             tet_connectivity_synchronizing_flag = true;
             auto current_capacity = m_tet_connectivity.size();
-            p_edge_attrs->resize(2 * current_capacity * 6);
-            p_face_attrs->resize(2 * current_capacity * 4);
-            p_tet_attrs->resize(2 * current_capacity);
+            if (p_edge_attrs) {
+                p_edge_attrs->resize(2 * current_capacity * 6);
+            }
+            if (p_face_attrs) {
+                p_face_attrs->resize(2 * current_capacity * 4);
+            }
+            if (p_tet_attrs) {
+                p_tet_attrs->resize(2 * current_capacity);
+            }
             m_tet_connectivity.grow_to_at_least(2 * current_capacity);
             tet_connectivity_synchronizing_flag = false;
             tet_connectivity_lock.unlock();
@@ -46,7 +52,9 @@ int wmtk::TetMesh::get_next_empty_slot_v()
             }
             vertex_connectivity_synchronizing_flag = true;
             auto current_capacity = m_vertex_connectivity.size();
-            p_vertex_attrs->resize(2 * current_capacity);
+            if (p_vertex_attrs) {
+                p_vertex_attrs->resize(2 * current_capacity);
+            }
             resize_vertex_mutex(2 * current_capacity);
             m_vertex_connectivity.grow_to_at_least(2 * current_capacity);
             vertex_connectivity_synchronizing_flag = false;
@@ -84,10 +92,18 @@ void wmtk::TetMesh::init(size_t n_vertices, const std::vector<std::array<size_t,
     m_vertex_mutex.grow_to_at_least(n_vertices);
 
     // resize attributes
-    p_vertex_attrs->resize(n_vertices);
-    p_tet_attrs->resize(tets.size());
-    p_face_attrs->resize(4 * tets.size());
-    p_edge_attrs->resize(6 * tets.size());
+    if (p_vertex_attrs) {
+        p_vertex_attrs->resize(n_vertices);
+    }
+    if (p_tet_attrs) {
+        p_tet_attrs->resize(tets.size());
+    }
+    if (p_face_attrs) {
+        p_face_attrs->resize(4 * tets.size());
+    }
+    if (p_edge_attrs) {
+        p_edge_attrs->resize(6 * tets.size());
+    }
 }
 
 void wmtk::TetMesh::init_with_isolated_vertices(
@@ -116,10 +132,34 @@ void wmtk::TetMesh::init_with_isolated_vertices(
     m_vertex_mutex.grow_to_at_least(n_vertices);
 
     // resize attributes
-    p_vertex_attrs->resize(n_vertices);
-    p_tet_attrs->resize(tets.size());
-    p_face_attrs->resize(4 * tets.size());
-    p_edge_attrs->resize(6 * tets.size());
+    if (p_vertex_attrs) {
+        p_vertex_attrs->resize(n_vertices);
+    }
+    if (p_tet_attrs) {
+        p_tet_attrs->resize(tets.size());
+    }
+    if (p_face_attrs) {
+        p_face_attrs->resize(4 * tets.size());
+    }
+    if (p_edge_attrs) {
+        p_edge_attrs->resize(6 * tets.size());
+    }
+}
+
+void wmtk::TetMesh::init(const MatrixXi& T)
+{
+    size_t n_vertices = T.maxCoeff() + 1;
+
+    std::vector<std::array<size_t, 4>> tets;
+    tets.resize(T.rows());
+
+    for (int i = 0; i < T.rows(); ++i) {
+        for (int j = 0; j < 4; ++j) {
+            tets[i][j] = T(i, j);
+        }
+    }
+
+    TetMesh::init(n_vertices, tets);
 }
 
 
@@ -618,7 +658,9 @@ void wmtk::TetMesh::consolidate_mesh()
         if (v_cnt != i) {
             assert(v_cnt < i);
             m_vertex_connectivity[v_cnt] = m_vertex_connectivity[i];
-            p_vertex_attrs->move(i, v_cnt);
+            if (p_vertex_attrs) {
+                p_vertex_attrs->move(i, v_cnt);
+            }
         }
         for (size_t& t_id : m_vertex_connectivity[v_cnt].m_conn_tets) t_id = map_t_ids[t_id];
         v_cnt++;
@@ -631,13 +673,19 @@ void wmtk::TetMesh::consolidate_mesh()
             assert(t_cnt < i);
             m_tet_connectivity[t_cnt] = m_tet_connectivity[i];
             m_tet_connectivity[t_cnt].hash = 0;
-            p_tet_attrs->move(i, t_cnt);
+            if (p_tet_attrs) {
+                p_tet_attrs->move(i, t_cnt);
+            }
 
-            for (auto j = 0; j < 4; j++) {
-                p_face_attrs->move(i * 4 + j, t_cnt * 4 + j);
+            if (p_face_attrs) {
+                for (auto j = 0; j < 4; j++) {
+                    p_face_attrs->move(i * 4 + j, t_cnt * 4 + j);
+                }
             }
-            for (auto j = 0; j < 6; j++) {
-                p_edge_attrs->move(i * 6 + j, t_cnt * 6 + j);
+            if (p_edge_attrs) {
+                for (auto j = 0; j < 6; j++) {
+                    p_edge_attrs->move(i * 6 + j, t_cnt * 6 + j);
+                }
             }
         }
         for (size_t& v_id : m_tet_connectivity[t_cnt].m_indices) v_id = map_v_ids[v_id];

src/wmtk/TetMesh.h

@@ -3,6 +3,7 @@
 #include <wmtk/utils/VectorUtils.h>
 #include <type_traits>
 #include <wmtk/AttributeCollection.hpp>
+#include <wmtk/Types.hpp>
 #include <wmtk/utils/Logger.hpp>
 
 #include <tbb/concurrent_vector.h>
@@ -352,6 +353,13 @@ class TetMesh
         size_t n_vertices,
         const std::vector<std::array<size_t, 4>>& tets);
 
+    /**
+     * @brief Generate the connectivity of the mesh from an IGL-style T matrix.
+     *
+     * @param #T by 4 list of vertex indices.
+     */
+    void init(const MatrixXi& T);
+
     /**
      * Split an edge
      *
@@ -489,7 +497,10 @@ class TetMesh
     using vector = tbb::concurrent_vector<T>;
 
 public:
-    AbstractAttributeContainer *p_vertex_attrs, *p_edge_attrs, *p_face_attrs, *p_tet_attrs;
+    AbstractAttributeContainer* p_vertex_attrs = nullptr;
+    AbstractAttributeContainer* p_edge_attrs = nullptr;
+    AbstractAttributeContainer* p_face_attrs = nullptr;
+    AbstractAttributeContainer* p_tet_attrs = nullptr;
     // AbstractAttributeContainer vertex_attrs, edge_attrs, face_attrs, tet_attrs;
 
 

src/wmtk/TriMesh.h

@@ -12,7 +12,6 @@
 #include <wmtk/utils/EnableWarnings.hpp>
 // clang-format on
 
-#include <Eigen/Core>
 #include <algorithm>
 #include <array>
 #include <cassert>
@@ -253,14 +252,6 @@ class TriMesh
      */
     std::vector<Tuple> get_vertices() const;
 
-    /**
-     * Generate a vector of Tuples from global face index
-     * @note Local vid is the first of the m_idices
-     * Local eid assigned counter clockwise as in the ilustrated example
-     * @return vector of Tuples refering to each face
-     */
-    std::vector<Tuple> get_faces() const;
-
     /**
      * Generate a vector of Tuples for each edge
      * @note ensures the fid assigned is the smallest between faces adjacent to the
@@ -269,6 +260,14 @@ class TriMesh
      */
     std::vector<Tuple> get_edges() const;
 
+    /**
+     * Generate a vector of Tuples from global face index
+     * @note Local vid is the first of the m_idices
+     * Local eid assigned counter clockwise as in the ilustrated example
+     * @return vector of Tuples refering to each face
+     */
+    std::vector<Tuple> get_faces() const;
+
     /**
      * Generate a tuple using local vid and global fid
      * @param vid1, vid2 are local vids

src/wmtk/utils/examples/TetMesh_examples.cpp

@@ -0,0 +1,146 @@
+#include "TetMesh_examples.hpp"
+
+namespace wmtk::utils::examples::tet {
+
+TetMeshVT single_tet()
+{
+    TetMeshVT m;
+    auto& V = m.V;
+    auto& T = m.T;
+
+    T.resize(1, 4);
+    T.row(0) << 0, 1, 2, 3;
+
+    V.resize(4, 3);
+    V.row(0) << 0, 0, 0;
+    V.row(1) << 0, 0, 1;
+    V.row(2) << 0, 1, 0;
+    V.row(3) << 1, 0, 0;
+
+    return m;
+}
+
+TetMeshVT two_tets()
+{
+    TetMeshVT m;
+    auto& V = m.V;
+    auto& T = m.T;
+
+    T.resize(2, 4);
+    T.row(0) << 0, 1, 2, 3;
+    T.row(1) << 0, 2, 3, 4;
+
+    // TODO check if positions make sense
+    V.resize(5, 3);
+    V.row(0) << 0, 0, 0;
+    V.row(1) << 0, 0, 1;
+    V.row(2) << 0, 1, 0;
+    V.row(3) << 1, 0, 0;
+    V.row(4) << 1, 1, 1;
+
+    return m;
+}
+
+// TetMeshVT two_ears()
+// {
+//     TetMesh m;
+//     RowVectors4l tets;
+//     tets.resize(3, 4);
+//     tets.row(0) << 0, 1, 2, 3;
+//     tets.row(1) << 0, 2, 3, 4;
+//     tets.row(2) << 0, 1, 3, 5;
+//     m.initialize(tets);
+//     return m;
+// }
+
+TetMeshVT three_incident_tets()
+{
+    TetMeshVT m;
+    auto& V = m.V;
+    auto& T = m.T;
+
+    T.resize(3, 4);
+    T.row(0) << 0, 1, 2, 3;
+    T.row(1) << 0, 2, 3, 4;
+    T.row(2) << 2, 5, 3, 4;
+
+    V.resize(6, 3);
+    V.row(0) = Eigen::Vector3d(-4., 0., 0);
+    V.row(1) = Eigen::Vector3d(2., 2., 0);
+    V.row(2) = Eigen::Vector3d(0., 2., 0);
+    V.row(3) = Eigen::Vector3d(0., 1, 1);
+    V.row(4) = Eigen::Vector3d(0., 1, -1);
+    V.row(5) = Eigen::Vector3d(1., 1, -1);
+
+    return m;
+}
+
+TetMeshVT six_cycle_tets()
+{
+    //        0 ---------- 4
+    //       / \\        // \ .
+    //      /   \ \     //   \ .
+    //     /     \  \  //     \ .
+    //    /       \   \3       \ .
+    //  1 --------- 2/ -------- 5   tuple edge 2-3
+    //    \       /  /\ \      / .
+    //     \     / /   \\     / .
+    //      \   //      \\   / .
+    //       \ //        \  / .
+    //        6 -----------7
+    //
+
+    TetMeshVT m;
+    auto& V = m.V;
+    auto& T = m.T;
+
+    T.resize(6, 4);
+    T.row(0) << 0, 1, 2, 3;
+    T.row(1) << 0, 2, 3, 4;
+    T.row(2) << 2, 5, 3, 4;
+    T.row(3) << 6, 1, 2, 3;
+    T.row(4) << 6, 2, 3, 7;
+    T.row(5) << 7, 2, 3, 5;
+
+    V.resize(8, 3);
+    V.row(2) = Eigen::Vector3d(0, 0, -1);
+    V.row(3) = Eigen::Vector3d(0, 0, 1);
+
+    V.row(1) = Eigen::Vector3d(-1, 0, 0);
+    V.row(5) = Eigen::Vector3d(1, 0, 0);
+
+    V.row(0) = Eigen::Vector3d(1, -1, 0);
+    V.row(7) = Eigen::Vector3d(-1, 1, 0);
+
+    V.row(4) = Eigen::Vector3d(1, 1, 0);
+    V.row(6) = Eigen::Vector3d(-1, -1, 0);
+
+    return m;
+}
+
+// TetMeshVT three_cycle_tets()
+// {
+//     TetMesh m;
+//     RowVectors4l tets;
+//     tets.resize(3, 4);
+//     tets.row(0) << 0, 1, 2, 4;
+//     tets.row(1) << 0, 1, 4, 3;
+//     tets.row(2) << 0, 1, 3, 2;
+//     m.initialize(tets);
+//     return m;
+// }
+
+// TetMeshVT four_cycle_tets()
+// {
+//     TetMesh m;
+//     RowVectors4l tets;
+//     tets.resize(4, 4);
+//     tets.row(0) << 0, 1, 3, 4;
+//     tets.row(1) << 0, 1, 4, 5;
+//     tets.row(2) << 0, 1, 5, 2;
+//     tets.row(3) << 0, 1, 2, 3;
+//     m.initialize(tets);
+//     return m;
+// }
+
+} // namespace wmtk::utils::examples::tet