Debian Codegraph @

include/deal.II/physics/elasticity/kinematics.h

raw
1 // ------------------------------------------------------------------------
2 //
3 // SPDX-License-Identifier: LGPL-2.1-or-later
4 // Copyright (C) 2016 - 2024 by the deal.II authors
5 //
6 // This file is part of the deal.II library.
7 //
8 // Part of the source code is dual licensed under Apache-2.0 WITH
9 // LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10 // governing the source code and code contributions can be found in
11 // LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12 //
13 // ------------------------------------------------------------------------
14
15 #ifndef dealii_elasticity_kinematics_h
16 #define dealii_elasticity_kinematics_h
17
18
19 #include <deal.II/base/config.h>
20
21 #include <deal.II/base/numbers.h>
22 #include <deal.II/base/symmetric_tensor.h>
23 #include <deal.II/base/tensor.h>
24
25 #include <deal.II/physics/elasticity/standard_tensors.h>
26
27 DEAL_II_NAMESPACE_OPEN
28
29 namespace Physics
30 {
31 namespace Elasticity
32 {
33 /**
34 * A collection of tensor definitions for deformation and strain measures,
35 * as well as a few special transformations, that conform to notation used
36 * in standard scientific literature, in particular the books of
37 * Holzapfel (2007) and Wriggers (2008). The citation for these references,
38 * as well as other notation used here, can be found in the description for
39 * the Physics::Elasticity namespace.
40 *
41 * @note These hold specifically for the codimension 0 case,
42 * where the metric tensor is the identity tensor.
43 */
44 namespace Kinematics
45 {
46 /**
47 * @name Deformation tensors
48 */
49 /** @{ */
50
51 /**
52 * Return the deformation gradient tensor,
53 * as constructed from the material displacement gradient
54 * tensor @p Grad_u.
55 * The result is expressed as
56 * @f[
57 * \mathbf{F}
58 * \dealcoloneq \nabla_{0} \boldsymbol{\varphi}
59 * \left( \mathbf{X} \right)
60 * =\mathbf{I} + \nabla_{0}\mathbf{u}
61 * @f]
62 * where $\mathbf{u} = \mathbf{u}\left(\mathbf{X}\right)$ is the
63 * displacement at position $\mathbf{X}$ in the referential configuration.
64 * The differential operator $\nabla_{0}$ is defined as
65 * $\frac{\partial}{\partial \mathbf{X}}$.
66 *
67 * @dealiiWriggersA{23,3.14}
68 * @dealiiHolzapfelA{71,2.39}
69 */
70 template <int dim, typename Number>
71 DEAL_II_ALWAYS_INLINE Tensor<2, dim, Number>
72 F(const Tensor<2, dim, Number> &Grad_u);
73
74 /**
75 * Return the isochoric counterpart of the deformation gradient
76 * tensor @p F .
77 * The result is expressed as
78 * @f[
79 * \mathbf{F}^{\text{iso}} \dealcoloneq J^{-1/\textrm{dim}} \mathbf{F}
80 * @f]
81 * where $J = \text{det}\left(\mathbf{F}\right)$.
82 *
83 * @dealiiWriggersA{29,3.28}
84 * @dealiiHolzapfelA{228,6.79}
85 */
86 template <int dim, typename Number>
87 DEAL_II_ALWAYS_INLINE Tensor<2, dim, Number>
88 F_iso(const Tensor<2, dim, Number> &F);
89
90 /**
91 * Return the volumetric counterpart of the deformation gradient
92 * tensor @p F .
93 * The result is expressed as
94 * @f[
95 * \mathbf{F}^{\text{vol}} \dealcoloneq J^{1/\textrm{dim}} \mathbf{I}
96 * @f]
97 * where $J = \text{det}\left(\mathbf{F}\right)$.
98 *
99 * @dealiiWriggersA{29,3.28}
100 * @dealiiHolzapfelA{228,6.79}
101 */
102 template <int dim, typename Number>
103 DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
104 F_vol(const Tensor<2, dim, Number> &F);
105
106 /**
107 * Return the symmetric right Cauchy-Green deformation tensor,
108 * as constructed from the deformation gradient tensor @p F.
109 * The result is expressed as
110 * @f[
111 * \mathbf{C} \dealcoloneq \mathbf{F}^{T}\cdot\mathbf{F} \, .
112 * @f]
113 *
114 * @dealiiWriggersA{23,3.15}
115 * @dealiiHolzapfelA{78,2.65}
116 */
117 template <int dim, typename Number>
118 DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
119 C(const Tensor<2, dim, Number> &F);
120
121 /**
122 * Return the symmetric left Cauchy-Green deformation tensor,
123 * as constructed from the deformation gradient tensor @p F.
124 * The result is expressed as
125 * @f[
126 * \mathbf{b} \dealcoloneq \mathbf{F}\cdot\mathbf{F}^{T} \, .
127 * @f]
128 *
129 * @dealiiWriggersA{28,3.25}
130 * @dealiiHolzapfelA{81,2.79}
131 */
132 template <int dim, typename Number>
133 DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
134 b(const Tensor<2, dim, Number> &F);
135
136 /** @} */
137
138 /**
139 * @name Strain tensors
140 */
141 /** @{ */
142
143 /**
144 * Return the symmetric Green-Lagrange strain tensor,
145 * as constructed from the deformation gradient tensor @p F.
146 * The result is expressed as
147 * @f[
148 * \mathbf{E} \dealcoloneq \frac{1}{2}
149 * \left[ \mathbf{F}^{T}\cdot\mathbf{F} - \mathbf{I} \right] \, .
150 * @f]
151 *
152 * @dealiiWriggersA{23,3.15}
153 * @dealiiHolzapfelA{79,6.29}
154 */
155 template <int dim, typename Number>
156 DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
157 E(const Tensor<2, dim, Number> &F);
158
159 /**
160 * Return the symmetric small strain tensor,
161 * as constructed from the displacement gradient tensor @p Grad_u.
162 * The result is expressed as
163 * @f[
164 * \boldsymbol{\varepsilon} \dealcoloneq \frac{1}{2}
165 * \left[ \nabla_{0}\mathbf{u} + [\nabla_{0}\mathbf{u}]^{T} \right] \, .
166 * @f]
167 * where $\mathbf{u} = \mathbf{u}(\mathbf{X})$ is the displacement at
168 * position
169 * $\mathbf{X}$ in the referential configuration.
170 * The differential operator $\nabla_{0}$ is defined as
171 * $\frac{\partial}{\partial \mathbf{X}}$.
172 *
173 * @dealiiWriggersA{24,3.17}
174 */
175 template <int dim, typename Number>
176 DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
177 epsilon(const Tensor<2, dim, Number> &Grad_u);
178
179 /**
180 * Return the symmetric Almansi strain tensor,
181 * as constructed from the deformation gradient tensor @p F.
182 * The result is expressed as
183 * @f[
184 * \mathbf{e} \dealcoloneq \frac{1}{2} \left[ \mathbf{I}
185 * - \mathbf{F}^{-T}\cdot\mathbf{F}^{-1} \right] \, .
186 * @f]
187 *
188 * @dealiiWriggersA{30,3.35}
189 * @dealiiHolzapfelA{81,2.83}
190 */
191 template <int dim, typename Number>
192 DEAL_II_ALWAYS_INLINE SymmetricTensor<2, dim, Number>
193 e(const Tensor<2, dim, Number> &F);
194
195 /** @} */
196
197 /**
198 * @name Strain rate tensors
199 */
200 /** @{ */
201
202 /**
203 * Return the spatial velocity gradient tensor,
204 * as constructed from the deformation gradient tensor @p F
205 * and its material time derivative @p dF_dt (the material velocity
206 * gradient).
207 * The result is expressed as
208 * @f[
209 * \mathbf{l} \dealcoloneq \dot{\mathbf{F}}\cdot\mathbf{F}^{-1} \, .
210 * @f]
211 *
212 * @dealiiWriggersA{32,3.47}
213 * @dealiiHolzapfelA{96,2.141}
214 */
215 template <int dim, typename Number>
216 Tensor<2, dim, Number>
217 l(const Tensor<2, dim, Number> &F, const Tensor<2, dim, Number> &dF_dt);
218
219 /**
220 * Return the rate of deformation tensor (also known as the rate of strain
221 * tensor), as constructed from the deformation gradient tensor @p F
222 * and its material time derivative @p dF_dt (the material velocity
223 * gradient).
224 * The result is expressed as
225 * @f[
226 * \mathbf{d} \dealcoloneq \frac{1}{2}
227 * \left[ \mathbf{l} + \mathbf{l}^{T} \right]
228 * @f]
229 * where
230 * @f[
231 * \mathbf{l} = \dot{\mathbf{F}}\cdot\mathbf{F}^{-1}
232 * @f]
233 * is the spatial velocity gradient tensor.
234 *
235 * @dealiiWriggersA{32,3.49}
236 * @dealiiHolzapfelA{97,2.148}
237 */
238 template <int dim, typename Number>
239 SymmetricTensor<2, dim, Number>
240 d(const Tensor<2, dim, Number> &F, const Tensor<2, dim, Number> &dF_dt);
241
242 /**
243 * Return the rate of rotation tensor (also known as the vorticity
244 * tensor), as constructed from the deformation gradient tensor @p F
245 * and its material time derivative @p dF_dt (the material velocity
246 * gradient).
247 * The result is expressed as
248 * @f[
249 * \mathbf{w} \dealcoloneq \frac{1}{2}
250 * \left[ \mathbf{l} - \mathbf{l}^{T} \right]
251 * @f]
252 * where
253 * @f[
254 * \mathbf{l} = \dot{\mathbf{F}}\cdot\mathbf{F}^{-1}
255 * @f]
256 * is the spatial velocity gradient tensor.
257 *
258 * @dealiiHolzapfelA{97,2.149}
259 */
260 template <int dim, typename Number>
261 Tensor<2, dim, Number>
262 w(const Tensor<2, dim, Number> &F, const Tensor<2, dim, Number> &dF_dt);
263
264 /** @} */
265 } // namespace Kinematics
266 } // namespace Elasticity
267 } // namespace Physics
268
269
270
271 #ifndef DOXYGEN
272
273 // ------------------------- inline functions ------------------------
274
275
276
277 template <int dim, typename Number>
278 inline Tensor<2, dim, Number>
279 Physics::Elasticity::Kinematics::F(const Tensor<2, dim, Number> &Grad_u)
280 {
281 return StandardTensors<dim>::I + Grad_u;
282 }
283
284
285
286 template <int dim, typename Number>
287 inline Tensor<2, dim, Number>
288 Physics::Elasticity::Kinematics::F_iso(const Tensor<2, dim, Number> &F)
289 {
290 // Make things work with AD types
291 using std::pow;
292 return internal::NumberType<Number>::value(pow(determinant(F), -1.0 / dim)) *
293 F;
294 }
295
296
297
298 template <int dim, typename Number>
299 inline SymmetricTensor<2, dim, Number>
300 Physics::Elasticity::Kinematics::F_vol(const Tensor<2, dim, Number> &F)
301 {
302 // Make things work with AD types
303 using std::pow;
304 return internal::NumberType<Number>::value(pow(determinant(F), 1.0 / dim)) *
305 static_cast<SymmetricTensor<2, dim, Number>>(
306 unit_symmetric_tensor<dim>());
307 }
308
309
310
311 template <int dim, typename Number>
312 inline SymmetricTensor<2, dim, Number>
313 Physics::Elasticity::Kinematics::C(const Tensor<2, dim, Number> &F)
314 {
315 return symmetrize(transpose(F) * F);
316 }
317
318
319
320 template <int dim, typename Number>
321 inline SymmetricTensor<2, dim, Number>
322 Physics::Elasticity::Kinematics::b(const Tensor<2, dim, Number> &F)
323 {
324 return symmetrize(F * transpose(F));
325 }
326
327
328
329 template <int dim, typename Number>
330 inline SymmetricTensor<2, dim, Number>
331 Physics::Elasticity::Kinematics::E(const Tensor<2, dim, Number> &F)
332 {
333 return internal::NumberType<Number>::value(0.5) *
334 (C(F) - static_cast<SymmetricTensor<2, dim, Number>>(
335 StandardTensors<dim>::I));
336 }
337
338
339
340 template <int dim, typename Number>
341 inline SymmetricTensor<2, dim, Number>
342 Physics::Elasticity::Kinematics::epsilon(const Tensor<2, dim, Number> &Grad_u)
343 {
344 // This is the equivalent to 0.5*symmetrize(Grad_u + transpose(Grad_u));
345 return symmetrize(Grad_u);
346 }
347
348
349
350 template <int dim, typename Number>
351 inline SymmetricTensor<2, dim, Number>
352 Physics::Elasticity::Kinematics::e(const Tensor<2, dim, Number> &F)
353 {
354 const Tensor<2, dim, Number> F_inv = invert(F);
355 return internal::NumberType<Number>::value(0.5) *
356 symmetrize(static_cast<SymmetricTensor<2, dim, Number>>(
357 StandardTensors<dim>::I) -
358 transpose(F_inv) * F_inv);
359 }
360
361
362
363 template <int dim, typename Number>
364 inline Tensor<2, dim, Number>
365 Physics::Elasticity::Kinematics::l(const Tensor<2, dim, Number> &F,
366 const Tensor<2, dim, Number> &dF_dt)
367 {
368 return dF_dt * invert(F);
369 }
370
371
372
373 template <int dim, typename Number>
374 inline SymmetricTensor<2, dim, Number>
375 Physics::Elasticity::Kinematics::d(const Tensor<2, dim, Number> &F,
376 const Tensor<2, dim, Number> &dF_dt)
377 {
378 return symmetrize(l(F, dF_dt));
379 }
380
381
382
383 template <int dim, typename Number>
384 inline Tensor<2, dim, Number>
385 Physics::Elasticity::Kinematics::w(const Tensor<2, dim, Number> &F,
386 const Tensor<2, dim, Number> &dF_dt)
387 {
388 // This could be implemented as w = l-d, but that would mean computing "l"
389 // a second time.
390 const auto grad_v = l(F, dF_dt);
391 return internal::NumberType<Number>::value(0.5) *
392 (grad_v - transpose(grad_v));
393 }
394
395 #endif // DOXYGEN
396
397 DEAL_II_NAMESPACE_CLOSE
398
399 #endif