Geometric Contact Potential

.clang-tidy

@@ -8,6 +8,7 @@ Checks: >
 
   # Bug Detection and Safety
   bugprone-*,
+  # misc-const-correctness,
 
   # Specific high-value checks (even if not in a group above)
   google-runtime-int,
@@ -27,7 +28,10 @@ Checks: >
   -readability-isolate-declaration,
   -readability-magic-numbers,
   -readability-math-missing-parentheses,
-  -readability-redundant-access-specifiers
+  -readability-redundant-access-specifiers,
+  -readability-uppercase-literal-suffix,
+  -readability-function-size,
+  -readability-convert-member-functions-to-static
 
 WarningsAsErrors: '*'
 HeaderFilterRegex: '.*(ipc/).*'

.github/workflows/coverage.yml

@@ -72,7 +72,7 @@ jobs:
           lcov --remove coverage.info --ignore-errors unused '/usr/*' "$HOME/.cache/*" "*tests/*" --output-file coverage.info
 
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v3.1.6
+        uses: codecov/codecov-action@v5.5.1
         with:
           fail_ci_if_error: true
           files: build/coverage.info

.pre-commit-config.yaml

@@ -1,11 +1,11 @@
 repos:
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: v14.0.0
+    rev: v21.1.2
     hooks:
       - id: clang-format
         name: clang-format
         description: "Use clang-format to format C/C++ code"
-        entry: clang-format-20
+        entry: clang-format
         args:
           - --style=file
           - --verbose

CMakeLists.txt

@@ -176,6 +176,11 @@ target_link_libraries(ipc_toolkit PRIVATE simple_bvh::simple_bvh)
 include(spdlog)
 target_link_libraries(ipc_toolkit PUBLIC spdlog::spdlog)
 
+# TinyAD
+include(tinyad)
+# TODO: Make this a private dependency once we stop exposing TinyAD types in the public API.
+target_link_libraries(ipc_toolkit PUBLIC TinyAD::TinyAD)
+
 # CCD
 if(IPC_TOOLKIT_WITH_INEXACT_CCD)
   # Etienne Vouga's CTCD Library for the floating point root finding algorithm

cmake/ipc_toolkit/ipc_toolkit_tests_data.cmake

@@ -30,7 +30,7 @@ else()
         SOURCE_DIR ${IPC_TOOLKIT_TESTS_DATA_DIR}
 
         GIT_REPOSITORY https://github.com/ipc-sim/ipc-toolkit-tests-data.git
-        GIT_TAG 0c6ce752d020db32f62da37d7b8ca9f73c204b36
+        GIT_TAG 7ca6db695adcc00d3d6d978767dfc0d81722a515
 
         CONFIGURE_COMMAND ""
         BUILD_COMMAND ""

cmake/recipes/scalable_ccd.cmake

@@ -8,7 +8,7 @@ message(STATUS "Third-party: creating target 'scalable_ccd::scalable_ccd'")
 
 include(CPM)
 CPMAddPackage(
-    URI "gh:continuous-collision-detection/scalable-ccd#4fa806f533b19132e696a2dddeab16537025b5f9"
+    URI "gh:continuous-collision-detection/scalable-ccd#c80af01cab083b3eeb8dac80312ec9cfe479a5cf"
     OPTIONS "SCALABLE_CCD_WITH_CUDA ${IPC_TOOLKIT_WITH_CUDA}"
 )
 

cmake/recipes/spdlog.cmake

@@ -10,7 +10,7 @@ option(SPDLOG_INSTALL "Generate the install target" ON)
 set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME "spdlog")
 
 include(CPM)
-CPMAddPackage("gh:gabime/spdlog@1.11.0")
+CPMAddPackage("gh:gabime/spdlog@1.15.3")
 
 set_target_properties(spdlog PROPERTIES POSITION_INDEPENDENT_CODE ON)
 

cmake/recipes/tinyad.cmake

