use normal potential in python bindings

Author: maxpaik16

python/src/collisions/tangential/edge_edge.cpp

@@ -14,7 +14,7 @@ void define_edge_edge_tangential_collision(py::module_& m)
         .def(
             py::init<
                 const EdgeEdgeNormalCollision&, const VectorMax12d&,
-                const BarrierPotential&, const double>(),
+                const NormalPotential&, const double>(),
             py::arg("collision"), py::arg("positions"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"));
+            py::arg("normal_potential"), py::arg("normal_stiffness"));
 }

python/src/collisions/tangential/edge_vertex.cpp

@@ -14,7 +14,7 @@ void define_edge_vertex_tangential_collision(py::module_& m)
         .def(
             py::init<
                 const EdgeVertexNormalCollision&, const VectorMax12d&,
-                const BarrierPotential&, const double>(),
+                const NormalPotential&, const double>(),
             py::arg("collision"), py::arg("positions"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"));
+            py::arg("normal_potential"), py::arg("normal_stiffness"));
 }

python/src/collisions/tangential/face_vertex.cpp

@@ -14,7 +14,7 @@ void define_face_vertex_tangential_collision(py::module_& m)
         .def(
             py::init<
                 const FaceVertexNormalCollision&, const VectorMax12d&,
-                const BarrierPotential&, const double>(),
+                const NormalPotential&, const double>(),
             py::arg("collision"), py::arg("positions"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"));
+            py::arg("normal_potential"), py::arg("normal_stiffness"));
 }

python/src/collisions/tangential/tangential_collisions.cpp

@@ -13,35 +13,35 @@ void define_tangential_collisions(py::module_& m)
             "build",
             py::overload_cast<
                 const CollisionMesh&, const Eigen::MatrixXd&,
