clang-format

Author: antoinebou12

python/src/friction/collisions/edge_edge.cpp

@@ -12,7 +12,8 @@ void define_edge_edge_friction_collision(py::module_& m)
         .def(
             py::init<
                 const EdgeEdgeCollision&, const VectorMax12d&,
-                const BarrierPotential&, const double, const double, const double>(),
+                const BarrierPotential&, const double, const double,
+                const double>(),
             py::arg("collision"), py::arg("positions"),
             py::arg("barrier_potential"), py::arg("barrier_stiffness"),
             py::arg("static_mu"), py::arg("kinetic_mu"));

python/src/friction/collisions/edge_vertex.cpp

@@ -14,7 +14,8 @@ void define_edge_vertex_friction_collision(py::module_& m)
         .def(
             py::init<
                 const EdgeVertexCollision&, const VectorMax12d&,
-                const BarrierPotential&, const double, const double, const double>(),
+                const BarrierPotential&, const double, const double,
+                const double>(),
             py::arg("collision"), py::arg("positions"),
             py::arg("barrier_potential"), py::arg("barrier_stiffness"),
             py::arg("static_mu"), py::arg("kinetic_mu"));

python/src/friction/collisions/face_vertex.cpp

@@ -14,7 +14,8 @@ void define_face_vertex_friction_collision(py::module_& m)
         .def(
             py::init<
                 const FaceVertexCollision&, const VectorMax12d&,
-                const BarrierPotential&, const double, const double, const double>(),
+                const BarrierPotential&, const double, const double,
+                const double>(),
             py::arg("collision"), py::arg("positions"),
             py::arg("barrier_potential"), py::arg("barrier_stiffness"),
             py::arg("static_mu"), py::arg("kinetic_mu"));

python/src/friction/collisions/vertex_vertex.cpp

@@ -14,7 +14,8 @@ void define_vertex_vertex_friction_collision(py::module_& m)
         .def(
             py::init<
                 const VertexVertexCollision&, const VectorMax12d&,
-                const BarrierPotential&, const double, const double, const double>(),
+                const BarrierPotential&, const double, const double,
+                const double>(),
             py::arg("collision"), py::arg("positions"),
             py::arg("barrier_potential"), py::arg("barrier_stiffness"),
             py::arg("static_mu"), py::arg("kinetic_mu"));

python/src/friction/friction_collisions.cpp

@@ -36,7 +36,8 @@ void define_friction_collisions(py::module_& m)
             py::overload_cast<
                 const CollisionMesh&, const Eigen::MatrixXd&, const Collisions&,
                 const BarrierPotential&, const double, const Eigen::VectorXd&,
-                const std::function<double(double, double, std::optional<BlendType>)>&>(
+                const std::function<double(
+                    double, double, std::optional<BlendType>)>&>(
                 &FrictionCollisions::build),
             py::arg("mesh"), py::arg("vertices"), py::arg("collisions"),
             py::arg("barrier_potential"), py::arg("barrier_stiffness"),
@@ -45,8 +46,10 @@ void define_friction_collisions(py::module_& m)
             "build",
             py::overload_cast<
                 const CollisionMesh&, const Eigen::MatrixXd&, const Collisions&,
-                const BarrierPotential&, const double, const double, const double,
-                const std::map<std::tuple<int, int>, std::pair<double, double>>&>(
+                const BarrierPotential&, const double, const double,
+                const double,
+                const std::map<
+                    std::tuple<int, int>, std::pair<double, double>>&>(
                 &FrictionCollisions::build),
             py::arg("mesh"), py::arg("vertices"), py::arg("collisions"),
             py::arg("barrier_potential"), py::arg("barrier_stiffness"),
@@ -65,11 +68,14 @@ void define_friction_collisions(py::module_& m)
                 kinetic_mu: Global kinetic friction coefficient.
                 pairwise_friction: Pairwise static and kinetic friction coefficients.
             )ipc_Qu8mg5v7")
-        .def("__len__", &FrictionCollisions::size,
+        .def(
+            "__len__", &FrictionCollisions::size,
             "Get the number of friction collisions.")
-        .def("empty", &FrictionCollisions::empty,
+        .def(
+            "empty", &FrictionCollisions::empty,
             "Get if the friction collisions are empty.")
-        .def("clear", &FrictionCollisions::clear,
+        .def(
+            "clear", &FrictionCollisions::clear,
             "Clear the friction collisions.")
         .def(
             "__getitem__",
@@ -87,7 +93,8 @@ void define_friction_collisions(py::module_& m)
                 A reference to the collision.
             )ipc_Qu8mg5v7",
             py::arg("i"))
-        .def_static("default_blend_mu", &FrictionCollisions::default_blend_mu,
+        .def_static(
+            "default_blend_mu", &FrictionCollisions::default_blend_mu,
             py::arg("mu0"), py::arg("mu1"), py::arg("type") = std::nullopt)
         .def_readwrite("vv_collisions", &FrictionCollisions::vv_collisions)
         .def_readwrite("ev_collisions", &FrictionCollisions::ev_collisions)

python/src/friction/smooth_friction_mollifier.cpp

@@ -173,7 +173,8 @@ void define_smooth_friction_mollifier(py::module_& m)
         Returns:
             The value of the mollifier function at s, using the appropriate mu (static or kinetic).
         )ipc_Qu8mg5v7",
-        py::arg("s"), py::arg("epsv"), py::arg("static_mu"), py::arg("kinetic_mu"));
+        py::arg("s"), py::arg("epsv"), py::arg("static_mu"),
+        py::arg("kinetic_mu"));
 
     m.def(
         "f1_SF_over_x_pairwise_transition", &f1_SF_over_x_pairwise_transition,
@@ -189,10 +190,12 @@ void define_smooth_friction_mollifier(py::module_& m)
         Returns:
             The value of the derivative of f0_SF divided by s, using the appropriate mu (static or kinetic).
         )ipc_Qu8mg5v7",
-        py::arg("s"), py::arg("epsv"), py::arg("static_mu"), py::arg("kinetic_mu"));
+        py::arg("s"), py::arg("epsv"), py::arg("static_mu"),
+        py::arg("kinetic_mu"));
 
     m.def(
-        "df1_x_minus_f1_over_x3_pairwise_transition", &df1_x_minus_f1_over_x3_pairwise_transition,
+        "df1_x_minus_f1_over_x3_pairwise_transition",
+        &df1_x_minus_f1_over_x3_pairwise_transition,
         R"ipc_Qu8mg5v7(
         The derivative of f1 times s minus f1 all divided by s cubed, using the appropriate mu (static or kinetic).
 
@@ -205,5 +208,6 @@ void define_smooth_friction_mollifier(py::module_& m)
         Returns:
             The derivative of f1 times s minus f1 all divided by s cubed, using the appropriate mu (static or kinetic).
         )ipc_Qu8mg5v7",