@@ -0,0 +1,16 @@
+# TinyAD (https://github.com/patr-schm/tinyad)
+# License: MIT
+if(TARGET TinyAD::TinyAD)
+    return()
+endif()
+
+message(STATUS "Third-party: creating target 'TinyAD::TinyAD'")
+
+include(CPM)
+CPMAddPackage(
+    URI "gh:zfergus/tinyad#957ede5bcf4b8d924f27230083508c664a9f7a7d"
+    OPTIONS "TINYAD_PARALLEL_BACKEND onetbb"
+)
+
+# Folder name for IDE
+set_target_properties(TinyAD PROPERTIES FOLDER "ThirdParty")

docs/source/developers/tools.rst

@@ -0,0 +1,25 @@
+Tools for Developers
+=====================
+
+Using Pre-Commit Hooks
+----------------------
+
+Use the ``.pre-commit-config.yaml`` file to apply clang-format on before commits.
+
+Steps:
+1. ``pip install pre-commit``
+2. ``pre-commit install``
+3. ``git add . && git commit -m "My commit message"``
+
+Hopefully, that will avoid upsetting the GitHub checks :slightly_smiling_face:
+
+Clang-Tidy
+----------
+
+To run locally:
+
+1. `Install clang-tidy on mac <https://stackoverflow.com/questions/53111082/how-to-install-clang-tidy-on-macos/78243685#78243685>`_
+2. ``cd build; cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ..``: this exports a JSON describing how all the files will be compiled
+3. ``cd ..; run-clang-tidy -quiet -p build $(find src -name '*.cpp')``
+
+You can also tack on a ``-j <N>`` to run-clang-tidy to make it parallel.

python/src/bindings.cpp

@@ -88,6 +88,8 @@ PYBIND11_MODULE(ipctk, m)
     define_smooth_friction_mollifier(m);
     define_smooth_mu(m);
 
+    define_smooth_potential(m);
+
     // implicits
     define_plane_implicit(m);
 

python/src/collision_mesh.cpp