-                const NormalCollisions&, const BarrierPotential&, double,
+                const NormalCollisions&, const NormalPotential&, double,
                 double>(&TangentialCollisions::build),
             py::arg("mesh"), py::arg("vertices"), py::arg("collisions"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"),
+            py::arg("normal_potential"), py::arg("normal_stiffness"),
             py::arg("mu"))
         .def(
             "build",
             [](TangentialCollisions& self, const CollisionMesh& mesh,
                const Eigen::MatrixXd& vertices,
                const NormalCollisions& collisions,
-               const BarrierPotential& barrier_potential,
-               const double barrier_stiffness, const Eigen::VectorXd& mus) {
+               const NormalPotential& normal_potential,
+               const double normal_stiffness, const Eigen::VectorXd& mus) {
                 self.build(
-                    mesh, vertices, collisions, barrier_potential,
-                    barrier_stiffness, mus);
+                    mesh, vertices, collisions, normal_potential,
+                    normal_stiffness, mus);
             },
             py::arg("mesh"), py::arg("vertices"), py::arg("collisions"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"),
+            py::arg("normal_potential"), py::arg("normal_stiffness"),
             py::arg("mus"))
         .def(
             "build",
             py::overload_cast<
                 const CollisionMesh&, const Eigen::MatrixXd&,
-                const NormalCollisions&, const BarrierPotential&, const double,
+                const NormalCollisions&, const NormalPotential&, const double,
                 const Eigen::VectorXd&,
                 const std::function<double(double, double)>&>(
                 &TangentialCollisions::build),
             py::arg("mesh"), py::arg("vertices"), py::arg("collisions"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"),
+            py::arg("normal_potential"), py::arg("normal_stiffness"),
             py::arg("mus"), py::arg("blend_mu"))
         .def(
             "__len__", &TangentialCollisions::size,

python/src/collisions/tangential/vertex_vertex.cpp

@@ -16,7 +16,7 @@ void define_vertex_vertex_tangential_collision(py::module_& m)
         .def(
             py::init<
                 const VertexVertexNormalCollision&, const VectorMax12d&,
-                const BarrierPotential&, const double>(),
+                const NormalPotential&, const double>(),
             py::arg("collision"), py::arg("positions"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"));
+            py::arg("normal_potential"), py::arg("normal_stiffness"));
 }

python/src/potentials/tangential_potential.cpp

@@ -32,7 +32,7 @@ void define_tangential_potential(py::module_& m)
             py::overload_cast<
                 const TangentialCollisions&, const CollisionMesh&,
                 const Eigen::MatrixXd&, const Eigen::MatrixXd&,
-                const Eigen::MatrixXd&, const BarrierPotential&, const double,
+                const Eigen::MatrixXd&, const NormalPotential&, const double,
                 const double, const bool>(
                 &TangentialPotential::force, py::const_),
             R"ipc_Qu8mg5v7(
@@ -44,8 +44,8 @@ void define_tangential_potential(py::module_& m)
                 rest_positions: Rest positions of the vertices (rowwise).
                 lagged_displacements: Previous displacements of the vertices (rowwise).
                 velocities: Current displacements of the vertices (rowwise).
-                barrier_potential: Barrier potential (used for normal force magnitude).
-                barrier_stiffness: Barrier stiffness (used for normal force magnitude).
+                normal_potential: Normal potential (used for normal force magnitude).
+                normal_stiffness: Normal stiffness (used for normal force magnitude).
                 dmin: Minimum distance (used for normal force magnitude).
                 no_mu: whether to not multiply by mu
 
@@ -54,14 +54,14 @@ void define_tangential_potential(py::module_& m)
             )ipc_Qu8mg5v7",
             py::arg("collisions"), py::arg("mesh"), py::arg("rest_positions"),
             py::arg("lagged_displacements"), py::arg("velocities"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"),
+            py::arg("normal_potential"), py::arg("normal_stiffness"),
             py::arg("dmin") = 0, py::arg("no_mu") = false)
         .def(
             "force_jacobian",
             py::overload_cast<
                 const TangentialCollisions&, const CollisionMesh&,
                 const Eigen::MatrixXd&, const Eigen::MatrixXd&,
-                const Eigen::MatrixXd&, const BarrierPotential&, const double,
+                const Eigen::MatrixXd&, const NormalPotential&, const double,
                 const TangentialPotential::DiffWRT, const double>(
                 &TangentialPotential::force_jacobian, py::const_),
             R"ipc_Qu8mg5v7(
@@ -73,8 +73,8 @@ void define_tangential_potential(py::module_& m)
                 rest_positions: Rest positions of the vertices (rowwise).
                 lagged_displacements: Previous displacements of the vertices (rowwise).
                 velocities: Current displacements of the vertices (rowwise).
-                barrier_potential: Barrier potential (used for normal force magnitude).
-                barrier_stiffness: Barrier stiffness (used for normal force magnitude).
+                normal_potential: Normal potential (used for normal force magnitude).
+                normal_stiffness: Normal stiffness (used for normal force magnitude).
                 wrt: The variable to take the derivative with respect to.
                 dmin: Minimum distance (used for normal force magnitude).
 
@@ -83,14 +83,14 @@ void define_tangential_potential(py::module_& m)
             )ipc_Qu8mg5v7",
             py::arg("collisions"), py::arg("mesh"), py::arg("rest_positions"),
             py::arg("lagged_displacements"), py::arg("velocities"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"),
+            py::arg("normal_potential"), py::arg("normal_stiffness"),
             py::arg("wrt"), py::arg("dmin") = 0)
         .def(
             "force",
             py::overload_cast<
                 const TangentialCollision&, const VectorMax12d&,
                 const VectorMax12d&, const VectorMax12d&,
-                const BarrierPotential&, const double, const double,
+                const NormalPotential&, const double, const double,
                 const bool>(&TangentialPotential::force, py::const_),
             R"ipc_Qu8mg5v7(
             Compute the friction force.
@@ -100,8 +100,8 @@ void define_tangential_potential(py::module_& m)
                 rest_positions: Rest positions of the vertices (rowwise).
                 lagged_displacements: Previous displacements of the vertices (rowwise).
                 velocities: Current displacements of the vertices (rowwise).
-                barrier_potential: Barrier potential (used for normal force magnitude).
-                barrier_stiffness: Barrier stiffness (used for normal force magnitude).
+                normal_potential: Normal potential (used for normal force magnitude).
+                normal_stiffness: Normal stiffness (used for normal force magnitude).
                 dmin: Minimum distance (used for normal force magnitude).
                 no_mu: Whether to not multiply by mu
 
@@ -110,14 +110,14 @@ void define_tangential_potential(py::module_& m)
             )ipc_Qu8mg5v7",
             py::arg("collision"), py::arg("rest_positions"),
             py::arg("lagged_displacements"), py::arg("velocities"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"),
+            py::arg("normal_potential"), py::arg("normal_stiffness"),
             py::arg("dmin") = 0, py::arg("no_mu") = false)
         .def(
             "force_jacobian",
             py::overload_cast<
                 const TangentialCollision&, const VectorMax12d&,
                 const VectorMax12d&, const VectorMax12d&,
-                const BarrierPotential&, const double,
+                const NormalPotential&, const double,
                 const TangentialPotential::DiffWRT, const double>(
                 &TangentialPotential::force_jacobian, py::const_),
             R"ipc_Qu8mg5v7(
@@ -128,8 +128,8 @@ void define_tangential_potential(py::module_& m)
                 rest_positions: Rest positions of the vertices (rowwise).
                 lagged_displacements: Previous displacements of the vertices (rowwise).
                 velocities: Current displacements of the vertices (rowwise).
-                barrier_potential: Barrier potential (used for normal force magnitude).
-                barrier_stiffness: Barrier stiffness (used for normal force magnitude).
+                normal_potential: Normal potential (used for normal force magnitude).
+                normal_stiffness: Normal stiffness (used for normal force magnitude).
                 wrt: Variable to differentiate the friction force with respect to.
                 dmin: Minimum distance (used for normal force magnitude).
 
@@ -138,6 +138,6 @@ void define_tangential_potential(py::module_& m)
             )ipc_Qu8mg5v7",
             py::arg("collision"), py::arg("rest_positions"),
             py::arg("lagged_displacements"), py::arg("velocities"),
-            py::arg("barrier_potential"), py::arg("barrier_stiffness"),
+            py::arg("normal_potential"), py::arg("normal_stiffness"),
             py::arg("wrt"), py::arg("dmin") = 0);
 }