Skip to content
This repository was archived by the owner on Oct 22, 2025. It is now read-only.

Commit 446c384

Browse files
HuangzizhouHuangzizhou
committed
clang formatting
1 parent 9fa2c71 commit 446c384

30 files changed

+1226
-1073
lines changed

‎.github/workflows/coverage.yml‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,16 @@
11
name: Coverage
22

33
on:
4-
push:
5-
branches: [main]
6-
pull_request:
7-
paths:
8-
- '.github/workflows/coverage.yml'
9-
- 'cmake/**'
10-
- 'src/**'
11-
- 'tests/**'
12-
- 'CMakeLists.txt'
13-
- 'codecov.yml'
4+
# push:
5+
# branches: [main]
6+
# pull_request:
7+
# paths:
8+
# - '.github/workflows/coverage.yml'
9+
# - 'cmake/**'
10+
# - 'src/**'
11+
# - 'tests/**'
12+
# - 'CMakeLists.txt'
13+
# - 'codecov.yml'
1414

1515
jobs:
1616
Coverage:

‎.github/workflows/docs.yml‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
name: Docs
22

33
on:
4-
workflow_dispatch:
5-
push:
6-
branches:
7-
- main
8-
- docs
4+
# workflow_dispatch:
5+
# push:
6+
# branches:
7+
# - main
8+
# - docs
99

1010
jobs:
1111
Docs:

‎src/ipc/collisions/tangential/tangential_collisions.cpp‎

