Bullet Collision Detection & Physics Library: btDeformableNeoHookeanForce.h Source File

Bullet Collision Detection & Physics Library

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

btDeformableNeoHookeanForce.h
Go to the documentation of this file.
1/*
2Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
3
4Bullet Continuous Collision Detection and Physics Library
5Copyright (c) 2019 Google Inc. http://bulletphysics.org
6This software is provided 'as-is', without any express or implied warranty.
7In no event will the authors be held liable for any damages arising from the use of this software.
8Permission is granted to anyone to use this software for any purpose,
9including commercial applications, and to alter it and redistribute it freely,
10subject to the following restrictions:
111. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
122. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
133. This notice may not be removed or altered from any source distribution.
14*/
15
16#ifndef BT_NEOHOOKEAN_H
17#define BT_NEOHOOKEAN_H
18
19#include "btDeformableLagrangianForce.h"
20#include "LinearMath/btQuickprof.h"
21#include "LinearMath/btImplicitQRSVD.h"
22// This energy is as described in https://graphics.pixar.com/library/StableElasticity/paper.pdf
23 class btDeformableNeoHookeanForce : public btDeformableLagrangianForce
24{
25public:
26 typedef btAlignedObjectArray<btVector3> TVStack;
27 btScalar m_mu, m_lambda; // Lame Parameters
28 btScalar m_E, m_nu; // Young's modulus and Poisson ratio
29 btScalar m_mu_damp, m_lambda_damp;
30 btDeformableNeoHookeanForce() : m_mu(1), m_lambda(1)
31 {
32 btScalar damping = 0.05;
33 m_mu_damp = damping * m_mu;
34 m_lambda_damp = damping * m_lambda;
35 updateYoungsModulusAndPoissonRatio();
36 }
37
38 btDeformableNeoHookeanForce(btScalar mu, btScalar lambda, btScalar damping = 0.05) : m_mu(mu), m_lambda(lambda)
39 {
40 m_mu_damp = damping * m_mu;
41 m_lambda_damp = damping * m_lambda;
42 updateYoungsModulusAndPoissonRatio();
43 }
44
45 void updateYoungsModulusAndPoissonRatio()
46 {
47 // conversion from Lame Parameters to Young's modulus and Poisson ratio
48 // https://en.wikipedia.org/wiki/Lam%C3%A9_parameters
49 m_E = m_mu * (3 * m_lambda + 2 * m_mu) / (m_lambda + m_mu);
50 m_nu = m_lambda * 0.5 / (m_mu + m_lambda);
51 }
52
53 void updateLameParameters()
54 {
55 // conversion from Young's modulus and Poisson ratio to Lame Parameters
56 // https://en.wikipedia.org/wiki/Lam%C3%A9_parameters
57 m_mu = m_E * 0.5 / (1 + m_nu);
58 m_lambda = m_E * m_nu / ((1 + m_nu) * (1 - 2 * m_nu));
59 }
60
61 void setYoungsModulus(btScalar E)
62 {
63 m_E = E;
64 updateLameParameters();
65 }
66
67 void setPoissonRatio(btScalar nu)
68 {
69 m_nu = nu;
70 updateLameParameters();
71 }
72
73 void setDamping(btScalar damping)
74 {
75 m_mu_damp = damping * m_mu;
76 m_lambda_damp = damping * m_lambda;
77 }
78
79 void setLameParameters(btScalar mu, btScalar lambda)
80 {
81 m_mu = mu;
82 m_lambda = lambda;
83 updateYoungsModulusAndPoissonRatio();
84 }
85
86 virtual void addScaledForces(btScalar scale, TVStack& force)
87 {
88 addScaledDampingForce(scale, force);
89 addScaledElasticForce(scale, force);
90 }
91
92 virtual void addScaledExplicitForce(btScalar scale, TVStack& force)
93 {
94 addScaledElasticForce(scale, force);
95 }
96
97 // The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search
98 virtual void addScaledDampingForce(btScalar scale, TVStack& force)
99 {
100 if (m_mu_damp == 0 && m_lambda_damp == 0)
101 return;
102 int numNodes = getNumNodes();
103 btAssert(numNodes <= force.size());
104 btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
105 for (int i = 0; i < m_softBodies.size(); ++i)
106 {
107 btSoftBody* psb = m_softBodies[i];
108 if (!psb->isActive())
109 {
110 continue;
111 }
112 for (int j = 0; j < psb->m_tetras.size(); ++j)
113 {
114 btSoftBody::Tetra& tetra = psb->m_tetras[j];
115 btSoftBody::Node* node0 = tetra.m_n[0];
116 btSoftBody::Node* node1 = tetra.m_n[1];
117 btSoftBody::Node* node2 = tetra.m_n[2];
118 btSoftBody::Node* node3 = tetra.m_n[3];
119 size_t id0 = node0->index;
120 size_t id1 = node1->index;
121 size_t id2 = node2->index;
122 size_t id3 = node3->index;
123 btMatrix3x3 dF = DsFromVelocity(node0, node1, node2, node3) * tetra.m_Dm_inverse;
124 btMatrix3x3 I;
125 I.setIdentity();
126 btMatrix3x3 dP = (dF + dF.transpose()) * m_mu_damp + I * (dF[0][0] + dF[1][1] + dF[2][2]) * m_lambda_damp;
127 // firstPiolaDampingDifferential(psb->m_tetraScratchesTn[j], dF, dP);
128 btVector3 df_on_node0 = dP * (tetra.m_Dm_inverse.transpose() * grad_N_hat_1st_col);
129 btMatrix3x3 df_on_node123 = dP * tetra.m_Dm_inverse.transpose();
130
131 // damping force differential
132 btScalar scale1 = scale * tetra.m_element_measure;
133 force[id0] -= scale1 * df_on_node0;
134 force[id1] -= scale1 * df_on_node123.getColumn(0);
135 force[id2] -= scale1 * df_on_node123.getColumn(1);
136 force[id3] -= scale1 * df_on_node123.getColumn(2);
137 }
138 }
139 }
140
141 virtual double totalElasticEnergy(btScalar dt)
142 {
143 double energy = 0;
144 for (int i = 0; i < m_softBodies.size(); ++i)
145 {
146 btSoftBody* psb = m_softBodies[i];
147 if (!psb->isActive())
148 {
149 continue;
150 }
151 for (int j = 0; j < psb->m_tetraScratches.size(); ++j)
152 {
153 btSoftBody::Tetra& tetra = psb->m_tetras[j];
154 btSoftBody::TetraScratch& s = psb->m_tetraScratches[j];
155 energy += tetra.m_element_measure * elasticEnergyDensity(s);
156 }
157 }
158 return energy;
159 }
160
161 // The damping energy is formulated as in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search
162 virtual double totalDampingEnergy(btScalar dt)
163 {
164 double energy = 0;
165 int sz = 0;
166 for (int i = 0; i < m_softBodies.size(); ++i)
167 {
168 btSoftBody* psb = m_softBodies[i];
169 if (!psb->isActive())
170 {
171 continue;
172 }
173 for (int j = 0; j < psb->m_nodes.size(); ++j)
174 {
175 sz = btMax(sz, psb->m_nodes[j].index);
176 }
177 }
178 TVStack dampingForce;
179 dampingForce.resize(sz + 1);
180 for (int i = 0; i < dampingForce.size(); ++i)
181 dampingForce[i].setZero();
182 addScaledDampingForce(0.5, dampingForce);
183 for (int i = 0; i < m_softBodies.size(); ++i)
184 {
185 btSoftBody* psb = m_softBodies[i];
186 for (int j = 0; j < psb->m_nodes.size(); ++j)
187 {
188 const btSoftBody::Node& node = psb->m_nodes[j];
189 energy -= dampingForce[node.index].dot(node.m_v) / dt;
190 }
191 }
192 return energy;
193 }
194
195 double elasticEnergyDensity(const btSoftBody::TetraScratch& s)
196 {
197 double density = 0;
198 density += m_mu * 0.5 * (s.m_trace - 3.);
199 density += m_lambda * 0.5 * (s.m_J - 1. - 0.75 * m_mu / m_lambda) * (s.m_J - 1. - 0.75 * m_mu / m_lambda);
200 density -= m_mu * 0.5 * log(s.m_trace + 1);
201 return density;
202 }
203
204 virtual void addScaledElasticForce(btScalar scale, TVStack& force)
205 {
206 int numNodes = getNumNodes();
207 btAssert(numNodes <= force.size());
208 btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
209 for (int i = 0; i < m_softBodies.size(); ++i)
210 {
211 btSoftBody* psb = m_softBodies[i];
212 if (!psb->isActive())
213 {
214 continue;
215 }
216 btScalar max_p = psb->m_cfg.m_maxStress;
217 for (int j = 0; j < psb->m_tetras.size(); ++j)
218 {
219 btSoftBody::Tetra& tetra = psb->m_tetras[j];
220 btMatrix3x3 P;
221 firstPiola(psb->m_tetraScratches[j], P);
222#ifdef USE_SVD
223 if (max_p > 0)
224 {
225 // since we want to clamp the principal stress to max_p, we only need to
226 // calculate SVD when sigma_0^2 + sigma_1^2 + sigma_2^2 > max_p * max_p
227 btScalar trPTP = (P[0].length2() + P[1].length2() + P[2].length2());
228 if (trPTP > max_p * max_p)
229 {
230 btMatrix3x3 U, V;
231 btVector3 sigma;
232 singularValueDecomposition(P, U, sigma, V);
233 sigma[0] = btMin(sigma[0], max_p);
234 sigma[1] = btMin(sigma[1], max_p);
235 sigma[2] = btMin(sigma[2], max_p);
236 sigma[0] = btMax(sigma[0], -max_p);
237 sigma[1] = btMax(sigma[1], -max_p);
238 sigma[2] = btMax(sigma[2], -max_p);
239 btMatrix3x3 Sigma;
240 Sigma.setIdentity();
241 Sigma[0][0] = sigma[0];
242 Sigma[1][1] = sigma[1];
243 Sigma[2][2] = sigma[2];
244 P = U * Sigma * V.transpose();
245 }
246 }
247#endif
248 // btVector3 force_on_node0 = P * (tetra.m_Dm_inverse.transpose()*grad_N_hat_1st_col);
249 btMatrix3x3 force_on_node123 = P * tetra.m_Dm_inverse.transpose();
250 btVector3 force_on_node0 = force_on_node123 * grad_N_hat_1st_col;
251
252 btSoftBody::Node* node0 = tetra.m_n[0];
253 btSoftBody::Node* node1 = tetra.m_n[1];
254 btSoftBody::Node* node2 = tetra.m_n[2];
255 btSoftBody::Node* node3 = tetra.m_n[3];
256 size_t id0 = node0->index;
257 size_t id1 = node1->index;
258 size_t id2 = node2->index;
259 size_t id3 = node3->index;
260
261 // elastic force
262 btScalar scale1 = scale * tetra.m_element_measure;
263 force[id0] -= scale1 * force_on_node0;
264 force[id1] -= scale1 * force_on_node123.getColumn(0);
265 force[id2] -= scale1 * force_on_node123.getColumn(1);
266 force[id3] -= scale1 * force_on_node123.getColumn(2);
267 }
268 }
269 }
270
271 // The damping matrix is calculated using the time n state as described in https://www.math.ucla.edu/~jteran/papers/GSSJT15.pdf to allow line search
272 virtual void addScaledDampingForceDifferential(btScalar scale, const TVStack& dv, TVStack& df)
273 {
274 if (m_mu_damp == 0 && m_lambda_damp == 0)
275 return;
276 int numNodes = getNumNodes();
277 btAssert(numNodes <= df.size());
278 btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
279 for (int i = 0; i < m_softBodies.size(); ++i)
280 {
281 btSoftBody* psb = m_softBodies[i];
282 if (!psb->isActive())
283 {
284 continue;
285 }
286 for (int j = 0; j < psb->m_tetras.size(); ++j)
287 {
288 btSoftBody::Tetra& tetra = psb->m_tetras[j];
289 btSoftBody::Node* node0 = tetra.m_n[0];
290 btSoftBody::Node* node1 = tetra.m_n[1];
291 btSoftBody::Node* node2 = tetra.m_n[2];
292 btSoftBody::Node* node3 = tetra.m_n[3];
293 size_t id0 = node0->index;
294 size_t id1 = node1->index;
295 size_t id2 = node2->index;
296 size_t id3 = node3->index;
297 btMatrix3x3 dF = Ds(id0, id1, id2, id3, dv) * tetra.m_Dm_inverse;
298 btMatrix3x3 I;
299 I.setIdentity();
300 btMatrix3x3 dP = (dF + dF.transpose()) * m_mu_damp + I * (dF[0][0] + dF[1][1] + dF[2][2]) * m_lambda_damp;
301 // firstPiolaDampingDifferential(psb->m_tetraScratchesTn[j], dF, dP);
302 // btVector3 df_on_node0 = dP * (tetra.m_Dm_inverse.transpose()*grad_N_hat_1st_col);
303 btMatrix3x3 df_on_node123 = dP * tetra.m_Dm_inverse.transpose();
304 btVector3 df_on_node0 = df_on_node123 * grad_N_hat_1st_col;
305
306 // damping force differential
307 btScalar scale1 = scale * tetra.m_element_measure;
308 df[id0] -= scale1 * df_on_node0;
309 df[id1] -= scale1 * df_on_node123.getColumn(0);
310 df[id2] -= scale1 * df_on_node123.getColumn(1);
311 df[id3] -= scale1 * df_on_node123.getColumn(2);
312 }
313 }
314 }
315
316 virtual void buildDampingForceDifferentialDiagonal(btScalar scale, TVStack& diagA) {}
317
318 virtual void addScaledElasticForceDifferential(btScalar scale, const TVStack& dx, TVStack& df)
319 {
320 int numNodes = getNumNodes();
321 btAssert(numNodes <= df.size());
322 btVector3 grad_N_hat_1st_col = btVector3(-1, -1, -1);
323 for (int i = 0; i < m_softBodies.size(); ++i)
324 {
325 btSoftBody* psb = m_softBodies[i];
326 if (!psb->isActive())
327 {
328 continue;
329 }
330 for (int j = 0; j < psb->m_tetras.size(); ++j)
331 {
332 btSoftBody::Tetra& tetra = psb->m_tetras[j];
333 btSoftBody::Node* node0 = tetra.m_n[0];
334 btSoftBody::Node* node1 = tetra.m_n[1];
335 btSoftBody::Node* node2 = tetra.m_n[2];
336 btSoftBody::Node* node3 = tetra.m_n[3];
337 size_t id0 = node0->index;
338 size_t id1 = node1->index;
339 size_t id2 = node2->index;
340 size_t id3 = node3->index;
341 btMatrix3x3 dF = Ds(id0, id1, id2, id3, dx) * tetra.m_Dm_inverse;
342 btMatrix3x3 dP;
343 firstPiolaDifferential(psb->m_tetraScratches[j], dF, dP);
344 // btVector3 df_on_node0 = dP * (tetra.m_Dm_inverse.transpose()*grad_N_hat_1st_col);
345 btMatrix3x3 df_on_node123 = dP * tetra.m_Dm_inverse.transpose();
346 btVector3 df_on_node0 = df_on_node123 * grad_N_hat_1st_col;
347
348 // elastic force differential
349 btScalar scale1 = scale * tetra.m_element_measure;
350 df[id0] -= scale1 * df_on_node0;
351 df[id1] -= scale1 * df_on_node123.getColumn(0);
352 df[id2] -= scale1 * df_on_node123.getColumn(1);
353 df[id3] -= scale1 * df_on_node123.getColumn(2);
354 }
355 }
356 }
357
358 void firstPiola(const btSoftBody::TetraScratch& s, btMatrix3x3& P)
359 {
360 btScalar c1 = (m_mu * (1. - 1. / (s.m_trace + 1.)));
361 btScalar c2 = (m_lambda * (s.m_J - 1.) - 0.75 * m_mu);
362 P = s.m_F * c1 + s.m_cofF * c2;
363 }
364
365 // Let P be the first piola stress.
366 // This function calculates the dP = dP/dF * dF
367 void firstPiolaDifferential(const btSoftBody::TetraScratch& s, const btMatrix3x3& dF, btMatrix3x3& dP)
368 {
369 btScalar c1 = m_mu * (1. - 1. / (s.m_trace + 1.));
370 btScalar c2 = (2. * m_mu) * DotProduct(s.m_F, dF) * (1. / ((1. + s.m_trace) * (1. + s.m_trace)));
371 btScalar c3 = (m_lambda * DotProduct(s.m_cofF, dF));
372 dP = dF * c1 + s.m_F * c2;
373 addScaledCofactorMatrixDifferential(s.m_F, dF, m_lambda * (s.m_J - 1.) - 0.75 * m_mu, dP);
374 dP += s.m_cofF * c3;
375 }
376
377 // Let Q be the damping stress.
378 // This function calculates the dP = dQ/dF * dF
379 void firstPiolaDampingDifferential(const btSoftBody::TetraScratch& s, const btMatrix3x3& dF, btMatrix3x3& dP)
380 {
381 btScalar c1 = (m_mu_damp * (1. - 1. / (s.m_trace + 1.)));
382 btScalar c2 = ((2. * m_mu_damp) * DotProduct(s.m_F, dF) * (1. / ((1. + s.m_trace) * (1. + s.m_trace))));
383 btScalar c3 = (m_lambda_damp * DotProduct(s.m_cofF, dF));
384 dP = dF * c1 + s.m_F * c2;
385 addScaledCofactorMatrixDifferential(s.m_F, dF, m_lambda_damp * (s.m_J - 1.) - 0.75 * m_mu_damp, dP);
386 dP += s.m_cofF * c3;
387 }
388
389 btScalar DotProduct(const btMatrix3x3& A, const btMatrix3x3& B)
390 {
391 btScalar ans = 0;
392 for (int i = 0; i < 3; ++i)
393 {
394 ans += A[i].dot(B[i]);
395 }
396 return ans;
397 }
398
399 // Let C(A) be the cofactor of the matrix A
400 // Let H = the derivative of C(A) with respect to A evaluated at F = A
401 // This function calculates H*dF
402 void addScaledCofactorMatrixDifferential(const btMatrix3x3& F, const btMatrix3x3& dF, btScalar scale, btMatrix3x3& M)
403 {
404 M[0][0] += scale * (dF[1][1] * F[2][2] + F[1][1] * dF[2][2] - dF[2][1] * F[1][2] - F[2][1] * dF[1][2]);
405 M[1][0] += scale * (dF[2][1] * F[0][2] + F[2][1] * dF[0][2] - dF[0][1] * F[2][2] - F[0][1] * dF[2][2]);
406 M[2][0] += scale * (dF[0][1] * F[1][2] + F[0][1] * dF[1][2] - dF[1][1] * F[0][2] - F[1][1] * dF[0][2]);
407 M[0][1] += scale * (dF[2][0] * F[1][2] + F[2][0] * dF[1][2] - dF[1][0] * F[2][2] - F[1][0] * dF[2][2]);
408 M[1][1] += scale * (dF[0][0] * F[2][2] + F[0][0] * dF[2][2] - dF[2][0] * F[0][2] - F[2][0] * dF[0][2]);
409 M[2][1] += scale * (dF[1][0] * F[0][2] + F[1][0] * dF[0][2] - dF[0][0] * F[1][2] - F[0][0] * dF[1][2]);
410 M[0][2] += scale * (dF[1][0] * F[2][1] + F[1][0] * dF[2][1] - dF[2][0] * F[1][1] - F[2][0] * dF[1][1]);
411 M[1][2] += scale * (dF[2][0] * F[0][1] + F[2][0] * dF[0][1] - dF[0][0] * F[2][1] - F[0][0] * dF[2][1]);
412 M[2][2] += scale * (dF[0][0] * F[1][1] + F[0][0] * dF[1][1] - dF[1][0] * F[0][1] - F[1][0] * dF[0][1]);
413 }
414
415 virtual btDeformableLagrangianForceType getForceType()
416 {
417 return BT_NEOHOOKEAN_FORCE;
418 }
419};
420#endif /* BT_NEOHOOKEAN_H */
btDeformableLagrangianForce.h
btDeformableLagrangianForceType
btDeformableLagrangianForceType
Definition btDeformableLagrangianForce.h:24
BT_NEOHOOKEAN_FORCE
@ BT_NEOHOOKEAN_FORCE
Definition btDeformableLagrangianForce.h:28
btImplicitQRSVD.h
singularValueDecomposition
void singularValueDecomposition(const btMatrix2x2 &A, GivensRotation &U, const btMatrix2x2 &Sigma, GivensRotation &V, const btScalar tol=64 *std::numeric_limits< btScalar >::epsilon())
2x2 SVD (singular value decomposition) A=USV'
Definition btImplicitQRSVD.h:469
btMax
const T & btMax(const T &a, const T &b)
Definition btMinMax.h:27
btMin
const T & btMin(const T &a, const T &b)
Definition btMinMax.h:21
btQuickprof.h
btScalar
float btScalar
The btScalar type abstracts floating point numbers, to easily switch between double and single floati...
Definition btScalar.h:314
btAssert
#define btAssert(x)
Definition btScalar.h:153
btAlignedObjectArray
The btAlignedObjectArray template class uses a subset of the stl::vector interface for its methods It...
Definition btAlignedObjectArray.h:46
btAlignedObjectArray::size
int size() const
return the number of elements in the array
Definition btAlignedObjectArray.h:142
btAlignedObjectArray::resize
void resize(int newsize, const T &fillData=T())
Definition btAlignedObjectArray.h:203
btCollisionObject::isActive
bool isActive() const
Definition btCollisionObject.h:306
btDeformableLagrangianForce
Definition btDeformableLagrangianForce.h:39
btDeformableLagrangianForce::Ds
virtual btMatrix3x3 Ds(int id0, int id1, int id2, int id3, const TVStack &dx)
Definition btDeformableLagrangianForce.h:105
btDeformableLagrangianForce::DsFromVelocity
virtual btMatrix3x3 DsFromVelocity(const btSoftBody::Node *n0, const btSoftBody::Node *n1, const btSoftBody::Node *n2, const btSoftBody::Node *n3)
Definition btDeformableLagrangianForce.h:114
btDeformableLagrangianForce::getNumNodes
virtual int getNumNodes()
Definition btDeformableLagrangianForce.h:78
btDeformableLagrangianForce::m_softBodies
btAlignedObjectArray< btSoftBody * > m_softBodies
Definition btDeformableLagrangianForce.h:42
btDeformableNeoHookeanForce
Definition btDeformableNeoHookeanForce.h:24
btDeformableNeoHookeanForce::addScaledElasticForceDifferential
virtual void addScaledElasticForceDifferential(btScalar scale, const TVStack &dx, TVStack &df)
Definition btDeformableNeoHookeanForce.h:318
btDeformableNeoHookeanForce::btDeformableNeoHookeanForce
btDeformableNeoHookeanForce(btScalar mu, btScalar lambda, btScalar damping=0.05)
Definition btDeformableNeoHookeanForce.h:38
btDeformableNeoHookeanForce::addScaledForces
virtual void addScaledForces(btScalar scale, TVStack &force)
Definition btDeformableNeoHookeanForce.h:86
btDeformableNeoHookeanForce::m_lambda
btScalar m_lambda
Definition btDeformableNeoHookeanForce.h:27
btDeformableNeoHookeanForce::firstPiola
void firstPiola(const btSoftBody::TetraScratch &s, btMatrix3x3 &P)
Definition btDeformableNeoHookeanForce.h:358
btDeformableNeoHookeanForce::m_mu
btScalar m_mu
Definition btDeformableNeoHookeanForce.h:27
btDeformableNeoHookeanForce::setLameParameters
void setLameParameters(btScalar mu, btScalar lambda)
Definition btDeformableNeoHookeanForce.h:79
btDeformableNeoHookeanForce::addScaledDampingForce
virtual void addScaledDampingForce(btScalar scale, TVStack &force)
Definition btDeformableNeoHookeanForce.h:98
btDeformableNeoHookeanForce::TVStack
btAlignedObjectArray< btVector3 > TVStack
Definition btDeformableNeoHookeanForce.h:26
btDeformableNeoHookeanForce::m_nu
btScalar m_nu
Definition btDeformableNeoHookeanForce.h:28
btDeformableNeoHookeanForce::addScaledCofactorMatrixDifferential
void addScaledCofactorMatrixDifferential(const btMatrix3x3 &F, const btMatrix3x3 &dF, btScalar scale, btMatrix3x3 &M)
Definition btDeformableNeoHookeanForce.h:402
btDeformableNeoHookeanForce::m_lambda_damp
btScalar m_lambda_damp
Definition btDeformableNeoHookeanForce.h:29
btDeformableNeoHookeanForce::btDeformableNeoHookeanForce
btDeformableNeoHookeanForce()
Definition btDeformableNeoHookeanForce.h:30
btDeformableNeoHookeanForce::addScaledExplicitForce
virtual void addScaledExplicitForce(btScalar scale, TVStack &force)
Definition btDeformableNeoHookeanForce.h:92
btDeformableNeoHookeanForce::updateYoungsModulusAndPoissonRatio
void updateYoungsModulusAndPoissonRatio()
Definition btDeformableNeoHookeanForce.h:45
btDeformableNeoHookeanForce::setYoungsModulus
void setYoungsModulus(btScalar E)
Definition btDeformableNeoHookeanForce.h:61
btDeformableNeoHookeanForce::addScaledDampingForceDifferential
virtual void addScaledDampingForceDifferential(btScalar scale, const TVStack &dv, TVStack &df)
Definition btDeformableNeoHookeanForce.h:272
btDeformableNeoHookeanForce::totalElasticEnergy
virtual double totalElasticEnergy(btScalar dt)
Definition btDeformableNeoHookeanForce.h:141
btDeformableNeoHookeanForce::DotProduct
btScalar DotProduct(const btMatrix3x3 &A, const btMatrix3x3 &B)
Definition btDeformableNeoHookeanForce.h:389
btDeformableNeoHookeanForce::setDamping
void setDamping(btScalar damping)
Definition btDeformableNeoHookeanForce.h:73
btDeformableNeoHookeanForce::updateLameParameters
void updateLameParameters()
Definition btDeformableNeoHookeanForce.h:53
btDeformableNeoHookeanForce::totalDampingEnergy
virtual double totalDampingEnergy(btScalar dt)
Definition btDeformableNeoHookeanForce.h:162
btDeformableNeoHookeanForce::m_E
btScalar m_E
Definition btDeformableNeoHookeanForce.h:28
btDeformableNeoHookeanForce::firstPiolaDifferential
void firstPiolaDifferential(const btSoftBody::TetraScratch &s, const btMatrix3x3 &dF, btMatrix3x3 &dP)
Definition btDeformableNeoHookeanForce.h:367
btDeformableNeoHookeanForce::addScaledElasticForce
virtual void addScaledElasticForce(btScalar scale, TVStack &force)
Definition btDeformableNeoHookeanForce.h:204
btDeformableNeoHookeanForce::setPoissonRatio
void setPoissonRatio(btScalar nu)
Definition btDeformableNeoHookeanForce.h:67
btDeformableNeoHookeanForce::m_mu_damp
btScalar m_mu_damp
Definition btDeformableNeoHookeanForce.h:29
btDeformableNeoHookeanForce::buildDampingForceDifferentialDiagonal
virtual void buildDampingForceDifferentialDiagonal(btScalar scale, TVStack &diagA)
Definition btDeformableNeoHookeanForce.h:316
btDeformableNeoHookeanForce::elasticEnergyDensity
double elasticEnergyDensity(const btSoftBody::TetraScratch &s)
Definition btDeformableNeoHookeanForce.h:195
btDeformableNeoHookeanForce::getForceType
virtual btDeformableLagrangianForceType getForceType()
Definition btDeformableNeoHookeanForce.h:415
btDeformableNeoHookeanForce::firstPiolaDampingDifferential
void firstPiolaDampingDifferential(const btSoftBody::TetraScratch &s, const btMatrix3x3 &dF, btMatrix3x3 &dP)
Definition btDeformableNeoHookeanForce.h:379
btMatrix3x3
The btMatrix3x3 class implements a 3x3 rotation matrix, to perform linear algebra in combination with...
Definition btMatrix3x3.h:50
btMatrix3x3::transpose
btMatrix3x3 transpose() const
Return the transpose of the matrix.
Definition btMatrix3x3.h:1049
btMatrix3x3::setIdentity
void setIdentity()
Set the matrix to the identity.
Definition btMatrix3x3.h:323
btMatrix3x3::getColumn
btVector3 getColumn(int i) const
Get a column of the matrix as a vector.
Definition btMatrix3x3.h:142
btSoftBody
The btSoftBody is an class to simulate cloth and volumetric soft bodies.
Definition btSoftBody.h:75
btSoftBody::m_tetras
tTetraArray m_tetras
Definition btSoftBody.h:819
btSoftBody::m_cfg
Config m_cfg
Definition btSoftBody.h:808
btSoftBody::m_tetraScratches
btAlignedObjectArray< TetraScratch > m_tetraScratches
Definition btSoftBody.h:820
btSoftBody::m_nodes
tNodeArray m_nodes
Definition btSoftBody.h:814
btVector3
btVector3 can be used to represent 3D points and vectors.
Definition btVector3.h:82
btSoftBody::Config::m_maxStress
btScalar m_maxStress
Definition btSoftBody.h:740
btSoftBody::Node
Definition btSoftBody.h:268
btSoftBody::Node::m_v
btVector3 m_v
Definition btSoftBody.h:271
btSoftBody::Node::index
int index
Definition btSoftBody.h:280
btSoftBody::TetraScratch
Definition btSoftBody.h:332
btSoftBody::TetraScratch::m_J
btScalar m_J
Definition btSoftBody.h:335
btSoftBody::TetraScratch::m_F
btMatrix3x3 m_F
Definition btSoftBody.h:333
btSoftBody::TetraScratch::m_cofF
btMatrix3x3 m_cofF
Definition btSoftBody.h:336
btSoftBody::TetraScratch::m_trace
btScalar m_trace
Definition btSoftBody.h:334
btSoftBody::Tetra
Definition btSoftBody.h:317
btSoftBody::Tetra::m_element_measure
btScalar m_element_measure
Definition btSoftBody.h:326
btSoftBody::Tetra::m_Dm_inverse
btMatrix3x3 m_Dm_inverse
Definition btSoftBody.h:324
btSoftBody::Tetra::m_n
Node * m_n[4]
Definition btSoftBody.h:318