v0.13.2
Loading...
Searching...
No Matches
PlasticOps.hpp
Go to the documentation of this file.
1
2
3/** \file PlasticOps.hpp
4 * \example PlasticOps.hpp
5
6\f[
7\left\{
8\begin{array}{ll}
9\frac{\partial \sigma_{ij}}{\partial x_j} - b_i = 0 & \forall x \in \Omega \\
10\varepsilon_{ij} = \frac{1}{2}\left( \frac{\partial u_i}{\partial x_j} +
11\frac{\partial u_j}{\partial x_i} \right)\\
12\sigma_{ij} = D_{ijkl}\left(\varepsilon_{kl}-\varepsilon^p_{kl}\right) \\
13\dot{\varepsilon}^p_{kl} - \dot{\tau} \left( \left. \frac{\partial f}{\partial
14\sigma_{kl}} \right|_{(\sigma,\tau) } \right) = 0 \\
15f(\sigma, \tau) \leq 0,\; \dot{\tau} \geq 0,\;\dot{\tau}f(\sigma, \tau)=0\\
16u_i = \overline{u}_i & \forall x \in \partial\Omega_u \\
17\sigma_{ij}n_j = \overline{t}_i & \forall x \in \partial\Omega_\sigma \\
18\Omega_u \cup \Omega_\sigma = \Omega \\
19\Omega_u \cap \Omega_\sigma = \emptyset
20\end{array}
21\right.
22\f]
23
24\f[
25\left\{
26\begin{array}{ll}
27\left(\frac{\partial \delta u_i}{\partial x_j},\sigma_{ij}\right)_\Omega-(\delta
28u_i,b_i)_\Omega -(\delta u_i,\overline{t}_i)_{\partial\Omega_\sigma}=0 & \forall
29\delta u_i \in H^1(\Omega)\\ \left(\delta\varepsilon^p_{kl} ,D_{ijkl}\left(
30\dot{\varepsilon}^p_{kl} - \dot{\tau} A_{kl} \right)\right) = 0
31& \forall \delta\varepsilon^p_{ij} \in L^2(\Omega) \cap \mathcal{S} \\
32\left(\delta\tau,c_n\dot{\tau} - \frac{1}{2}\left\{c_n \dot{\tau} +
33(f(\pmb\sigma,\tau) - \sigma_y) +
34\| c_n \dot{\tau} + (f(\pmb\sigma,\tau) - \sigma_y) \|\right\}\right) = 0 &
35\forall \delta\tau \in L^2(\Omega) \end{array} \right.
36\f]
37
38*/
39
40namespace PlasticOps {
41
42//! [Common data]
43struct CommonData : public boost::enable_shared_from_this<CommonData> {
44 boost::shared_ptr<MatrixDouble> mDPtr;
45 boost::shared_ptr<MatrixDouble> mDPtr_Axiator;
46 boost::shared_ptr<MatrixDouble> mDPtr_Deviator;
47 boost::shared_ptr<MatrixDouble> mGradPtr;
48 boost::shared_ptr<MatrixDouble> mStrainPtr;
49 boost::shared_ptr<MatrixDouble> mStressPtr;
50
51 VectorDouble plasticSurface;
52 MatrixDouble plasticFlow;
53 VectorDouble plasticTau;
54 VectorDouble plasticTauDot;
55 MatrixDouble plasticStrain;
56 MatrixDouble plasticStrainDot;
57
58 VectorDouble resC;
59 VectorDouble resCdTau;
60 MatrixDouble resCdStrain;
61 MatrixDouble resCdStrainDot;
62 MatrixDouble resFlow;
63 MatrixDouble resFlowDtau;
64 MatrixDouble resFlowDstrain;
65 MatrixDouble resFlowDstrainDot;
66
67 std::array<int, 5> activityData;
69
70 inline auto getPlasticSurfacePtr() {
71 return boost::shared_ptr<VectorDouble>(shared_from_this(), &plasticSurface);
72 }
73 inline auto getPlasticTauPtr() {
74 return boost::shared_ptr<VectorDouble>(shared_from_this(), &plasticTau);
75 }
76 inline auto getPlasticTauDotPtr() {
77 return boost::shared_ptr<VectorDouble>(shared_from_this(), &plasticTauDot);
78 }
79 inline auto getPlasticStrainPtr() {
80 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &plasticStrain);
81 }
82 inline auto getPlasticStrainDotPtr() {
83 return boost::shared_ptr<MatrixDouble>(shared_from_this(),
85 }
86 inline auto getPlasticFlowPtr() {
87 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &plasticFlow);
88 }
89};
90//! [Common data]
91
100
105
108
109//! [Operators definitions]
111 OpCalculatePlasticSurface(const std::string field_name,
112 boost::shared_ptr<CommonData> common_data_ptr);
113 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
114
115protected:
116 boost::shared_ptr<CommonData> commonDataPtr;
117};
118
120 OpCalculatePlasticity(const std::string field_name, MoFEM::Interface &m_field,
121 boost::shared_ptr<CommonData> common_data_ptr,
122 boost::shared_ptr<MatrixDouble> m_D_ptr);
123 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
124
125protected:
127 boost::shared_ptr<CommonData> commonDataPtr;
128 boost::shared_ptr<MatrixDouble> mDPtr;
129};
130
132 OpPlasticStress(const std::string field_name,
133 boost::shared_ptr<CommonData> common_data_ptr,
134 boost::shared_ptr<MatrixDouble> mDPtr,
135 const double scale = 1);
136 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
137
138private:
139 boost::shared_ptr<MatrixDouble> mDPtr;
140 const double scaleStress;
141 boost::shared_ptr<CommonData> commonDataPtr;
142};
143
145 OpCalculatePlasticFlowRhs(const std::string field_name,
146 boost::shared_ptr<CommonData> common_data_ptr,
147 boost::shared_ptr<MatrixDouble> m_D_ptr);
148 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &data);
149
150private:
151 boost::shared_ptr<CommonData> commonDataPtr;
152 boost::shared_ptr<MatrixDouble> mDPtr;
153};
154
156 OpCalculateConstraintsRhs(const std::string field_name,
157 boost::shared_ptr<CommonData> common_data_ptr,
158 boost::shared_ptr<MatrixDouble> m_D_ptr);
159 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &data);
160
161private:
162 boost::shared_ptr<CommonData> commonDataPtr;
163 boost::shared_ptr<MatrixDouble> mDPtr;
164};
165
168 const std::string row_field_name, const std::string col_field_name,
169 boost::shared_ptr<CommonData> common_data_ptr,
170 boost::shared_ptr<MatrixDouble> m_D_ptr);
171 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
172 EntitiesFieldData::EntData &col_data);
173
174private:
175 boost::shared_ptr<CommonData> commonDataPtr;
176 boost::shared_ptr<MatrixDouble> mDPtr;
177};
178
180 : public AssemblyDomainEleOp {
182 const std::string row_field_name, const std::string col_field_name,
183 boost::shared_ptr<CommonData> common_data_ptr,
184 boost::shared_ptr<HenckyOps::CommonData> common_henky_data_ptr,
185 boost::shared_ptr<MatrixDouble> m_D_ptr);
186 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
187 EntitiesFieldData::EntData &col_data);
188
189private:
190 boost::shared_ptr<CommonData> commonDataPtr;
191 boost::shared_ptr<HenckyOps::CommonData> commonHenckyDataPtr;
192 boost::shared_ptr<MatrixDouble> mDPtr;
193 MatrixDouble locMat;
194 MatrixDouble resDiff;
195};
196
198 OpCalculatePlasticFlowLhs_dU(const std::string row_field_name,
199 const std::string col_field_name,
200 boost::shared_ptr<CommonData> common_data_ptr,
201 boost::shared_ptr<MatrixDouble> m_D_ptr);
202 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
203 EntitiesFieldData::EntData &col_data);
204
205private:
206 boost::shared_ptr<CommonData> commonDataPtr;
207 boost::shared_ptr<MatrixDouble> mDPtr;
208};
209
212 const std::string row_field_name, const std::string col_field_name,
213 boost::shared_ptr<CommonData> common_data_ptr,
214 boost::shared_ptr<HenckyOps::CommonData> comman_henky_data_ptr,
215 boost::shared_ptr<MatrixDouble> m_D_ptr);
216 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
217 EntitiesFieldData::EntData &col_data);
218
219private:
220 boost::shared_ptr<CommonData> commonDataPtr;
221 boost::shared_ptr<HenckyOps::CommonData> commonHenckyDataPtr;
222 boost::shared_ptr<MatrixDouble> mDPtr;
223 MatrixDouble resDiff;
224};
225
227 OpCalculatePlasticFlowLhs_dEP(const std::string row_field_name,
228 const std::string col_field_name,
229 boost::shared_ptr<CommonData> common_data_ptr,
230 boost::shared_ptr<MatrixDouble> m_D_ptr);
231 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
232 EntitiesFieldData::EntData &col_data);
233
234private:
235 boost::shared_ptr<CommonData> commonDataPtr;
236 boost::shared_ptr<MatrixDouble> mDPtr;
237};
238
240 OpCalculatePlasticFlowLhs_dTAU(const std::string row_field_name,
241 const std::string col_field_name,
242 boost::shared_ptr<CommonData> common_data_ptr,
243 boost::shared_ptr<MatrixDouble> m_D_ptr);
244 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
245 EntitiesFieldData::EntData &col_data);
246
247private:
248 boost::shared_ptr<CommonData> commonDataPtr;
249 boost::shared_ptr<MatrixDouble> mDPtr;
250};
251
253 OpCalculateConstraintsLhs_dU(const std::string row_field_name,
254 const std::string col_field_name,
255 boost::shared_ptr<CommonData> common_data_ptr,
256 boost::shared_ptr<MatrixDouble> m_D_ptr);
257 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
258 EntitiesFieldData::EntData &col_data);
259
260private:
261 boost::shared_ptr<CommonData> commonDataPtr;
262 boost::shared_ptr<MatrixDouble> mDPtr;
263};
264
267 const std::string row_field_name, const std::string col_field_name,
268 boost::shared_ptr<CommonData> common_data_ptr,
269 boost::shared_ptr<HenckyOps::CommonData> comman_henky_data_ptr,
270 boost::shared_ptr<MatrixDouble> m_D_ptr);
271 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
272 EntitiesFieldData::EntData &col_data);
273
274private:
275 boost::shared_ptr<CommonData> commonDataPtr;
276 boost::shared_ptr<HenckyOps::CommonData> commonHenckyDataPtr;
277 boost::shared_ptr<MatrixDouble> mDPtr;
278 MatrixDouble resDiff;
279};
280
282 OpCalculateConstraintsLhs_dEP(const std::string row_field_name,
283 const std::string col_field_name,
284 boost::shared_ptr<CommonData> common_data_ptr,
285 boost::shared_ptr<MatrixDouble> mat_D_ptr);
286 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
287 EntitiesFieldData::EntData &col_data);
288
289private:
290 boost::shared_ptr<CommonData> commonDataPtr;
291 boost::shared_ptr<MatrixDouble> mDPtr;
292};
293
295 OpCalculateConstraintsLhs_dTAU(const std::string row_field_name,
296 const std::string col_field_name,
297 boost::shared_ptr<CommonData> common_data_ptr);
298 MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data,
299 EntitiesFieldData::EntData &col_data);
300
301private:
302 boost::shared_ptr<CommonData> commonDataPtr;
303};
304
305//! [Operators definitions]
306
307//! [Lambda functions]
308inline auto diff_tensor() {
311 t_diff(i, j, k, l) = (t_kd(i, k) ^ t_kd(j, l)) / 4.;
312 return t_diff;
313};
314
315inline auto symm_L_tensor() {
317 t_L(i, j, L) = 0;
318 if constexpr (SPACE_DIM == 2) {
319 t_L(0, 0, 0) = 1;
320 t_L(1, 0, 1) = 1;
321 t_L(1, 1, 2) = 1;
322 } else {
323 t_L(0, 0, 0) = 1;
324 t_L(1, 0, 1) = 1;
325 t_L(2, 0, 2) = 1;
326 t_L(1, 1, 3) = 1;
327 t_L(2, 1, 4) = 1;
328 t_L(2, 2, 5) = 1;
329 }
330 return t_L;
331}
332
333inline auto diff_symmetrize() {
335
336 t_diff(i, j, k, l) = 0;
337 t_diff(0, 0, 0, 0) = 1;
338 t_diff(1, 1, 1, 1) = 1;
339
340 t_diff(1, 0, 1, 0) = 0.5;
341 t_diff(1, 0, 0, 1) = 0.5;
342
343 t_diff(0, 1, 0, 1) = 0.5;
344 t_diff(0, 1, 1, 0) = 0.5;
345
346 if constexpr (SPACE_DIM == 3) {
347 t_diff(2, 2, 2, 2) = 1;
348
349 t_diff(2, 0, 2, 0) = 0.5;
350 t_diff(2, 0, 0, 2) = 0.5;
351 t_diff(0, 2, 0, 2) = 0.5;
352 t_diff(0, 2, 2, 0) = 0.5;
353
354 t_diff(2, 1, 2, 1) = 0.5;
355 t_diff(2, 1, 1, 2) = 0.5;
356 t_diff(1, 2, 1, 2) = 0.5;
357 t_diff(1, 2, 2, 1) = 0.5;
358 }
359
360 return t_diff;
361};
362
363template <typename T>
365 constexpr double third = boost::math::constants::third<double>();
366 if constexpr (SPACE_DIM == 2)
367 return (t_stress(0, 0) + t_stress(1, 1)) * third;
368 else
369 return (t_stress(0, 0) + t_stress(1, 1) + t_stress(2, 2)) * third;
370};
371
372template <typename T>
374 double trace) {
376 t_dev(I, J) = 0;
377 for (int ii = 0; ii != SPACE_DIM; ++ii)
378 for (int jj = ii; jj != SPACE_DIM; ++jj)
379 t_dev(ii, jj) = t_stress(ii, jj);
380 t_dev(0, 0) -= trace;
381 t_dev(1, 1) -= trace;
382 t_dev(2, 2) -= trace;
383 return t_dev;
384};
385
386inline auto
389 t_diff_deviator(I, J, k, l) = 0;
390 for (int ii = 0; ii != SPACE_DIM; ++ii)
391 for (int jj = ii; jj != SPACE_DIM; ++jj)
392 for (int kk = 0; kk != SPACE_DIM; ++kk)
393 for (int ll = kk; ll != SPACE_DIM; ++ll)
394 t_diff_deviator(ii, jj, kk, ll) = t_diff_stress(ii, jj, kk, ll);
395
396 constexpr double third = boost::math::constants::third<double>();
397
398 t_diff_deviator(0, 0, 0, 0) -= third;
399 t_diff_deviator(0, 0, 1, 1) -= third;
400
401 t_diff_deviator(1, 1, 0, 0) -= third;
402 t_diff_deviator(1, 1, 1, 1) -= third;
403
404 t_diff_deviator(2, 2, 0, 0) -= third;
405 t_diff_deviator(2, 2, 1, 1) -= third;
406
407 if constexpr (SPACE_DIM == 3) {
408 t_diff_deviator(0, 0, 2, 2) -= third;
409 t_diff_deviator(1, 1, 2, 2) -= third;
410 t_diff_deviator(2, 2, 2, 2) -= third;
411 }
412
413 return t_diff_deviator;
414};
415
416/**
417 *
418
419\f[
420\begin{split}
421f&=\sqrt{s_{ij}s_{ij}}\\
422A_{ij}&=\frac{\partial f}{\partial \sigma_{ij}}=
423\frac{1}{f} s_{kl} \frac{\partial s_{kl}}{\partial \sigma_{ij}}\\
424\frac{\partial A_{ij}}{\partial \sigma_{kl}}&= \frac{\partial^2 f}{\partial
425\sigma_{ij}\partial\sigma_{mn}}= \frac{1}{f} \left( \frac{\partial
426s_{kl}}{\partial \sigma_{mn}}\frac{\partial s_{kl}}{\partial \sigma_{ij}}
427-A_{mn}A_{ij}
428\right)\\
429\frac{\partial f}{\partial \varepsilon_{ij}}&=A_{mn}D_{mnij}
430\\
431\frac{\partial A_{ij}}{\partial \varepsilon_{kl}}&=
432\frac{\partial A_{ij}}{\partial \sigma_{mn}} \frac{\partial
433\sigma_{mn}}{\partial \varepsilon_{kl}}= \frac{\partial A_{ij}}{\partial
434\sigma_{mn}} D_{mnkl}
435\end{split}
436\f]
437
438 */
439inline double
441 return std::sqrt(1.5 * t_stress_deviator(I, J) * t_stress_deviator(I, J)) +
442 std::numeric_limits<double>::epsilon();
443};
444
445inline auto plastic_flow(long double f,
447 FTensor::Ddg<double, 3, SPACE_DIM> &&t_diff_deviator) {
449 t_diff_f(k, l) =
450 (1.5 * (t_dev_stress(I, J) * t_diff_deviator(I, J, k, l))) / f;
451 return t_diff_f;
452};
453
454template <typename T>
456 long double f, FTensor::Tensor2_symmetric<T, SPACE_DIM> &t_flow,
457 FTensor::Ddg<double, 3, SPACE_DIM> &&t_diff_deviator) {
459 t_diff_flow(i, j, k, l) =
460 (1.5 * (t_diff_deviator(M, N, i, j) * t_diff_deviator(M, N, k, l) -
461 (2. / 3.) * t_flow(i, j) * t_flow(k, l))) /
462 f;
463 return t_diff_flow;
464};
465
466template <typename T>
469 FTensor::Ddg<double, SPACE_DIM, SPACE_DIM> &&t_diff_plastic_flow_dstress) {
471 t_diff_flow(i, j, k, l) =
472 t_diff_plastic_flow_dstress(i, j, m, n) * t_D(m, n, k, l);
473 return t_diff_flow;
474};
475
476inline double constrain_diff_sign(double x) {
477 const auto y = x / zeta;
478 if (y > std::numeric_limits<float>::max_exponent10 ||
479 y < std::numeric_limits<float>::min_exponent10) {
480 return 0;
481 } else {
482 const auto e = std::exp(y);
483 const auto ep1 = e + 1;
484 return (2 / zeta) * (e / (ep1 * ep1));
485 }
486};
487
488inline double constrian_sign(double x) {
489 const auto y = x / zeta;
490 if (y > std::numeric_limits<float>::max_exponent10 ||
491 y < std::numeric_limits<float>::min_exponent10) {
492 if (x > 0)
493 return 1.;
494 else
495 return -1.;
496 } else {
497 const auto e = std::exp(y);
498 return (e - 1) / (1 + e);
499 }
500};
501
502inline double constrain_abs(double x) {
503 const auto y = -x / zeta;
504 if (y > std::numeric_limits<float>::max_exponent10 ||
505 y < std::numeric_limits<float>::min_exponent10) {
506 return std::abs(x);
507 } else {
508 const double e = std::exp(y);
509 return x + 2 * zeta * std::log1p(e);
510 }
511};
512
513inline double w(double eqiv, double dot_tau, double f, double sigma_y) {
514 return (f - sigma_y) / sigmaY + cn1 * (dot_tau * std::sqrt(eqiv));
515};
516
517/**
518
519\f[
520\dot{\tau} - \frac{1}{2}\left\{\dot{\tau} + (f(\pmb\sigma) - \sigma_y) +
521\| \dot{\tau} + (f(\pmb\sigma) - \sigma_y) \|\right\} = 0 \\
522c_n \sigma_y \dot{\tau} - \frac{1}{2}\left\{c_n\sigma_y \dot{\tau} +
523(f(\pmb\sigma) - \sigma_y) +
524\| c_n \sigma_y \dot{\tau} + (f(\pmb\sigma) - \sigma_y) \|\right\} = 0
525\f]
526
527 */
528inline double constraint(double eqiv, double dot_tau, double f, double sigma_y,
529 double abs_w) {
530 return visH * dot_tau + (sigmaY / 2) * ((cn0 * (dot_tau - eqiv) +
531 cn1 * (std::sqrt(eqiv) * dot_tau) -
532 (f - sigma_y) / sigmaY) -
533 abs_w);
534};
535
536inline double diff_constrain_ddot_tau(double sign, double eqiv) {
537 return visH + (sigmaY / 2) * (cn0 + cn1 * std::sqrt(eqiv) * (1 - sign));
538};
539
540inline double diff_constrain_eqiv(double sign, double eqiv, double dot_tau) {
541 return (sigmaY / 2) *
542 (-cn0 + cn1 * dot_tau * (0.5 / std::sqrt(eqiv)) * (1 - sign));
543};
544
545inline auto diff_constrain_df(double sign) { return (-1 - sign) / 2; };
546
547inline auto diff_constrain_dsigma_y(double sign) { return (1 + sign) / 2; }
548
549template <typename T>
551 double diff_constrain_df,
553 FTensor::Tensor2_symmetric<double, SPACE_DIM> t_diff_constrain_dstress;
554 t_diff_constrain_dstress(i, j) = diff_constrain_df * t_plastic_flow(i, j);
555 return t_diff_constrain_dstress;
556};
557
558template <typename T1, typename T2>
559inline auto diff_constrain_dstrain(T1 &t_D, T2 &&t_diff_constrain_dstress) {
560 FTensor::Tensor2_symmetric<double, SPACE_DIM> t_diff_constrain_dstrain;
561 t_diff_constrain_dstrain(k, l) =
562 t_diff_constrain_dstress(i, j) * t_D(i, j, k, l);
563 return t_diff_constrain_dstrain;
564};
565
566template <typename T>
568 FTensor::Tensor2_symmetric<T, SPACE_DIM> &t_plastic_strain_dot) {
569 constexpr double A = 2. / 3;
570 return std::sqrt(A * t_plastic_strain_dot(i, j) *
571 t_plastic_strain_dot(i, j)) +
572 std::numeric_limits<double>::epsilon();
573};
574
575template <typename T1, typename T2, typename T3>
576inline auto diff_equivalent_strain_dot(const T1 eqiv, T2 &t_plastic_strain_dot,
577 T3 &t_diff_plastic_strain) {
578 constexpr double A = 2. / 3;
580 t_diff_eqiv(i, j) = A * (t_plastic_strain_dot(k, l) / eqiv) *
581 t_diff_plastic_strain(k, l, i, j);
582 return t_diff_eqiv;
583};
584
585//! [Lambda functions]
586
587//! [Auxiliary functions functions
588static inline auto get_mat_tensor_sym_dvector(size_t rr, MatrixDouble &mat,
591 &mat(3 * rr + 0, 0), &mat(3 * rr + 0, 1), &mat(3 * rr + 1, 0),
592 &mat(3 * rr + 1, 1), &mat(3 * rr + 2, 0), &mat(3 * rr + 2, 1)};
593}
594
595static inline auto get_mat_tensor_sym_dvector(size_t rr, MatrixDouble &mat,
598 &mat(6 * rr + 0, 0), &mat(6 * rr + 0, 1), &mat(6 * rr + 0, 2),
599 &mat(6 * rr + 1, 0), &mat(6 * rr + 1, 1), &mat(6 * rr + 1, 2),
600 &mat(6 * rr + 2, 0), &mat(6 * rr + 2, 1), &mat(6 * rr + 2, 2),
601 &mat(6 * rr + 3, 0), &mat(6 * rr + 3, 1), &mat(6 * rr + 3, 2),
602 &mat(6 * rr + 4, 0), &mat(6 * rr + 4, 1), &mat(6 * rr + 4, 2),
603 &mat(6 * rr + 5, 0), &mat(6 * rr + 5, 1), &mat(6 * rr + 5, 2)};
604}
605
606//! [Auxiliary functions functions
607
608}; // namespace PlasticOps
609
610#include <PlasticOpsGeneric.hpp>
613#include <PlasticOpsMonitor.hpp>
constexpr double third
constexpr int SPACE_DIM
Kronecker Delta class symmetric.
constexpr auto t_kd
auto diff_constrain_dstress(double diff_constrain_df, FTensor::Tensor2_symmetric< T, SPACE_DIM > &t_plastic_flow)
Definition: PlasticOps.hpp:550
auto symm_L_tensor()
Definition: PlasticOps.hpp:315
auto deviator(FTensor::Tensor2_symmetric< T, SPACE_DIM > &t_stress, double trace)
Definition: PlasticOps.hpp:373
double constrian_sign(double x)
Definition: PlasticOps.hpp:488
double platsic_surface(FTensor::Tensor2_symmetric< double, 3 > &&t_stress_deviator)
Definition: PlasticOps.hpp:440
FTensor::Index< 'p', SPACE_DIM > p
Definition: PlasticOps.hpp:99
FTensor::Index< 'j', SPACE_DIM > j
Definition: PlasticOps.hpp:93
FTensor::Index< 'M', 3 > M
Definition: PlasticOps.hpp:103
auto diff_constrain_dstrain(T1 &t_D, T2 &&t_diff_constrain_dstress)
Definition: PlasticOps.hpp:559
double diff_constrain_eqiv(double sign, double eqiv, double dot_tau)
Definition: PlasticOps.hpp:540
double constrain_diff_sign(double x)
Definition: PlasticOps.hpp:476
auto plastic_flow(long double f, FTensor::Tensor2_symmetric< double, 3 > &&t_dev_stress, FTensor::Ddg< double, 3, SPACE_DIM > &&t_diff_deviator)
Definition: PlasticOps.hpp:445
FTensor::Index< 'O', size_symm > O
Definition: PlasticOps.hpp:107
FTensor::Index< 'L', size_symm > L
Definition: PlasticOps.hpp:106
FTensor::Index< 'l', SPACE_DIM > l
Definition: PlasticOps.hpp:95
FTensor::Index< 'k', SPACE_DIM > k
Definition: PlasticOps.hpp:94
auto diff_tensor()
[Operators definitions]
Definition: PlasticOps.hpp:308
auto diff_constrain_df(double sign)
Definition: PlasticOps.hpp:545
double w(double eqiv, double dot_tau, double f, double sigma_y)
Definition: PlasticOps.hpp:513
FTensor::Index< 'N', 3 > N
Definition: PlasticOps.hpp:104
auto diff_constrain_dsigma_y(double sign)
Definition: PlasticOps.hpp:547
FTensor::Index< 'I', 3 > I
Definition: PlasticOps.hpp:101
auto diff_deviator(FTensor::Ddg< double, SPACE_DIM, SPACE_DIM > &&t_diff_stress)
Definition: PlasticOps.hpp:387
FTensor::Index< 'i', SPACE_DIM > i
[Common data]
Definition: PlasticOps.hpp:92
FTensor::Index< 'o', SPACE_DIM > o
Definition: PlasticOps.hpp:98
FTensor::Index< 'm', SPACE_DIM > m
Definition: PlasticOps.hpp:96
double constrain_abs(double x)
Definition: PlasticOps.hpp:502
FTensor::Index< 'J', 3 > J
Definition: PlasticOps.hpp:102
auto diff_equivalent_strain_dot(const T1 eqiv, T2 &t_plastic_strain_dot, T3 &t_diff_plastic_strain)
Definition: PlasticOps.hpp:576
double trace(FTensor::Tensor2_symmetric< T, SPACE_DIM > &t_stress)
Definition: PlasticOps.hpp:364
auto diff_symmetrize()
Definition: PlasticOps.hpp:333
auto diff_plastic_flow_dstress(long double f, FTensor::Tensor2_symmetric< T, SPACE_DIM > &t_flow, FTensor::Ddg< double, 3, SPACE_DIM > &&t_diff_deviator)
Definition: PlasticOps.hpp:455
auto diff_plastic_flow_dstrain(FTensor::Ddg< T, SPACE_DIM, SPACE_DIM > &t_D, FTensor::Ddg< double, SPACE_DIM, SPACE_DIM > &&t_diff_plastic_flow_dstress)
Definition: PlasticOps.hpp:467
double constraint(double eqiv, double dot_tau, double f, double sigma_y, double abs_w)
Definition: PlasticOps.hpp:528
double diff_constrain_ddot_tau(double sign, double eqiv)
Definition: PlasticOps.hpp:536
auto equivalent_strain_dot(FTensor::Tensor2_symmetric< T, SPACE_DIM > &t_plastic_strain_dot)
Definition: PlasticOps.hpp:567
FTensor::Index< 'n', SPACE_DIM > n
Definition: PlasticOps.hpp:97
static auto get_mat_tensor_sym_dvector(size_t rr, MatrixDouble &mat, FTensor::Number< 2 >)
[Lambda functions]
Definition: PlasticOps.hpp:588
constexpr AssemblyType A
double visH
Definition: plastic.cpp:104
double scale
Definition: plastic.cpp:97
double zeta
Definition: plastic.cpp:107
double cn0
Definition: plastic.cpp:105
double sigmaY
Definition: plastic.cpp:102
double cn1
Definition: plastic.cpp:106
constexpr auto field_name
Deprecated interface functions.
Data on single entity (This is passed as argument to DataOperator::doWork)
boost::shared_ptr< MatrixDouble > mStrainPtr
Definition: PlasticOps.hpp:48
MatrixDouble resFlowDstrainDot
Definition: PlasticOps.hpp:65
VectorDouble resCdTau
Definition: PlasticOps.hpp:59
MatrixDouble resCdStrain
Definition: PlasticOps.hpp:60
boost::shared_ptr< MatrixDouble > mGradPtr
Definition: PlasticOps.hpp:47
MatrixDouble resFlow
Definition: PlasticOps.hpp:62
VectorDouble plasticTauDot
Definition: PlasticOps.hpp:54
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:44
VectorDouble plasticSurface
Definition: PlasticOps.hpp:51
boost::shared_ptr< MatrixDouble > mDPtr_Axiator
Definition: PlasticOps.hpp:45
MatrixDouble resFlowDtau
Definition: PlasticOps.hpp:63
MatrixDouble resCdStrainDot
Definition: PlasticOps.hpp:61
MatrixDouble plasticStrain
Definition: PlasticOps.hpp:55
boost::shared_ptr< MatrixDouble > mStressPtr
Definition: PlasticOps.hpp:49
MatrixDouble plasticFlow
Definition: PlasticOps.hpp:52
MatrixDouble plasticStrainDot
Definition: PlasticOps.hpp:56
VectorDouble plasticTau
Definition: PlasticOps.hpp:53
MatrixDouble resFlowDstrain
Definition: PlasticOps.hpp:64
boost::shared_ptr< MatrixDouble > mDPtr_Deviator
Definition: PlasticOps.hpp:46
std::array< int, 5 > activityData
Definition: PlasticOps.hpp:67
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:277
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:275
boost::shared_ptr< HenckyOps::CommonData > commonHenckyDataPtr
Definition: PlasticOps.hpp:276
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:290
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:291
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:302
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:261
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:262
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &data)
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:162
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:163
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:222
boost::shared_ptr< HenckyOps::CommonData > commonHenckyDataPtr
Definition: PlasticOps.hpp:221
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:220
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:236
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:235
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:248
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:249
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:207
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:206
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:152
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:151
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &data)
boost::shared_ptr< HenckyOps::CommonData > commonHenckyDataPtr
Definition: PlasticOps.hpp:191
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:175
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:176
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Operator for linear form, usually to calculate values on right hand side.
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:116
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:127
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:128
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Operator for linear form, usually to calculate values on right hand side.
boost::shared_ptr< CommonData > commonDataPtr
Definition: PlasticOps.hpp:141
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
[Calculate stress]
boost::shared_ptr< MatrixDouble > mDPtr
Definition: PlasticOps.hpp:139