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

Commit b72be86

Browse files
HuangzizhouHuangzizhou
committed
temporary
1 parent e22a89c commit b72be86

14 files changed

+286
-394
lines changed

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

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -90,8 +90,7 @@ class TangentialCollision : virtual public CollisionStencil<4> {
9090
public:
9191
/// @brief Normal force magnitude
9292
double normal_force_magnitude;
93-
std::shared_ptr<SmoothCollision<max_vert_2d>> smooth_collision_2d;
94-
std::shared_ptr<SmoothCollision<max_vert_3d>> smooth_collision_3d;
93+
std::shared_ptr<SmoothCollision> smooth_collision;
9594

9695
/// @brief Ratio between normal and tangential forces (e.g., friction coefficient)
9796
double mu;

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

Lines changed: 18 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -11,11 +11,10 @@
1111

1212
namespace ipc {
1313

14-
template <int dim>
1514
void TangentialCollisions::build_for_smooth_contact(
1615
const CollisionMesh& mesh,
1716
const Eigen::MatrixXd& vertices,
18-
const SmoothCollisions<dim>& collisions,
17+
const SmoothCollisions& collisions,
1918
const ParameterType& params,
2019
const double barrier_stiffness,
2120
const Eigen::VectorXd& mus,
@@ -35,16 +34,16 @@ void TangentialCollisions::build_for_smooth_contact(
3534
for (size_t i = 0; i < collisions.size(); i++) {
3635
const auto& cc = collisions[i];
3736
Eigen::VectorXd contact_potential_grad =
38-
cc.gradient(cc.dof(vertices, edges, faces), params);
37+
cc.gradient(cc.dof(vertices), params);
3938
const double contact_force =
4039
barrier_stiffness * contact_potential_grad.norm();
4140

42-
if constexpr (dim == 3) {
41+
if (mesh.dim() == 3) {
4342
TangentialCollision* ptr = nullptr;
4443
if (const auto cvv = dynamic_cast<const SmoothCollisionTemplate<
45-
max_vert_3d, Point3, Point3>*>(&cc)) {
44+
Point3, Point3>*>(&cc)) {
4645
Eigen::VectorXd collision_points =
47-
cvv->core_dof(vertices, edges, faces);
46+
cvv->core_dof(vertices);
4847
FC_vv.emplace_back(
4948
VertexVertexNormalCollision(
5049
cc[0], cc[1], 1., Eigen::SparseVector<double>()),
@@ -56,10 +55,10 @@ void TangentialCollisions::build_for_smooth_contact(
5655
ptr = &(FC_vv.back());
5756
} else if (
5857
const auto cev = dynamic_cast<
59-
const SmoothCollisionTemplate<max_vert_3d, Edge3, Point3>*>(
58+
const SmoothCollisionTemplate<Edge3, Point3>*>(
6059
&cc)) {
6160
Eigen::VectorXd collision_points =
62-
cev->core_dof(vertices, edges, faces);
61+
cev->core_dof(vertices);
6362
collision_points =
6463
collision_points({ 6, 7, 8, 0, 1, 2, 3, 4, 5 })
6564
.eval(); // {edge, point} -> {point, edge}
@@ -77,11 +76,11 @@ void TangentialCollisions::build_for_smooth_contact(
7776
ptr = &(FC_ev.back());
7877
} else if (
7978
const auto cee = dynamic_cast<
80-
const SmoothCollisionTemplate<max_vert_3d, Edge3, Edge3>*>(
79+
const SmoothCollisionTemplate<Edge3, Edge3>*>(
8180
&cc)) {
8281
Eigen::VectorXd collision_points =
83-
cee->core_dof(vertices, edges, faces);
84-
const auto vert_ids = cee->core_vertex_ids(edges, faces);
82+
cee->core_dof(vertices);
83+
const auto vert_ids = cee->core_vertex_ids();
8584
const Eigen::Vector3d ea0 = vertices.row(vert_ids[0]);
8685
const Eigen::Vector3d ea1 = vertices.row(vert_ids[1]);
8786
const Eigen::Vector3d eb0 = vertices.row(vert_ids[2]);
@@ -108,10 +107,10 @@ void TangentialCollisions::build_for_smooth_contact(
108107
ptr = &(FC_ee.back());
109108
} else if (
110109
const auto cfv = dynamic_cast<
111-
const SmoothCollisionTemplate<max_vert_3d, Face, Point3>*>(
110+
const SmoothCollisionTemplate<Face, Point3>*>(
112111
&cc)) {
113112
Eigen::VectorXd collision_points =
114-
cfv->core_dof(vertices, edges, faces);
113+
cfv->core_dof(vertices);
115114
collision_points =
116115
collision_points({ 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7, 8 })
117116
.eval(); // {face, point} -> {point, face}
@@ -129,13 +128,13 @@ void TangentialCollisions::build_for_smooth_contact(
129128
ptr = &(FC_fv.back());
130129
}
131130
if (ptr)
132-
ptr->smooth_collision_3d = collisions.collisions[i];
131+
ptr->smooth_collision = collisions.collisions[i];
133132
} else {
134133
TangentialCollision* ptr = nullptr;
135134
if (const auto cvv = dynamic_cast<const SmoothCollisionTemplate<
136-
max_vert_2d, Point2, Point2>*>(&cc)) {
135+
Point2, Point2>*>(&cc)) {
137136
Eigen::VectorXd collision_points =
138-
cvv->core_dof(vertices, edges, faces);
137+
cvv->core_dof(vertices);
139138
FC_vv.emplace_back(
140139
VertexVertexNormalCollision(
141140
cc[0], cc[1], 1., Eigen::SparseVector<double>()),
@@ -147,10 +146,10 @@ void TangentialCollisions::build_for_smooth_contact(
147146
ptr = &(FC_vv.back());
148147
} else if (
149148
const auto cev = dynamic_cast<
150-
const SmoothCollisionTemplate<max_vert_2d, Edge2, Point2>*>(
149+
const SmoothCollisionTemplate<Edge2, Point2>*>(
151150
&cc)) {
152151
Eigen::VectorXd collision_points =
153-
cev->core_dof(vertices, edges, faces);
152+
cev->core_dof(vertices);
154153
collision_points =
155154
collision_points({ 4, 5, 0, 1, 2, 3 })
156155
.eval(); // {edge, point} -> {point, edge}
@@ -168,29 +167,11 @@ void TangentialCollisions::build_for_smooth_contact(
168167
ptr = &(FC_ev.back());
169168
}
170169
if (ptr)
171-
ptr->smooth_collision_2d = collisions.collisions[i];
170+
ptr->smooth_collision = collisions.collisions[i];
172171
}
173172
}
174173
}
175174

176-
template void TangentialCollisions::build_for_smooth_contact<2>(
177-
const CollisionMesh& mesh,
178-
const Eigen::MatrixXd& vertices,
179-
const SmoothCollisions<2>& collisions,
180-
const ParameterType& params,
181-
const double barrier_stiffness,
182-
const Eigen::VectorXd& mus,
183-
const std::function<double(double, double)>& blend_mu);
184-
185-
template void TangentialCollisions::build_for_smooth_contact<3>(
186-
const CollisionMesh& mesh,
187-
const Eigen::MatrixXd& vertices,
188-
const SmoothCollisions<3>& collisions,
189-
const ParameterType& params,
190-
const double barrier_stiffness,
191-
const Eigen::VectorXd& mus,
192-
const std::function<double(double, double)>& blend_mu);
193-
194175
void TangentialCollisions::build(
195176
const CollisionMesh& mesh,
196177
Eigen::ConstRef<Eigen::MatrixXd> vertices,

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

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -46,11 +46,10 @@ class TangentialCollisions {
4646
const std::function<double(double, double)>& blend_mu =
4747
default_blend_mu);
4848

49-
template <int dim>
5049
void build_for_smooth_contact(
5150
const CollisionMesh& mesh,
5251
const Eigen::MatrixXd& vertices,
53-
const SmoothCollisions<dim>& collisions,
52+
const SmoothCollisions& collisions,
5453
const ParameterType& params,
5554
const double barrier_stiffness,
5655
const Eigen::VectorXd& mus,

‎src/ipc/potentials/tangential_potential.cpp‎

Lines changed: 9 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -582,32 +582,15 @@ Eigen::SparseMatrix<double> TangentialPotential::smooth_contact_force_jacobian(
582582
// normal_force_grad is the gradient of contact force norm
583583
Eigen::VectorXd normal_force_grad;
584584
std::vector<index_t> cc_vert_ids;
585-
{
586-
Eigen::MatrixXd Xt = rest_positions + lagged_displacements;
587-
if (dim == 2) {
588-
auto cc = collision.smooth_collision_2d;
589-
const Eigen::VectorXd contact_grad =
590-
cc->gradient(cc->dof(Xt, edges, faces), params);
591-
const Eigen::MatrixXd contact_hess =
592-
cc->hessian(cc->dof(Xt, edges, faces), params);
593-
normal_force_grad = (1 / contact_grad.norm())
594-
* (contact_hess * contact_grad);
595-
auto tmp_ids = cc->vertex_ids(edges, faces);
596-
cc_vert_ids =
597-
std::vector(tmp_ids.begin(), tmp_ids.end());
598-
} else if (dim == 3) {
599-
auto cc = collision.smooth_collision_3d;
600-
const Eigen::VectorXd contact_grad =
601-
cc->gradient(cc->dof(Xt, edges, faces), params);
602-
const Eigen::MatrixXd contact_hess =
603-
cc->hessian(cc->dof(Xt, edges, faces), params);
604-
normal_force_grad = (1 / contact_grad.norm())
605-
* (contact_hess * contact_grad);
606-
auto tmp_ids = cc->vertex_ids(edges, faces);
607-
cc_vert_ids =
608-
std::vector(tmp_ids.begin(), tmp_ids.end());
609-
}
610-
}
585+
Eigen::MatrixXd Xt = rest_positions + lagged_displacements;
586+
auto cc = collision.smooth_collision;
587+
const Eigen::VectorXd contact_grad =
588+
cc->gradient(cc->dof(Xt), params);
589+
const Eigen::MatrixXd contact_hess =
590+
cc->hessian(cc->dof(Xt), params);
591+
normal_force_grad = (1 / contact_grad.norm())
592+
* (contact_hess * contact_grad);
593+
cc_vert_ids = cc->vertex_ids();
611594

612595
local_jacobian_to_global_triplets(
613596
local_force * normal_force_grad.transpose(), vis,

0 commit comments

Comments
 (0)