fix python binding and compile error

Author: Huangzizhou

python/src/potentials/barrier_potential.cpp

@@ -76,21 +76,23 @@ void define_barrier_potential(py::module_& m)
         .def(
             "shape_derivative",
             py::overload_cast<
-                const CollisionsBase&, const CollisionMesh&,
+                const Collisions&, const CollisionMesh&,
                 const Eigen::MatrixXd&>(
                 &BarrierPotential::shape_derivative, py::const_),
             R"ipc_Qu8mg5v7(
             Compute the shape derivative of the potential.
 
-            std::runtime_error If the collision collisions were not built with shape derivatives enabled.
+            std::runtime_error If the collision collisions were not built
+            with shape derivatives enabled.
 
             Parameters:
                 collisions: The set of collisions.
                 mesh: The collision mesh.
                 vertices: Vertices of the collision mesh.
 
             Returns:
-                The derivative of the force with respect to X, the rest vertices.
+                The derivative of the force with respect to X, the rest
+                vertices.
             )ipc_Qu8mg5v7",
             py::arg("collisions"), py::arg("mesh"), py::arg("vertices"))
         .def(
@@ -142,7 +144,8 @@ void define_barrier_potential(py::module_& m)
             py::arg("project_hessian_to_psd") = false)
         .def(
             "shape_derivative",
-            [](const DistanceBasedPotential& self, const Collision<4>& collision,
+            [](const DistanceBasedPotential& self,
+               const Collision<4>& collision,
                const std::array<long, 4>& vertex_ids,
                const VectorMax12d& rest_positions,
                const VectorMax12d& positions) {
@@ -180,33 +183,36 @@ void define_smooth_potential(py::module_& m)
 {
     py::class_<ParameterType>(m, "ParameterType")
         .def(
-            py::init<const double&,const double&,const double&,const double&,const double&,
-            const int&>(),
+            py::init<
+                const double&, const double&, const double&, const double&,
+                const double&, const int&, const int&>(),
             R"ipc_Qu8mg5v7(
             Construct parameter set for smooth contact.
 
             Parameters:
                 dhat, alpha_t, beta_t, alpha_n, beta_n, r
             )ipc_Qu8mg5v7",
-            py::arg("dhat"), py::arg("alpha_t"), py::arg("beta_t"), py::arg("alpha_n"),
-            py::arg("beta_n"), py::arg("r"))
+            py::arg("dhat"), py::arg("alpha_t"), py::arg("beta_t"),
+            py::arg("alpha_n"), py::arg("beta_n"), py::arg("r"))
         .def(
-            py::init<const double&,const double&,const double&,const int&>(),
+            py::init<const double&, const double&, const double&, const int&>(),
             R"ipc_Qu8mg5v7(
             Construct parameter set for smooth contact.
 
             Parameters:
                 dhat, alpha_t, beta_t, r
             )ipc_Qu8mg5v7",
-            py::arg("dhat"), py::arg("alpha_t"), py::arg("beta_t"), py::arg("r"))
+            py::arg("dhat"), py::arg("alpha_t"), py::arg("beta_t"),
+            py::arg("r"))
         .def_readonly("dhat", &ParameterType::dhat)
         .def_readonly("alpha_t", &ParameterType::alpha_t)
         .def_readonly("beta_t", &ParameterType::beta_t)
         .def_readonly("alpha_n", &ParameterType::alpha_n)
         .def_readonly("beta_n", &ParameterType::beta_n)
         .def_readonly("r", &ParameterType::r);
 
-    py::class_<SmoothContactPotential<SmoothCollisions<2>>>(m, "SmoothPotential")
+    py::class_<SmoothContactPotential<SmoothCollisions<2>>>(
+        m, "SmoothPotential")
         .def(
             py::init<const ParameterType&>(),
             R"ipc_Qu8mg5v7(
@@ -221,7 +227,9 @@ void define_smooth_potential(py::module_& m)
             py::overload_cast<
                 const SmoothCollisions<2>&, const CollisionMesh&,
                 const Eigen::MatrixXd&>(
-                &SmoothContactPotential<SmoothCollisions<2>>::Potential::operator(), py::const_),
+                &SmoothContactPotential<
+                    SmoothCollisions<2>>::Potential::operator(),
+                py::const_),
             R"ipc_Qu8mg5v7(
             Compute the barrier potential for a set of collisions.
 
@@ -239,7 +247,9 @@ void define_smooth_potential(py::module_& m)
             py::overload_cast<
                 const SmoothCollisions<2>&, const CollisionMesh&,
                 const Eigen::MatrixXd&>(
-                &SmoothContactPotential<SmoothCollisions<2>>::Potential::gradient, py::const_),
+                &SmoothContactPotential<
+                    SmoothCollisions<2>>::Potential::gradient,
+                py::const_),
             R"ipc_Qu8mg5v7(
             Compute the gradient of the barrier potential.
 