@@ -151,7 +151,8 @@ void define_collision_mesh(py::module_& m)
             "displacement_map"_a = Eigen::SparseMatrix<double>())
         .def(
             py::init<
-                const std::vector<bool>&, Eigen::ConstRef<Eigen::MatrixXd>,
+                const std::vector<bool>&, const std::vector<bool>&,
+                Eigen::ConstRef<Eigen::MatrixXd>,
                 Eigen::ConstRef<Eigen::MatrixXi>,
                 Eigen::ConstRef<Eigen::MatrixXi>,
                 const Eigen::SparseMatrix<double>&>(),
@@ -160,12 +161,13 @@ void define_collision_mesh(py::module_& m)
 
             Parameters:
                 include_vertex: Vector of bools indicating whether each vertex should be included in the collision mesh.
+                orient_vertex: Vector of bools indicating whether each vertex is orientable.
                 full_rest_positions: The vertices of the full mesh at rest (#V × dim).
                 edges: The edges of the collision mesh indexed into the full mesh vertices (#E × 2).
                 faces: The faces of the collision mesh indexed into the full mesh vertices (#F × 3).
                 displacement_map: The displacement mapping from displacements on the full mesh to the collision mesh.
             )ipc_Qu8mg5v7",
-            "include_vertex"_a, "full_rest_positions"_a,
+            "include_vertex"_a, "orient_vertex"_a, "full_rest_positions"_a,
             "edges"_a = Eigen::MatrixXi(), "faces"_a = Eigen::MatrixXi(),
             "displacement_map"_a = Eigen::SparseMatrix<double>())
         .def_static(

python/src/collisions/normal/normal_collisions.cpp

@@ -1,9 +1,86 @@
 #include <common.hpp>
 
 #include <ipc/collisions/normal/normal_collisions.hpp>
+#include <ipc/smooth_contact/smooth_collisions.hpp>
 
 using namespace ipc;
 
+template <typename collision_type, typename parent_type>
+void define_smooth_collision_template(py::module_& m, std::string name)
+{
+    py::class_<collision_type, parent_type>(m, name.c_str())
+        .def("name", &collision_type::name, "Get the type name of collision")
+        .def(
+            "num_vertices", &collision_type::num_vertices,
+            "Get the number of vertices");
+}
+
+void define_smooth_collisions(py::module_& m, std::string name)
+{
+    py::class_<SmoothCollisions>(m, name.c_str())
+        .def(py::init())
+        .def(
+            "build",
+            py::overload_cast<
+                const CollisionMesh&, Eigen::ConstRef<Eigen::MatrixXd>,
+                const SmoothContactParameters, const bool,
+                const std::shared_ptr<BroadPhase>&>(&SmoothCollisions::build),
+            R"ipc_Qu8mg5v7(
+            Initialize the set of collisions used to compute the barrier potential.
+
+            Parameters:
+                mesh: The collision mesh.
+                vertices: Vertices of the collision mesh.
+                param: SmoothContactParameters.
+                use_adaptive_dhat: If the adaptive dhat should be used.
+                broad_phase: Broad phase method.
+            )ipc_Qu8mg5v7",
+            py::arg("mesh"), py::arg("vertices"), py::arg("param"),
+            py::arg("use_adaptive_dhat") = false,
+            py::arg("broad_phase") = make_default_broad_phase())
+        .def(
+            "compute_minimum_distance",
+            &SmoothCollisions::compute_minimum_distance,
+            R"ipc_Qu8mg5v7(
+            Computes the minimum distance between any non-adjacent elements.
+
+            Parameters:
+                mesh: The collision mesh.
+                vertices: Vertices of the collision mesh.
+
+            Returns:
+                The minimum distance between any non-adjacent elements.
+            )ipc_Qu8mg5v7",
+            py::arg("mesh"), py::arg("vertices"))
+        .def(
+            "__len__", &SmoothCollisions::size, "Get the number of collisions.")
+        .def(
+            "empty", &SmoothCollisions::empty,
+            "Get if the collision set is empty.")
+        .def("clear", &SmoothCollisions::clear, "Clear the collision set.")
+        .def(
+            "__getitem__",
+            [](SmoothCollisions& self, size_t i) ->
+            typename SmoothCollisions::value_type& { return self[i]; },
+            py::return_value_policy::reference,
+            R"ipc_Qu8mg5v7(
+            Get a reference to collision at index i.
+
+            Parameters:
+                i: The index of the collision.
+
+            Returns:
+                A reference to the collision.
+            )ipc_Qu8mg5v7",
+            py::arg("i"))
+        .def(
+            "to_string", &SmoothCollisions::to_string, py::arg("mesh"),
+            py::arg("vertices"), py::arg("param"))
+        .def(
+            "n_candidates", &SmoothCollisions::n_candidates,
+            "Get the number of candidates.");
+}
+
 void define_normal_collisions(py::module_& m)
 {
     py::class_<NormalCollisions>(m, "NormalCollisions")
@@ -159,4 +236,42 @@ void define_normal_collisions(py::module_& m)
         .def_readwrite("ee_collisions", &NormalCollisions::ee_collisions)
         .def_readwrite("fv_collisions", &NormalCollisions::fv_collisions)
         .def_readwrite("pv_collisions", &NormalCollisions::pv_collisions);
+
+    py::class_<SmoothCollision>(m, "SmoothCollision2")
+        .def("n_dofs", &SmoothCollision::n_dofs, "Get the degree of freedom")
+        .def(
+            "__call__", &SmoothCollision::operator(),
+            R"ipc_Qu8mg5v7(
+            Compute the potential.
+
+            Parameters:
+                positions: The vertex positions.
+                params: The parameters.
+
+            Returns:
+                The potential (not scaled by the barrier stiffness) of this collision pair.
+            )ipc_Qu8mg5v7",
+            py::arg("positions"), py::arg("params"))
+        .def(
+            "__getitem__",
+            [](SmoothCollision& self, size_t i) -> long { return self[i]; },
+            R"ipc_Qu8mg5v7(
+            Get primitive id.
+
+            Parameters:
+                i: 0 or 1.
+
+            Returns:
+                The index of the primitive.
+            )ipc_Qu8mg5v7",
+            py::arg("i"));
+
+    define_smooth_collision_template<
+        SmoothCollisionTemplate<Edge2, Point2>, SmoothCollision>(
+        m, "Edge2Point2Collision");
+    define_smooth_collision_template<
+        SmoothCollisionTemplate<Point2, Point2>, SmoothCollision>(
+        m, "Point2Point2Collision");
+
+    define_smooth_collisions(m, "SmoothCollisions");
 }