Lines changed: 93 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ void TangentialCollisions::build_for_smooth_contact(
1616
const CollisionMesh& mesh,
1717
const Eigen::MatrixXd& vertices,
1818
const SmoothCollisions<dim>& collisions,
19-
const ParameterType &params,
19+
const ParameterType& params,
2020
const double barrier_stiffness,
2121
const Eigen::VectorXd& mus,
2222
const std::function<double(double, double)>& blend_mu)
@@ -34,66 +34,93 @@ void TangentialCollisions::build_for_smooth_contact(
3434
// FC_vv.reserve(C_vv.size());
3535
for (size_t i = 0; i < collisions.size(); i++) {
3636
const auto& cc = collisions[i];
37-
Eigen::VectorXd contact_potential_grad = cc.gradient(cc.dof(vertices, edges, faces), params);
38-
const double contact_force = barrier_stiffness * contact_potential_grad.norm();
37+
Eigen::VectorXd contact_potential_grad =
38+
cc.gradient(cc.dof(vertices, edges, faces), params);
39+
const double contact_force =
40+
barrier_stiffness * contact_potential_grad.norm();
3941

40-
if constexpr (dim == 3)
41-
{
42+
if constexpr (dim == 3) {
4243
TangentialCollision* ptr = nullptr;
43-
if (const auto cvv = dynamic_cast<const SmoothCollisionTemplate<max_vert_3d, Point3, Point3> *>(&cc))
44-
{
45-
Eigen::VectorXd collision_points = cvv->core_dof(vertices, edges, faces);
44+
if (const auto cvv = dynamic_cast<const SmoothCollisionTemplate<
45+
max_vert_3d, Point3, Point3>*>(&cc)) {
46+
Eigen::VectorXd collision_points =
47+
cvv->core_dof(vertices, edges, faces);
4648
FC_vv.emplace_back(
47-
VertexVertexNormalCollision(cc[0], cc[1], 1., Eigen::SparseVector<double>()), collision_points, contact_force);
48-
const auto& [v0i, v1i, _, __] = FC_vv.back().vertex_ids(edges, faces);
49+
VertexVertexNormalCollision(
50+
cc[0], cc[1], 1., Eigen::SparseVector<double>()),
51+
collision_points, contact_force);
52+
const auto& [v0i, v1i, _, __] =
53+
FC_vv.back().vertex_ids(edges, faces);
4954

5055
FC_vv.back().mu = blend_mu(mus(v0i), mus(v1i));
5156
ptr = &(FC_vv.back());
52-
}
53-
else if (const auto cev = dynamic_cast<const SmoothCollisionTemplate<max_vert_3d, Edge3, Point3> *>(&cc))
54-
{
55-
Eigen::VectorXd collision_points = cev->core_dof(vertices, edges, faces);
56-
collision_points = collision_points({6,7,8,0,1,2,3,4,5}).eval(); // {edge, point} -> {point, edge}
57+
} else if (
58+
const auto cev = dynamic_cast<
59+
const SmoothCollisionTemplate<max_vert_3d, Edge3, Point3>*>(
60+
&cc)) {
61+
Eigen::VectorXd collision_points =
62+
cev->core_dof(vertices, edges, faces);
63+
collision_points =
64+
collision_points({ 6, 7, 8, 0, 1, 2, 3, 4, 5 })
65+
.eval(); // {edge, point} -> {point, edge}
5766
FC_ev.emplace_back(
58-
EdgeVertexNormalCollision(cc[0], cc[1], 1., Eigen::SparseVector<double>()), collision_points, contact_force);
59-
const auto& [vi, e0i, e1i, _] = FC_ev.back().vertex_ids(edges, faces);
67+
EdgeVertexNormalCollision(
68+
cc[0], cc[1], 1., Eigen::SparseVector<double>()),
69+
collision_points, contact_force);
70+
const auto& [vi, e0i, e1i, _] =
71+
FC_ev.back().vertex_ids(edges, faces);
6072

6173
const double edge_mu =
62-
(mus(e1i) - mus(e0i)) * FC_ev.back().closest_point[0] + mus(e0i);
74+
(mus(e1i) - mus(e0i)) * FC_ev.back().closest_point[0]
75+
+ mus(e0i);
6376
FC_ev.back().mu = blend_mu(edge_mu, mus(vi));
6477
ptr = &(FC_ev.back());
65-
}
66-
else if (const auto cee = dynamic_cast<const SmoothCollisionTemplate<max_vert_3d, Edge3, Edge3> *>(&cc))
67-
{
68-
Eigen::VectorXd collision_points = cee->core_dof(vertices, edges, faces);
78+
} else if (
79+
const auto cee = dynamic_cast<
80+
const SmoothCollisionTemplate<max_vert_3d, Edge3, Edge3>*>(
81+
&cc)) {
82+
Eigen::VectorXd collision_points =
83+
cee->core_dof(vertices, edges, faces);
6984
const auto vert_ids = cee->core_vertex_ids(edges, faces);
7085
const Eigen::Vector3d ea0 = vertices.row(vert_ids[0]);
7186
const Eigen::Vector3d ea1 = vertices.row(vert_ids[1]);
7287
const Eigen::Vector3d eb0 = vertices.row(vert_ids[2]);
7388
const Eigen::Vector3d eb1 = vertices.row(vert_ids[3]);
7489

7590
// Skip EE collisions that are close to parallel
76-
if (edge_edge_cross_squarednorm(ea0, ea1, eb0, eb1) < edge_edge_mollifier_threshold(ea0, ea1, eb0, eb1)) {
91+
if (edge_edge_cross_squarednorm(ea0, ea1, eb0, eb1)
92+
< edge_edge_mollifier_threshold(ea0, ea1, eb0, eb1)) {
7793
continue;
7894
}
7995

8096
FC_ee.emplace_back(
81-
EdgeEdgeNormalCollision(cc[0], cc[1], 0., EdgeEdgeDistanceType::EA_EB), collision_points, contact_force);
82-
83-
double ea_mu =
84-
(mus(vert_ids[1]) - mus(vert_ids[0])) * FC_ee.back().closest_point[0] + mus(vert_ids[0]);
85-
double eb_mu =
86-
(mus(vert_ids[3]) - mus(vert_ids[2])) * FC_ee.back().closest_point[1] + mus(vert_ids[2]);
97+
EdgeEdgeNormalCollision(
98+
cc[0], cc[1], 0., EdgeEdgeDistanceType::EA_EB),
99+
collision_points, contact_force);
100+
101+
double ea_mu = (mus(vert_ids[1]) - mus(vert_ids[0]))
102+
* FC_ee.back().closest_point[0]
103+
+ mus(vert_ids[0]);
104+
double eb_mu = (mus(vert_ids[3]) - mus(vert_ids[2]))
105+
* FC_ee.back().closest_point[1]
106+
+ mus(vert_ids[2]);
87107
FC_ee.back().mu = blend_mu(ea_mu, eb_mu);
88108
ptr = &(FC_ee.back());
89-
}
90-
else if (const auto cfv = dynamic_cast<const SmoothCollisionTemplate<max_vert_3d, Face, Point3> *>(&cc))
91-
{
92-
Eigen::VectorXd collision_points = cfv->core_dof(vertices, edges, faces);
93-
collision_points = collision_points({9,10,11,0,1,2,3,4,5,6,7,8}).eval(); // {face, point} -> {point, face}
109+
} else if (
110+
const auto cfv = dynamic_cast<
111+
const SmoothCollisionTemplate<max_vert_3d, Face, Point3>*>(
112+
&cc)) {
113+
Eigen::VectorXd collision_points =
114+
cfv->core_dof(vertices, edges, faces);
115+
collision_points =
116+
collision_points({ 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8 })
117+
.eval(); // {face, point} -> {point, face}
94118
FC_fv.emplace_back(
95-
FaceVertexNormalCollision(cc[0], cc[1], 1., Eigen::SparseVector<double>()), collision_points, contact_force);
96-
const auto& [vi, f0i, f1i, f2i] = FC_fv.back().vertex_ids(edges, faces);
119+
FaceVertexNormalCollision(
120+
cc[0], cc[1], 1., Eigen::SparseVector<double>()),
121+
collision_points, contact_force);
122+
const auto& [vi, f0i, f1i, f2i] =
123+
FC_fv.back().vertex_ids(edges, faces);
97124

98125
double face_mu = mus(f0i)
99126
+ FC_fv.back().closest_point[0] * (mus(f1i) - mus(f0i))
@@ -103,30 +130,40 @@ void TangentialCollisions::build_for_smooth_contact(
103130
}
104131
if (ptr)
105132
ptr->smooth_collision_3d = collisions.collisions[i];
106-
}
107-
else
108-
{
133+
} else {
109134
TangentialCollision* ptr = nullptr;
110-
if (const auto cvv = dynamic_cast<const SmoothCollisionTemplate<max_vert_2d, Point2, Point2> *>(&cc))
111-
{
112-
Eigen::VectorXd collision_points = cvv->core_dof(vertices, edges, faces);
135+
if (const auto cvv = dynamic_cast<const SmoothCollisionTemplate<
136+
max_vert_2d, Point2, Point2>*>(&cc)) {
137+
Eigen::VectorXd collision_points =
138+
cvv->core_dof(vertices, edges, faces);
113139
FC_vv.emplace_back(
114-
VertexVertexNormalCollision(cc[0], cc[1], 1., Eigen::SparseVector<double>()), collision_points, contact_force);
115-
const auto& [v0i, v1i, _, __] = FC_vv.back().vertex_ids(edges, faces);
140+
VertexVertexNormalCollision(
141+
cc[0], cc[1], 1., Eigen::SparseVector<double>()),
142+
collision_points, contact_force);
143+
const auto& [v0i, v1i, _, __] =
144+
FC_vv.back().vertex_ids(edges, faces);
116145

117146
FC_vv.back().mu = blend_mu(mus(v0i), mus(v1i));
118147
ptr = &(FC_vv.back());
119-
}
120-
else if (const auto cev = dynamic_cast<const SmoothCollisionTemplate<max_vert_2d, Edge2, Point2> *>(&cc))
121-
{
122-
Eigen::VectorXd collision_points = cev->core_dof(vertices, edges, faces);
123-
collision_points = collision_points({4,5,0,1,2,3}).eval(); // {edge, point} -> {point, edge}
148+
} else if (
149+
const auto cev = dynamic_cast<
150+
const SmoothCollisionTemplate<max_vert_2d, Edge2, Point2>*>(
151+
&cc)) {
152+
Eigen::VectorXd collision_points =
153+
cev->core_dof(vertices, edges, faces);
154+
collision_points =
155+
collision_points({ 4, 5, 0, 1, 2, 3 })
156+
.eval(); // {edge, point} -> {point, edge}
124157
FC_ev.emplace_back(
125-
EdgeVertexNormalCollision(cc[0], cc[1], 1., Eigen::SparseVector<double>()), collision_points, contact_force);
126-
const auto& [vi, e0i, e1i, _] = FC_ev.back().vertex_ids(edges, faces);
158+
EdgeVertexNormalCollision(
159+
cc[0], cc[1], 1., Eigen::SparseVector<double>()),
160+
collision_points, contact_force);
161+
const auto& [vi, e0i, e1i, _] =
162+
FC_ev.back().vertex_ids(edges, faces);
127163

128164
const double edge_mu =
129-
(mus(e1i) - mus(e0i)) * FC_ev.back().closest_point[0] + mus(e0i);
165+
(mus(e1i) - mus(e0i)) * FC_ev.back().closest_point[0]
166+
+ mus(e0i);
130167
FC_ev.back().mu = blend_mu(edge_mu, mus(vi));
131168
ptr = &(FC_ev.back());
132169
}
@@ -136,22 +173,20 @@ void TangentialCollisions::build_for_smooth_contact(
136173
}
137174
}
138175

139-
template
140-
void TangentialCollisions::build_for_smooth_contact<2>(
176+
template void TangentialCollisions::build_for_smooth_contact<2>(
141177
const CollisionMesh& mesh,
142178
const Eigen::MatrixXd& vertices,
143179
const SmoothCollisions<2>& collisions,
144-
const ParameterType &params,
180+
const ParameterType& params,
145181
const double barrier_stiffness,
146182
const Eigen::VectorXd& mus,
147183
const std::function<double(double, double)>& blend_mu);
148184

149-
template
150-
void TangentialCollisions::build_for_smooth_contact<3>(
185+
template void TangentialCollisions::build_for_smooth_contact<3>(
151186
const CollisionMesh& mesh,
152187
const Eigen::MatrixXd& vertices,
153188
const SmoothCollisions<3>& collisions,
154-
const ParameterType &params,
189+
const ParameterType& params,
155190
const double barrier_stiffness,
156191
const Eigen::VectorXd& mus,
157192
const std::function<double(double, double)>& blend_mu);

‎src/ipc/collisions/tangential/tangential_collisions.hpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,12 @@
22

33
#include <ipc/collision_mesh.hpp>
44
#include <ipc/collisions/normal/normal_collisions.hpp>
5-
#include <ipc/smooth_contact/smooth_collisions.hpp>
65
#include <ipc/collisions/tangential/edge_edge.hpp>
76
#include <ipc/collisions/tangential/edge_vertex.hpp>
87
#include <ipc/collisions/tangential/face_vertex.hpp>
98
#include <ipc/collisions/tangential/tangential_collision.hpp>
109
#include <ipc/collisions/tangential/vertex_vertex.hpp>
10+
#include <ipc/smooth_contact/smooth_collisions.hpp>
1111
#include <ipc/utils/eigen_ext.hpp>
1212

1313
#include <Eigen/Core>
@@ -51,7 +51,7 @@ class TangentialCollisions {
5151
const CollisionMesh& mesh,
5252
const Eigen::MatrixXd& vertices,
5353
const SmoothCollisions<dim>& collisions,
54-
const ParameterType &params,
54+
const ParameterType& params,
5555
const double barrier_stiffness,
5656
const Eigen::VectorXd& mus,
5757
const std::function<double(double, double)>& blend_mu =

‎src/ipc/smooth_contact/collisions/smooth_collision.cpp‎

Lines changed: 11 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,8 @@ SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::type() const
3232
}
3333

3434
template <int max_vert, typename PrimitiveA, typename PrimitiveB>
35-
std::string SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::name() const
35+
std::string
36+
SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::name() const
3637
{
3738
if constexpr (
3839
std::is_same_v<PrimitiveA, Edge2> && std::is_same_v<PrimitiveB, Point2>)
@@ -112,8 +113,7 @@ SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::
112113

113114
template <int max_vert, typename PrimitiveA, typename PrimitiveB>
114115
double SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::operator()(
115-
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>>
116-
positions,
116+
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>> positions,
117117
const ParameterType& params) const
118118
{
119119
Vector<double, n_core_points * dim> x;
@@ -144,8 +144,7 @@ double SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::operator()(
144144

145145
template <int max_vert, typename PrimitiveA, typename PrimitiveB>
146146
auto SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::gradient(
147-
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>>
148-
positions,
147+
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>> positions,
149148
const ParameterType& params) const -> Vector<double, -1, max_size>
150149
{
151150
const auto core_indices = get_core_indices();
@@ -253,10 +252,8 @@ auto SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::gradient(
253252
}
254253

255254
template <int max_vert, typename PrimitiveA, typename PrimitiveB>
256-
auto
257-
SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::hessian(
258-
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>>
259-
positions,
255+
auto SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::hessian(
256+
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>> positions,
260257
const ParameterType& params) const -> Eigen::MatrixXd
261258
{
262259
const auto core_indices = get_core_indices();
@@ -384,9 +381,8 @@ SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::hessian(
384381
n_dofs()),
385382
gB = Vector<double, -1, max_size>::Zero(
386383
n_dofs());
387-
Eigen::MatrixXd
388-
hA = Eigen::MatrixXd::Zero(n_dofs(), n_dofs()),
389-
hB = Eigen::MatrixXd::Zero(n_dofs(), n_dofs());
384+
Eigen::MatrixXd hA = Eigen::MatrixXd::Zero(n_dofs(), n_dofs()),
385+
hB = Eigen::MatrixXd::Zero(n_dofs(), n_dofs());
390386
{
391387
gA(core_indices) =
392388
closest_direction_grad.transpose() * gA_reduced.head(dim);
@@ -455,8 +451,7 @@ SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::hessian(
455451
template <int max_vert, typename PrimitiveA, typename PrimitiveB>
456452
double
457453
SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::compute_distance(
458-
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>>
459-
positions) const
454+
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>> positions) const
460455
{
461456
Vector<double, n_core_points * dim> x;
462457
x << positions.head(PrimitiveA::n_core_points * dim),
@@ -473,7 +468,8 @@ SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::compute_distance(
473468
template <int max_vert, typename PrimitiveA, typename PrimitiveB>
474469
auto SmoothCollisionTemplate<max_vert, PrimitiveA, PrimitiveB>::
475470
compute_distance_gradient(
476-
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>> positions) const -> Vector<double, -1, max_size>
471+
Eigen::ConstRef<Vector<double, -1, 3 * max_vert>> positions) const
472+
-> Vector<double, -1, max_size>
477473
{
478474
Vector<double, n_core_points * dim> x;
479475
x << positions.head(PrimitiveA::n_core_points * dim),

0 commit comments

Comments
 (0)