update builds

src/wmtk/multimesh/MultiMeshVisitor.hpp

@@ -56,6 +56,7 @@ class MultiMeshVisitor
             execute_PT<PrimitiveType::Tetrahedron>(mesh, simplex);
             break;
         }
+        default: throw "notimplemented"; break;
         }
     }
 
@@ -133,6 +134,7 @@ class MultiMeshVisitor
                             child_simplex);
                         break;
                     }
+                    default: throw "notimplemented";
                     }
                 }
             }

src/wmtk/operations/Operation.hpp

@@ -15,10 +15,15 @@ template <typename T>
 struct OperationSettings
 {
 };
+namespace utils {
+class MultiMeshEdgeSplitFunctor;
+
+}
 
 class Operation
 {
 public:
+    friend class MultiMeshEdgeSplitFunctor;
     // main entry point of the operator by the scheduler
     bool operator()();
     virtual std::string name() const = 0;

src/wmtk/operations/utils/UpdateEdgeOperationMultiMeshMapFunctor.cpp

@@ -10,10 +10,11 @@
 namespace wmtk::operations::utils {
 void UpdateEdgeOperationMultiMeshMapFunctor::operator()(
     TriMesh& parent_mesh,
-    const TriMeshOperationExecutor& parent_tmoe,
+    const tri_mesh::EdgeOperationData& parent_tmoe,
     TriMesh& child_mesh,
-    const TriMeshOperationExecutor& child_tmoe)
+    const tri_mesh::EdgeOperationData& child_tmoe) const
 {
+    /*
     const auto& parent_incident_data = parent_tmoe.incident_face_datas();
     const auto& child_incident_data = child_tmoe.incident_face_datas();
 
@@ -29,7 +30,7 @@ void UpdateEdgeOperationMultiMeshMapFunctor::operator()(
     auto child_to_parent_accessor = child_mesh.create_accessor(child_to_parent_handle);
     auto parent_to_child_accessor = my_mesh.create_accessor(parent_to_child_handle);
 
-    using IncidentData = TriMeshOperationExecutor::IncidentFaceData;
+    using IncidentData = tri_mesh::EdgeOperationData::IncidentFaceData;
     auto update_from_incident_data = [&](const IncidentData& parent_data,
                                          const IncidentData& child_data) {
         const auto child_split_f = child_data.split_f;
@@ -62,5 +63,6 @@ void UpdateEdgeOperationMultiMeshMapFunctor::operator()(
 
     // update_hash on neighboring cells
     update_hash_in_map(child_mesh);
+    */
 }
 } // namespace wmtk::operations::utils

src/wmtk/operations/utils/UpdateEdgeOperationMultiMeshMapFunctor.hpp

@@ -8,34 +8,40 @@ class EdgeMesh;
 class TriMesh;
 class TetMesh;
 
+namespace operations {
 class EdgeMeshOperationExecutor;
-class TriMeshOperationExecutor;
-class TetMeshOperationExecutor;
+namespace tri_mesh {
+class EdgeOperationData;
+}
+namespace tet_mesh {
+class EdgeOperationData;
+}
+} // namespace operations
 
 namespace operations::utils {
 
 struct UpdateEdgeOperationMultiMeshMapFunctor
 {
     void operator()(
         TriMesh& parent_mesh,
-        const TriMeshOperationExecutor& parent_tmoe,
+        const tri_mesh::EdgeOperationData& parent_tmoe,
         TriMesh& child_mesh,
-        const TriMeshOperationExecutor& child_tmoe);
+        const tri_mesh::EdgeOperationData& child_tmoe) const;
     void operator()(
         EdgeMesh&,
         const EdgeMeshOperationExecutor&,
         EdgeMesh&,
-        EdgeMeshOperationExecutor&) const;
+        const EdgeMeshOperationExecutor&) const;
     void operator()(
         TriMesh&,
-        const TriMeshOperationExecutor&,
+        const tri_mesh::EdgeOperationData&,
         EdgeMesh&,
         const EdgeMeshOperationExecutor&) const;
     void operator()(
         TetMesh&,
-        const TetMeshOperationExecutor&,
+        const tet_mesh::EdgeOperationData&,
         TriMesh&,
-        const TriMeshOperationExecutor&) const;
+        const tri_mesh::EdgeOperationData&) const;
 };
 } // namespace operations::utils
 } // namespace wmtk

src/wmtk/operations/utils/multi_mesh_edge_split.cpp

@@ -1,38 +1,23 @@
-
-#include <wmtk/TetMeshOperationExecutor.hpp>
-#include <wmtk/TriMeshOperationExecutor.hpp>
+#include "multi_mesh_edge_split.hpp"
+#include <wmtk/invariants/InvariantCollection.hpp>
 #include <wmtk/multimesh/MultiMeshVisitor.hpp>
+#include <wmtk/operations/utils/MultiMeshEdgeSplitFunctor.hpp>
 #include <wmtk/operations/utils/UpdateEdgeOperationMultiMeshMapFunctor.hpp>
-#include <wmtk/utils/mesh_type_from_primitive_type.hpp>
 
+#include <wmtk/TriMesh.hpp>
 
 namespace wmtk::operations::utils {
-namespace {
 
-struct EdgeSplitFunctor
+std::shared_ptr<InvariantCollection> multimesh_edge_split_invariants(const Mesh& m)
 {
-    void operator()(const Mesh&, const Simplex&) const { throw "Unimplemented!"; }
-    TriMesh::TriMeshOperationExecutor operator()(const TriMesh& m, const Simplex& s) const
-    {
-        Accessor<long> hash_accessor = m.get_cell_hash_accessor();
-        TriMesh::TriMeshOperationExecutor exec(m, t, hash_accessor);
-        exec.split_edge();
-        return exec;
-    }
-    TetMeshOperationExecutor operator()(const TetMesh& m, const Simplex& s) const
-    {
-        Accessor<long> hash_accessor = m.get_cell_hash_accessor();
-        TetMesh::TetMeshOperationExecutor exec(m, t, hash_accessor);
-        exec.split_edge();
-        return exec;
-    }
-};
-
+    return std::make_shared<InvariantCollection>();
+}
 
-void multi_mesh_split_edge(Mesh& mesh, const Tuple& t);
+void multi_mesh_edge_split(Mesh& mesh, const Tuple& t)
 {
     multimesh::MultiMeshVisitor visitor(
-        EdgeSplitFunctor{},
+        MultiMeshEdgeSplitFunctor{},
         UpdateEdgeOperationMultiMeshMapFunctor{});
     visitor.execute_from_root(mesh, Simplex(PrimitiveType::Edge, t));
 }
+} // namespace wmtk::operations::utils

src/wmtk/operations/utils/multi_mesh_edge_split.hpp

@@ -2,17 +2,18 @@
 #include <memory>
 
 namespace wmtk {
+class Mesh;
+class Tuple;
 
-namespace invariants {
 class InvariantCollection;
-}
 namespace operations::utils {
 
 
 // Initializes any invariants for splitting (which is None by default, but enabling a pattern
 // with other operations)
-std::shared_ptr<InvariantCollection> multimesh_split_edge_invariants(const Mesh& m);
-void multi_mesh_split_edge(Mesh& mesh, const Tuple& t);
+std::shared_ptr<InvariantCollection> multimesh_edge_split_invariants(const Mesh& m);
+
+void multi_mesh_edge_split(Mesh& mesh, const Tuple& t);
 
 
 } // namespace operations::utils