-        py::arg("s"), py::arg("epsv"), py::arg("static_mu"), py::arg("kinetic_mu"));
+        py::arg("s"), py::arg("epsv"), py::arg("static_mu"),
+        py::arg("kinetic_mu"));
 }

python/src/potentials/friction_potential.cpp

@@ -33,7 +33,7 @@ void define_friction_potential(py::module_& m)
             py::arg("epsv"))
         .def(
             "__call__",
-            py::overload_cast< 
+            py::overload_cast<
                 const FrictionCollisions&, const CollisionMesh&,
                 const Eigen::MatrixXd&>(
                 &FrictionPotential::Potential::operator(), py::const_),
@@ -147,8 +147,7 @@ void define_friction_potential(py::module_& m)
             py::arg("wrt"), py::arg("dmin") = 0)
         // Adding pairwise friction functions
         .def(
-            "pairwise_force",
-            &FrictionPotential::pairwise_force,
+            "pairwise_force", &FrictionPotential::pairwise_force,
             R"ipc_Qu8mg5v7(
             Compute the pairwise friction force for a collision.
 
@@ -197,8 +196,7 @@ void define_friction_potential(py::module_& m)
             py::arg("wrt"), py::arg("dmin") = 0, py::arg("static_mu"),
             py::arg("kinetic_mu"))
         .def(
-            "pairwise_hessian",
-            &FrictionPotential::pairwise_hessian,
+            "pairwise_hessian", &FrictionPotential::pairwise_hessian,
             R"ipc_Qu8mg5v7(
             Compute the Hessian of the pairwise friction potential.
 

src/ipc/broad_phase/aabb.hpp

@@ -20,8 +20,8 @@ class AABB {
 
     AABB(const AABB& aabb1, const AABB& aabb2, const AABB& aabb3)
         : AABB(
-              aabb1.min.min(aabb2.min).min(aabb3.min),
-              aabb1.max.max(aabb2.max).max(aabb3.max))
+            aabb1.min.min(aabb2.min).min(aabb3.min),
+            aabb1.max.max(aabb2.max).max(aabb3.max))
     {
     }
 

src/ipc/collision_mesh.cpp

@@ -14,11 +14,11 @@ CollisionMesh::CollisionMesh(
     const Eigen::MatrixXi& faces,
     const Eigen::SparseMatrix<double>& displacement_map)
     : CollisionMesh(
-          std::vector<bool>(rest_positions.rows(), true),
-          rest_positions,
-          edges,
-          faces,
-          displacement_map)
+        std::vector<bool>(rest_positions.rows(), true),
+        rest_positions,
+        edges,
+        faces,
+        displacement_map)
 {
 }
 

src/ipc/friction/collisions/edge_edge.cpp

@@ -36,7 +36,8 @@ EdgeEdgeFrictionCollision::EdgeEdgeFrictionCollision(
     : EdgeEdgeFrictionCollision(collision)
 {
     FrictionCollision::init(
-        collision, positions, barrier_potential, barrier_stiffness, static_mu, kinetic_mu);
+        collision, positions, barrier_potential, barrier_stiffness, static_mu,
+        kinetic_mu);
 }
 
 // ============================================================================