@@ -255,8 +265,11 @@ void define_smooth_potential(py::module_& m)
         .def(
             "hessian",
             py::overload_cast<
-                const SmoothCollisions<2>&, const CollisionMesh&, const Eigen::MatrixXd&,
-                const bool>(&SmoothContactPotential<SmoothCollisions<2>>::Potential::hessian, py::const_),
+                const SmoothCollisions<2>&, const CollisionMesh&,
+                const Eigen::MatrixXd&, const bool>(
+                &SmoothContactPotential<
+                    SmoothCollisions<2>>::Potential::hessian,
+                py::const_),
             R"ipc_Qu8mg5v7(
             Compute the hessian of the barrier potential.
 
@@ -273,8 +286,10 @@ void define_smooth_potential(py::module_& m)
             py::arg("project_hessian_to_psd") = false)
         .def(
             "__call__",
-            py::overload_cast<const SmoothCollision<6>&, const Vector<double, -1, 18>&>(
-                &SmoothContactPotential<SmoothCollisions<2>>::operator(), py::const_),
+            py::overload_cast<
+                const SmoothCollision<6>&, const Vector<double, -1, 18>&>(
+                &SmoothContactPotential<SmoothCollisions<2>>::operator(),
+                py::const_),
             R"ipc_Qu8mg5v7(
             Compute the potential for a single collision.
 
@@ -288,8 +303,10 @@ void define_smooth_potential(py::module_& m)
             py::arg("collision"), py::arg("x"))
         .def(
             "gradient",
-            py::overload_cast<const SmoothCollision<6>&, const Vector<double, -1, 18>&>(
-                &SmoothContactPotential<SmoothCollisions<2>>::gradient, py::const_),
+            py::overload_cast<
+                const SmoothCollision<6>&, const Vector<double, -1, 18>&>(
+                &SmoothContactPotential<SmoothCollisions<2>>::gradient,
+                py::const_),
             R"ipc_Qu8mg5v7(
             Compute the gradient of the potential for a single collision.
 
@@ -304,8 +321,10 @@ void define_smooth_potential(py::module_& m)
         .def(
             "hessian",
             py::overload_cast<
-                const SmoothCollision<6>&, const Vector<double, -1, 18>&, const bool>(
-                &SmoothContactPotential<SmoothCollisions<2>>::hessian, py::const_),
+                const SmoothCollision<6>&, const Vector<double, -1, 18>&,
+                const bool>(
+                &SmoothContactPotential<SmoothCollisions<2>>::hessian,
+                py::const_),
             R"ipc_Qu8mg5v7(
             Compute the hessian of the potential for a single collision.
 

src/ipc/friction/friction_collisions.cpp

@@ -12,7 +12,7 @@
 namespace ipc {
 
 template <int dim>
-void FrictionCollisions::build(
+void FrictionCollisions::build_for_smooth_contact(
     const CollisionMesh& mesh,
     const Eigen::MatrixXd& vertices,
     const SmoothCollisions<dim>& collisions,
@@ -137,7 +137,7 @@ void FrictionCollisions::build(
 }
 
 template
-void FrictionCollisions::build<2>(
+void FrictionCollisions::build_for_smooth_contact<2>(
     const CollisionMesh& mesh,
     const Eigen::MatrixXd& vertices,
     const SmoothCollisions<2>& collisions,
@@ -147,7 +147,7 @@ void FrictionCollisions::build<2>(
     const std::function<double(double, double)>& blend_mu);
 
 template
-void FrictionCollisions::build<3>(
+void FrictionCollisions::build_for_smooth_contact<3>(
     const CollisionMesh& mesh,
     const Eigen::MatrixXd& vertices,
     const SmoothCollisions<3>& collisions,

src/ipc/friction/friction_collisions.hpp

@@ -49,21 +49,21 @@ class FrictionCollisions {
             default_blend_mu);
 
     template <int dim>
-    void build(
+    void build_for_smooth_contact(
         const CollisionMesh& mesh,
         const Eigen::MatrixXd& vertices,
         const SmoothCollisions<dim>& collisions,
         const ParameterType &params,
         const double barrier_stiffness,
         double mu)
     {
-        this->build(
+        this->build_for_smooth_contact(
             mesh, vertices, collisions, params, barrier_stiffness,
             Eigen::VectorXd::Constant(vertices.rows(), mu));
     }
 
     template <int dim>
-    void build(
+    void build_for_smooth_contact(
         const CollisionMesh& mesh,
         const Eigen::MatrixXd& vertices,
         const SmoothCollisions<dim>& collisions,

src/ipc/smooth_contact/smooth_collisions_builder.cpp

@@ -19,12 +19,10 @@ namespace {
             std::shared_ptr<typename SmoothCollisions<dim>::value_type>>&
             collisions_)
     {
-        if (pair->is_active() && cc_to_id_.find(pair->get_hash()) == cc_to_id_.end())
-        {
+        if (pair->is_active()
+            && cc_to_id_.find(pair->get_hash()) == cc_to_id_.end()) {
             // New collision, so add it to the end of collisions
-            cc_to_id_.emplace(
-                pair->get_hash(),
-                pair);
+            cc_to_id_.emplace(pair->get_hash(), pair);
             collisions_.push_back(pair);
         }
     }
@@ -107,7 +105,8 @@ void SmoothCollisionsBuilder<3>::add_edge_edge_collisions(
             std::make_shared<
                 SmoothCollisionTemplate<max_vert_3d, Edge3, Edge3>>(
                 std::min(eai, ebi), std::max(eai, ebi), actual_dtype, mesh,
-                param, std::min(edge_dhat(eai), edge_dhat(ebi)), vertices), collisions);
+                param, std::min(edge_dhat(eai), edge_dhat(ebi)), vertices),
+            collisions);
     }
 }
 
@@ -143,7 +142,8 @@ void SmoothCollisionsBuilder<3>::add_face_vertex_collisions(
                 std::make_shared<
                     SmoothCollisionTemplate<max_vert_3d, Face, Point3>>(
                     fi, vi, pt_dtype, mesh, param,
-                    std::min(face_dhat(fi), vert_dhat(vi)), vertices), collisions);
+                    std::min(face_dhat(fi), vert_dhat(vi)), vertices),
+                collisions);
 
         for (int lv = 0; lv < 3; lv++) {
             const auto& vj = mesh.faces()(fi, lv);
@@ -205,10 +205,11 @@ void SmoothCollisionsBuilder<3>::merge(
     merged_collisions.collisions.reserve(total);
 
     // merge
-    for (const auto& builder : local_storage)
-    {
-        vert_vert_3_to_id.insert(builder.vert_vert_3_to_id.begin(), builder.vert_vert_3_to_id.end());
-        edge_vert_3_to_id.insert(builder.edge_vert_3_to_id.begin(), builder.edge_vert_3_to_id.end());
+    for (const auto& builder : local_storage) {
+        vert_vert_3_to_id.insert(
+            builder.vert_vert_3_to_id.begin(), builder.vert_vert_3_to_id.end());
+        edge_vert_3_to_id.insert(
+            builder.edge_vert_3_to_id.begin(), builder.edge_vert_3_to_id.end());
     }
     int edge_vert_count = edge_vert_3_to_id.size();
     int vert_vert_count = vert_vert_3_to_id.size();
@@ -220,17 +221,12 @@ void SmoothCollisionsBuilder<3>::merge(
     for (const auto& [key, val] : edge_vert_3_to_id)
         merged_collisions.collisions.push_back(val);
 
-    for (const auto& builder : local_storage)
-    {
-        for (const auto& cc : builder.collisions)
-        {
-            if (cc->type() == CollisionType::FaceVertex)
-            {
+    for (const auto& builder : local_storage) {
+        for (const auto& cc : builder.collisions) {
+            if (cc->type() == CollisionType::FaceVertex) {
                 face_vert_count++;
                 merged_collisions.collisions.push_back(cc);
-            }
-            else if (cc->type() == CollisionType::EdgeEdge)
-            {
+            } else if (cc->type() == CollisionType::EdgeEdge) {
                 edge_edge_count++;
                 merged_collisions.collisions.push_back(cc);
             }
@@ -266,10 +262,11 @@ void SmoothCollisionsBuilder<2>::merge(
     merged_collisions.collisions.reserve(total);
 
     // merge
-    for (auto& builder : local_storage)
-    {
-        vert_vert_2_to_id.insert(builder.vert_vert_2_to_id.begin(), builder.vert_vert_2_to_id.end());
-        vert_edge_2_to_id.insert(builder.vert_edge_2_to_id.begin(), builder.vert_edge_2_to_id.end());
+    for (auto& builder : local_storage) {
+        vert_vert_2_to_id.insert(
+            builder.vert_vert_2_to_id.begin(), builder.vert_vert_2_to_id.end());
+        vert_edge_2_to_id.insert(
+            builder.vert_edge_2_to_id.begin(), builder.vert_edge_2_to_id.end());
     }
     int edge_vert_count = vert_edge_2_to_id.size();
     int vert_vert_count = vert_vert_2_to_id.size();

src/ipc/smooth_contact/smooth_collisions_builder.hpp

@@ -12,7 +12,7 @@ template <int dim> class SmoothCollisionsBuilder;
 
 template <> class SmoothCollisionsBuilder<2> {
 public:
-    SmoothCollisionsBuilder() {}
+    SmoothCollisionsBuilder() { }
 
     void add_edge_vertex_collisions(
         const CollisionMesh& mesh,
@@ -25,9 +25,10 @@ template <> class SmoothCollisionsBuilder<2> {
         const size_t end_i);
 
     // -------------------------------------------------------------------------
-    
+
     static void merge(
-        const utils::ParallelCacheType<SmoothCollisionsBuilder<2>>& local_storage,
+        const utils::ParallelCacheType<SmoothCollisionsBuilder<2>>&
+            local_storage,
         SmoothCollisions<2>& merged_collisions);
 
     // Constructed collisions
@@ -49,7 +50,7 @@ template <> class SmoothCollisionsBuilder<2> {
 
 template <> class SmoothCollisionsBuilder<3> {
 public:
-    SmoothCollisionsBuilder() {}
+    SmoothCollisionsBuilder() { }
 
     void add_edge_edge_collisions(
         const CollisionMesh& mesh,
@@ -75,7 +76,8 @@ template <> class SmoothCollisionsBuilder<3> {
     // -------------------------------------------------------------------------
 
     static void merge(
-        const utils::ParallelCacheType<SmoothCollisionsBuilder<3>>& local_storage,
+        const utils::ParallelCacheType<SmoothCollisionsBuilder<3>>&
+            local_storage,
         SmoothCollisions<3>& merged_collisions);
 
     // Constructed collisions
@@ -84,7 +86,8 @@ template <> class SmoothCollisionsBuilder<3> {
 
     // -------------------------------------------------------------------------
 
-    // Store the indices to pairs to avoid duplicates, no need for Face-Vertex and Edge-Edge
+    // Store the indices to pairs to avoid duplicates, no need for Face-Vertex
+    // and Edge-Edge
     unordered_map<
         std::pair<long, long>,
         std::shared_ptr<SmoothCollisionTemplate<max_vert_3d, Point3, Point3>>>

tests/src/tests/friction/test_force_jacobian.cpp

@@ -364,7 +364,7 @@ void check_smooth_friction_force_jacobian(
         collisions.size());
 
     FrictionCollisions friction_collisions;
-    friction_collisions.build(
+    friction_collisions.build_for_smooth_contact<dim>(
         mesh, X + Ut, collisions, params, barrier_stiffness, mu);
     CHECK(friction_collisions.size());
 
@@ -484,23 +484,22 @@ void check_smooth_friction_force_jacobian(
             // fd_collisions.build(mesh, X + fd_Ut, params);
             fd_collisions.collisions.push_back(std::make_shared<SmoothCollisionTemplate<max_vert_3d, Face, Point3>>(0, 0, PointTriangleDistanceType::P_T, mesh, params, params.dhat, X + fd_Ut));
 
-            fd_friction_collisions.build(
+            fd_friction_collisions.build_for_smooth_contact(
                 mesh, X + fd_Ut, fd_collisions, params, barrier_stiffness, mu);
         } else {
             fd_friction_collisions = friction_collisions;
         }
 
         return D.smooth_contact_force(
-            friction_collisions, mesh, X, fd_Ut, velocities, dhat,
-            barrier_stiffness);
+            friction_collisions, mesh, X, fd_Ut, velocities);
     };
     Eigen::MatrixXd fd_JF_wrt_Ut;
     fd::finite_jacobian(fd::flatten(Ut), F_Ut, fd_JF_wrt_Ut);
     // CHECK(fd::compare_jacobian(JF_wrt_Ut, fd_JF_wrt_Ut));
     // if (!fd::compare_jacobian(JF_wrt_Ut, fd_JF_wrt_Ut)) {
     //     tests::print_compare_nonzero(JF_wrt_Ut, fd_JF_wrt_Ut);
     // }
-    std::cout << std::setprecision(8) << JF_wrt_Ut.transpose() << "\n\n" << fd_JF_wrt_Ut.transpose() << "\n";
+    // std::cout << std::setprecision(8) << JF_wrt_Ut.transpose() << "\n\n" << fd_JF_wrt_Ut.transpose() << "\n";
     CHECK((JF_wrt_Ut - fd_JF_wrt_Ut).norm() <= 1e-7 * JF_wrt_Ut.norm());
 
     // ///////////////////////////////////////////////////////////////////////////