ipc-sim · fsichetti · Nov 19, 2025 · Nov 20, 2025 · Nov 20, 2025 · Nov 24, 2025
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -100,6 +100,7 @@ option(IPC_TOOLKIT_WITH_ABSEIL                "Use Abseil's hash functions"
 option(IPC_TOOLKIT_WITH_FILIB                 "Use filib for interval arithmetic"              ON)
 option(IPC_TOOLKIT_WITH_INEXACT_CCD           "Use the original inexact CCD method of IPC"    OFF)
 option(IPC_TOOLKIT_WITH_PROFILER              "Enable performance profiler"                   OFF)
+option(IPC_TOOLKIT_WITH_GEOGRAM               "Use geogram for predicates / expansion types"  ON)
 option(IPC_TOOLKIT_WITH_TRACY                 "Enable Tracy frame profiler"                   OFF)
 option(IPC_TOOLKIT_WITH_MESHFEM_SPARSE        "Use MeshFEMSparse for block-accelerated assembly" ON)
 
@@ -302,6 +303,12 @@ if(IPC_TOOLKIT_WITH_FILIB)
   target_link_libraries(ipc_toolkit PUBLIC filib::filib)
 endif()
 
+# Geogram
+if(IPC_TOOLKIT_WITH_GEOGRAM)
+  include(geogram)
+  target_link_libraries(ipc_toolkit PUBLIC geogram::geogram)
+endif()
+
 # Block-accelerated Hessian assembly
 if(IPC_TOOLKIT_WITH_MESHFEM_SPARSE)
   include(meshfem_sparse)
@@ -408,6 +415,25 @@ endif()
 # Use C++17
 target_compile_features(ipc_toolkit PUBLIC cxx_std_17)
 
+################################################################################
+# CUDA
+################################################################################
+
+# CUDA support
+if(IPC_TOOLKIT_WITH_CUDA)
+  # If CMAKE_CUDA_ARCHITECTURES was not specified, set it to native.
+  if(DEFINED CMAKE_CUDA_ARCHITECTURES)
+    message(STATUS "CMAKE_CUDA_ARCHITECTURES was specified, skipping auto-detection")
+  else()
+    message(STATUS "CMAKE_CUDA_ARCHITECTURES was not specified, set it to native")
+    set(CMAKE_CUDA_ARCHITECTURES "native")
+  endif()
+  message(STATUS "Targeting CUDA_ARCHITECTURES \"${CMAKE_CUDA_ARCHITECTURES}\"")
+
+  # Enable CUDA support
+  enable_language(CUDA)
+endif()
+
 ################################################################################
 # Tests
 ################################################################################
@@ -417,6 +443,12 @@ if(IPC_TOOLKIT_BUILD_TESTS)
   include(CTest)
   enable_testing()
   add_subdirectory(tests)
+  if(IPC_TOOLKIT_WITH_ROBIN_MAP)
+    target_link_libraries(ipc_toolkit_tests PRIVATE tsl::robin_map)
+  endif()
+  if(IPC_TOOLKIT_WITH_ABSEIL)
+    target_link_libraries(ipc_toolkit_tests PRIVATE absl::hash)
+  endif()
 endif()
 
 ################################################################################

diff --git a/cmake/recipes/eigen.cmake b/cmake/recipes/eigen.cmake
@@ -5,7 +5,7 @@ if(TARGET Eigen3::Eigen)
 endif()
 
 option(EIGEN_WITH_MKL "Use Eigen with MKL" OFF)
-option(EIGEN_DONT_VECTORIZE "Disable Eigen vectorization" OFF)
+option(EIGEN_DONT_VECTORIZE "Disable Eigen vectorization" ON)
 
 message(STATUS "Third-party: creating target 'Eigen3::Eigen'")
 

diff --git a/cmake/recipes/geogram.cmake b/cmake/recipes/geogram.cmake
@@ -0,0 +1,24 @@
+# finite-diff (https://github.com/BrunoLevy/geogram)
+# License: BSD 3-Clause License
+if(TARGET geogram::geogram)
+    return()
+endif()
+
+message(STATUS "Third-party: creating target 'geogram::geogram'")
+
+include(CPM)
+CPMAddPackage(
+    URI "gh:BrunoLevy/geogram@1.10.1"
+    OPTIONS
+        "GEOGRAM_WITH_GRAPHICS OFF"  
+        "GEOGRAM_WITH_LEGACY_NUMERICS OFF"  
+        "GEOGRAM_WITH_HLBFGS OFF"  
+        "GEOGRAM_WITH_TETGEN OFF"  
+        "GEOGRAM_WITH_TRIANGLE OFF"  
+        "GEOGRAM_WITH_LUA OFF"  
+        "GEOGRAM_LIB_ONLY ON"
+)
+
+if(NOT TARGET geogram::geogram AND TARGET geogram)  
+    add_library(geogram::geogram ALIAS geogram)  
+endif()
diff --git a/docs/source/about/release_notes.rst b/docs/source/about/release_notes.rst
@@ -177,11 +177,11 @@ Bug Fixes |:bug:|
 Python |:snake:|
 ~~~~~~~~~~~~~~~~
 
-- 💥 **[Breaking]** Rename the ``SmoothPotential`` class to ``SmoothContactPotential`` to match the C++ name (`#247 <https://github.com/ipc-sim/ipc-toolkit/pull/247>`_).
+- 💥 **[Breaking]** Rename the ``GCPPotential`` class to ``GCPPotential`` to match the C++ name (`#247 <https://github.com/ipc-sim/ipc-toolkit/pull/247>`_).
 - Fill gaps that made the GCP and convergent-formulation tutorials impossible to follow from Python (`#247 <https://github.com/ipc-sim/ipc-toolkit/pull/247>`_):
 
-  - Add ``SmoothCollisions.compute_adaptive_dhat``. Without it, adaptive dhat was unreachable even though ``build()`` accepts ``use_adaptive_dhat=True`` and requires this to be called first.
-  - Add the ``SmoothContactParameters.adaptive_dhat_ratio`` property.
+  - Add ``GCPCollisions.compute_adaptive_dhat``. Without it, adaptive dhat was unreachable even though ``build()`` accepts ``use_adaptive_dhat=True`` and requires this to be called first.
+  - Add the ``GCPParameters.adaptive_dhat_ratio`` property.
   - Add the ``BarrierPotential.stiffness`` and ``.use_physical_barrier`` properties, mirroring the C++ setters.
 
 - Validate preconditions in the bindings instead of relying on the C++ ``assert``\ s, which are compiled out under ``NDEBUG`` and would let a release build silently accept a bad value (`#247 <https://github.com/ipc-sim/ipc-toolkit/pull/247>`_). ``BarrierPotential`` now raises ``ValueError`` for a non-positive or NaN ``dhat``/``stiffness`` and for a null barrier.
@@ -209,7 +209,7 @@ Documentation
 Refactor
 ~~~~~~~~
 
-- Replace the duplicate squared-distance implementations in ``ipc/smooth_contact/distance/`` (``point_point_sqr_distance``, ``point_line_sqr_distance``, ``line_line_sqr_distance``, ``edge_edge_sqr_distance``, ``point_plane_sqr_distance``, ``point_triangle_sqr_distance``) with the now-templated functions from ``ipc/distance/``.
+- Replace the duplicate squared-distance implementations in ``ipc/gcp/distance/`` (``point_point_sqr_distance``, ``point_line_sqr_distance``, ``line_line_sqr_distance``, ``edge_edge_sqr_distance``, ``point_plane_sqr_distance``, ``point_triangle_sqr_distance``) with the now-templated functions from ``ipc/distance/``.
 
 Miscellaneous
 ~~~~~~~~~~~~~

diff --git a/docs/source/tutorials/gcp.rst b/docs/source/tutorials/gcp.rst
@@ -297,17 +297,17 @@ GCP is implemented as separate collision and potential classes. A basic example
             double beta_n = 0.0;    // exterior direction constraint offset
             int r = 2;              // barrier exponent (dimension - 1)
 
-            ipc::SmoothContactParameters params(dhat, alpha_t, beta_t, alpha_n, beta_n, r);
+            ipc::GCPParameters params(dhat, alpha_t, beta_t, alpha_n, beta_n, r);
 
             // Build collision set
             bool use_adaptive_dhat = true;
-            ipc::SmoothCollisions collisions;
+            ipc::GCPCollisions collisions;
             if (use_adaptive_dhat)
                 collisions.compute_adaptive_dhat(collision_mesh, vertices, params);
             collisions.build(collision_mesh, vertices, params, use_adaptive_dhat);
 
             // Compute potential
-            ipc::SmoothContactPotential barrier_potential(params);
+            ipc::GCPPotential barrier_potential(params);
             double b = barrier_potential(collisions, collision_mesh, vertices);
 
             // Compute gradient
@@ -331,17 +331,17 @@ GCP is implemented as separate collision and potential classes. A basic example
             beta_n = 0.0      # exterior direction constraint offset
             r = 2             # barrier exponent (dimension - 1)
 
-            params = ipctk.SmoothContactParameters(dhat, alpha_t, beta_t, alpha_n, beta_n, r)
+            params = ipctk.GCPParameters(dhat, alpha_t, beta_t, alpha_n, beta_n, r)
 
             # Build collision set
             use_adaptive_dhat = True
-            collisions = ipctk.SmoothCollisions()
+            collisions = ipctk.GCPCollisions()
             if use_adaptive_dhat:
                 collisions.compute_adaptive_dhat(collision_mesh, vertices, params)
             collisions.build(collision_mesh, vertices, params, use_adaptive_dhat)
 
             # Compute potential
-            barrier_potential = ipctk.SmoothContactPotential(params)
+            barrier_potential = ipctk.GCPPotential(params)
             b = barrier_potential(collisions, collision_mesh, vertices)
 
             # Compute gradient
@@ -351,15 +351,15 @@ GCP is implemented as separate collision and potential classes. A basic example
             hess = barrier_potential.hessian(collisions, collision_mesh, vertices)
 
 .. important::
-    If ``use_adaptive_dhat`` is true, make sure to call ``SmoothCollisions::compute_adaptive_dhat()`` **before** ``SmoothCollisions::build()``. Adaptive :math:`\hat{d}` computes per-element barrier extents based on the rest configuration to guarantee zero potential (and zero forces) in the undeformed state.
+    If ``use_adaptive_dhat`` is true, make sure to call ``GCPCollisions::compute_adaptive_dhat()`` **before** ``GCPCollisions::build()``. Adaptive :math:`\hat{d}` computes per-element barrier extents based on the rest configuration to guarantee zero potential (and zero forces) in the undeformed state.
 
 .. note::
-    Unlike ``NormalCollisions`` in IPC, ``SmoothCollisions`` must be rebuilt whenever vertex positions change, because the interaction set depends on the current geometry (normals, tangents, and distances).
+    Unlike ``NormalCollisions`` in IPC, ``GCPCollisions`` must be rebuilt whenever vertex positions change, because the interaction set depends on the current geometry (normals, tangents, and distances).
 
 Parameter Choices
 -----------------
 
-The ``SmoothContactParameters`` structure contains the following parameters:
+The ``GCPParameters`` structure contains the following parameters:
 
 .. list-table::
    :header-rows: 1
@@ -392,7 +392,7 @@ As :math:`\alpha + \beta` decreases, the support of the Heaviside function shrin
 
 Additional internal parameters that may affect behavior:
 
-- **Adaptive dhat ratio** (default ``0.5``): Controls the ratio :math:`\epsilon(x) / d_c(x, f_0)` in the adaptive barrier localization. Set it via ``SmoothContactParameters::set_adaptive_dhat_ratio()`` in C++ or the ``SmoothContactParameters.adaptive_dhat_ratio`` property in Python.
+- **Adaptive dhat ratio** (default ``0.5``): Controls the ratio :math:`\epsilon(x) / d_c(x, f_0)` in the adaptive barrier localization. Set it via ``GCPParameters::set_adaptive_dhat_ratio()`` in C++ or the ``GCPParameters.adaptive_dhat_ratio`` property in Python.
 - **Element measure** :math:`L`: For vertices, this is set to the average edge length around the vertex; for edges, to the edge length; for faces, :math:`L` is not needed. This determines the strength of the potential for low-dimensional contact (edge–edge, edge–vertex, vertex–vertex).
 
 Friction

diff --git a/python/src/bindings.cpp b/python/src/bindings.cpp
@@ -92,6 +92,7 @@ PYBIND11_MODULE(ipctk, m)
     define_smooth_mu(m);
 
     define_smooth_potential(m);
+    define_esp_potential(m);
 
     // geometry
     define_angle(m);

diff --git a/python/src/candidates/candidates.cpp b/python/src/candidates/candidates.cpp
@@ -12,7 +12,7 @@ void define_candidates(py::module_& m)
             "build",
             py::overload_cast<
                 const CollisionMesh&, Eigen::ConstRef<Eigen::MatrixXd>,
-                const double, BroadPhase*>(&Candidates::build),
+                const double, BroadPhase*, const bool>(&Candidates::build),
             R"ipc_Qu8mg5v7(
             Initialize the set of discrete collision detection candidates.
 
@@ -23,13 +23,13 @@ void define_candidates(py::module_& m)
                 broad_phase: Broad phase to use.
             )ipc_Qu8mg5v7",
             "mesh"_a, "vertices"_a, "inflation_radius"_a = 0,
