2 Written by Xuchen Han <xuchenhan2015@u.northwestern.edu>
4 Bullet Continuous Collision Detection and Physics Library
5 Copyright (c) 2019 Google Inc. http://bulletphysics.org
6 This software is provided 'as-is', without any express or implied warranty.
7 In no event will the authors be held liable for any damages arising from the use of this software.
8 Permission is granted to anyone to use this software for any purpose,
9 including commercial applications, and to alter it and redistribute it freely,
10 subject to the following restrictions:
11 1. 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.
12 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
13 3. This notice may not be removed or altered from any source distribution.
16 #ifndef BT_DEFORMABLE_BODY_SOLVERS_H
17 #define BT_DEFORMABLE_BODY_SOLVERS_H
19 #include "btSoftBodySolvers.h"
20 #include "btDeformableBackwardEulerObjective.h"
21 #include "btDeformableMultiBodyDynamicsWorld.h"
22 #include "BulletDynamics/Featherstone/btMultiBodyLinkCollider.h"
23 #include "BulletDynamics/Featherstone/btMultiBodyConstraint.h"
24 #include "btConjugateResidual.h"
25 #include "btConjugateGradient.h"
26 struct btCollisionObjectWrapper;
27 // class btDeformableBackwardEulerObjective;
28 // class btDeformableMultiBodyDynamicsWorld;
30 class btDeformableBodySolver : public btSoftBodySolver
32 typedef btAlignedObjectArray<btVector3> TVStack;
35 int m_numNodes; // total number of deformable body nodes
36 TVStack m_dv; // v_{n+1} - v_n
37 TVStack m_backup_dv; // backed up dv
38 TVStack m_ddv; // incremental dv
39 TVStack m_residual; // rhs of the linear solve
40 btAlignedObjectArray<btSoftBody*> m_softBodies; // all deformable bodies
41 TVStack m_backupVelocity; // backed up v, equals v_n for implicit, equals v_{n+1}^* for explicit
43 btConjugateGradient<btDeformableBackwardEulerObjective> m_cg; // CG solver
44 btConjugateResidual<btDeformableBackwardEulerObjective> m_cr; // CR solver
45 bool m_implicit; // use implicit scheme if true, explicit scheme if false
46 int m_maxNewtonIterations; // max number of newton iterations
47 btScalar m_newtonTolerance; // stop newton iterations if f(x) < m_newtonTolerance
48 bool m_lineSearch; // If true, use newton's method with line search under implicit scheme
49 bool m_reducedSolver; // flag for reduced soft body solver
51 // handles data related to objective function
52 btDeformableBackwardEulerObjective* m_objective;
55 btDeformableBodySolver();
57 virtual ~btDeformableBodySolver();
59 virtual SolverTypes getSolverType() const
61 return DEFORMABLE_SOLVER;
64 // update soft body normals
65 virtual void updateSoftBodies();
67 virtual btScalar solveContactConstraints(btCollisionObject** deformableBodies, int numDeformableBodies, const btContactSolverInfo& infoGlobal);
69 // solve the momentum equation
70 virtual void solveDeformableConstraints(btScalar solverdt);
72 // set gravity (get from deformable world)
73 virtual void setGravity(const btVector3& gravity)
75 // for full deformable object, we don't store gravity in the solver
76 // this function is overriden in the reduced deformable object
79 // resize/clear data structures
80 virtual void reinitialize(const btAlignedObjectArray<btSoftBody*>& softBodies, btScalar dt);
82 // set up contact constraints
83 virtual void setConstraints(const btContactSolverInfo& infoGlobal);
85 // add in elastic forces and gravity to obtain v_{n+1}^* and calls predictDeformableMotion
86 virtual void predictMotion(btScalar solverdt);
88 // move to temporary position x_{n+1}^* = x_n + dt * v_{n+1}^*
89 // x_{n+1}^* is stored in m_q
90 void predictDeformableMotion(btSoftBody* psb, btScalar dt);
92 // save the current velocity to m_backupVelocity
93 void backupVelocity();
95 // set m_dv and m_backupVelocity to desired value to prepare for momentum solve
96 virtual void setupDeformableSolve(bool implicit);
98 // set the current velocity to that backed up in m_backupVelocity
99 void revertVelocity();
101 // set velocity to m_dv + m_backupVelocity
102 void updateVelocity();
104 // update the node count
107 // calculate the change in dv resulting from the momentum solve
108 void computeStep(TVStack& ddv, const TVStack& residual);
110 // calculate the change in dv resulting from the momentum solve when line search is turned on
111 btScalar computeDescentStep(TVStack& ddv, const TVStack& residual, bool verbose = false);
113 virtual void copySoftBodyToVertexBuffer(const btSoftBody* const softBody, btVertexBufferDescriptor* vertexBuffer) {}
115 // process collision between deformable and rigid
116 virtual void processCollision(btSoftBody* softBody, const btCollisionObjectWrapper* collisionObjectWrap)
118 softBody->defaultCollisionHandler(collisionObjectWrap);
121 // process collision between deformable and deformable
122 virtual void processCollision(btSoftBody* softBody, btSoftBody* otherSoftBody)
124 softBody->defaultCollisionHandler(otherSoftBody);
127 // If true, implicit time stepping scheme is used.
128 // Otherwise, explicit time stepping scheme is used
129 void setImplicit(bool implicit);
131 // If true, newton's method with line search is used when implicit time stepping scheme is turned on
132 void setLineSearch(bool lineSearch);
134 // set temporary position x^* = x_n + dt * v
135 // update the deformation gradient at position x^*
138 // set dv = dv + scale * ddv
139 void updateDv(btScalar scale = 1);
141 // set temporary position x^* = x_n + dt * v^*
142 void updateTempPosition();
144 // save the current dv to m_backup_dv;
147 // set dv to the backed-up value
150 // set dv = dv + scale * ddv
151 // set v^* = v_n + dv
152 // set temporary position x^* = x_n + dt * v^*
153 // update the deformation gradient at position x^*
154 void updateEnergy(btScalar scale);
156 // calculates the appropriately scaled kinetic energy in the system, which is
157 // 1/2 * dv^T * M * dv
158 // used in line search
159 btScalar kineticEnergy();
161 // add explicit force to the velocity in the objective class
162 virtual void applyExplicitForce();
164 // execute position/velocity update and apply anchor constraints in the integrateTransforms from the Dynamics world
165 virtual void applyTransforms(btScalar timeStep);
167 virtual void setStrainLimiting(bool opt)
169 m_objective->m_projection.m_useStrainLimiting = opt;
172 virtual void setPreconditioner(int opt)
176 case btDeformableBackwardEulerObjective::Mass_preconditioner:
177 m_objective->m_preconditioner = m_objective->m_massPreconditioner;
180 case btDeformableBackwardEulerObjective::KKT_preconditioner:
181 m_objective->m_preconditioner = m_objective->m_KKTPreconditioner;
190 virtual btAlignedObjectArray<btDeformableLagrangianForce*>* getLagrangianForceArray()
192 return &(m_objective->m_lf);
195 virtual const btAlignedObjectArray<btSoftBody::Node*>* getIndices()
197 return m_objective->getIndices();
200 virtual void setProjection()
202 m_objective->m_projection.setProjection();
205 virtual void setLagrangeMultiplier()
207 m_objective->m_projection.setLagrangeMultiplier();
210 virtual bool isReducedSolver()
212 return m_reducedSolver;
215 virtual void deformableBodyInternalWriteBack() {}
218 virtual void optimize(btAlignedObjectArray<btSoftBody*>& softBodies, bool forceUpdate = false) {}
219 virtual void solveConstraints(btScalar dt) {}
220 virtual bool checkInitialized() { return true; }
221 virtual void copyBackToSoftBodies(bool bMove = true) {}
224 #endif /* btDeformableBodySolver_h */