-            "broad_phase"_a = nullptr)
+            "broad_phase"_a = nullptr, "all_types"_a = false)
         .def(
             "build",
             py::overload_cast<
                 const CollisionMesh&, Eigen::ConstRef<Eigen::MatrixXd>,
-                Eigen::ConstRef<Eigen::MatrixXd>, const double, BroadPhase*>(
-                &Candidates::build),
+                Eigen::ConstRef<Eigen::MatrixXd>, const double, BroadPhase*,
+                const bool>(&Candidates::build),
             R"ipc_Qu8mg5v7(
             Initialize the set of continuous collision detection candidates.
 
@@ -44,7 +44,8 @@ void define_candidates(py::module_& m)
                 broad_phase: Broad phase to use.
             )ipc_Qu8mg5v7",
             "mesh"_a, "vertices_t0"_a, "vertices_t1"_a,
-            "inflation_radius"_a = 0, "broad_phase"_a = nullptr)
+            "inflation_radius"_a = 0, "broad_phase"_a = nullptr,
+            "all_types"_a = false)
         .def("__len__", &Candidates::size)
         .def("empty", &Candidates::empty)
         .def("clear", &Candidates::clear)

diff --git a/python/src/collision_mesh.cpp b/python/src/collision_mesh.cpp
@@ -18,8 +18,7 @@ struct PairHash {
     }
 };
 
-using MapCanCollide =
-    std::unordered_map<std::pair<size_t, size_t>, bool, PairHash>;
+using MapCanCollide = unordered_map<std::pair<size_t, size_t>, bool, PairHash>;
 
 CollisionFilter
 make_sparse_filter(MapCanCollide explicit_values, bool default_value)