v0.14.0
EshelbianADOL-C.cpp
Go to the documentation of this file.
1 /**
2  * \file EshelbianPlasticity.cpp
3  * \brief Implementation of automatic differentiation
4  */
5 
6 #include <MoFEM.hpp>
7 using namespace MoFEM;
8 
9 #include <MatrixFunction.hpp>
10 
11 #include <EshelbianPlasticity.hpp>
12 
13 #include <EshelbianAux.hpp>
14 
15 #include <boost/math/constants/constants.hpp>
16 
17 constexpr double third = boost::math::constants::third<double>();
18 
19 namespace EshelbianPlasticity {
20 
21 struct OpSpatialPhysical : public OpAssembleVolume {
22 
23  OpSpatialPhysical(const std::string &field_name,
24  boost::shared_ptr<DataAtIntegrationPts> data_ptr,
25  const double alpha_u)
26  : OpAssembleVolume(field_name, data_ptr, OPROW), alphaU(alpha_u) {}
27 
28  MoFEMErrorCode integrate(EntData &data);
29 
30 private:
31  const double alphaU;
32 };
33 
34 MoFEMErrorCode OpSpatialPhysical::integrate(EntData &data) {
35  MoFEMFunctionBegin;
36 
37  FTensor::Index<'L', size_symm> L;
38  auto t_L = symm_L_tensor();
39 
40  int nb_dofs = data.getIndices().size();
41  int nb_integration_pts = data.getN().size1();
42  auto v = getVolume();
43  auto t_w = getFTensor0IntegrationWeight();
44  auto t_approx_P_adjont_log_du =
45  getFTensor1FromMat<size_symm>(dataAtPts->adjointPdUAtPts);
46  auto t_P = getFTensor2FromMat<3, 3>(dataAtPts->PAtPts);
47  auto t_dot_log_u =
48  getFTensor2SymmetricFromMat<3>(dataAtPts->logStretchDotTensorAtPts);
49  auto t_diff_u =
50  getFTensor4DdgFromMat<3, 3, 1>(dataAtPts->diffStretchTensorAtPts);
51 
52  FTensor::Index<'i', 3> i;
53  FTensor::Index<'j', 3> j;
54  FTensor::Index<'k', 3> k;
55  FTensor::Index<'l', 3> l;
56  auto get_ftensor2 = [](auto &v) {
57  return FTensor::Tensor1<FTensor::PackPtr<double *, 6>, 6>(
58  &v[0], &v[1], &v[2], &v[3], &v[4], &v[5]);
59  };
60 
61  int nb_base_functions = data.getN().size2();
62  auto t_row_base_fun = data.getFTensor0N();
63  for (int gg = 0; gg != nb_integration_pts; ++gg) {
64  double a = v * t_w;
65  auto t_nf = get_ftensor2(nF);
66 
67  FTensor::Tensor3<double, 3, 3, size_symm> t_Ldiff_u;
68  t_Ldiff_u(i, j, L) = t_diff_u(i, j, k, l) * t_L(k, l, L);
69 
70  FTensor::Tensor2_symmetric<double, 3> t_viscous_P;
71  t_viscous_P(i, j) =
72  alphaU *
73  t_dot_log_u(i,
74  j); // That is cheat, should be split on axial and deviator
75 
76  FTensor::Tensor1<double, size_symm> t_residual;
77  t_residual(L) =
78  a * (t_approx_P_adjont_log_du(L) - t_Ldiff_u(i, j, L) * t_P(i, j) -
79  t_L(i, j, L) * t_viscous_P(i, j));
80 
81  int bb = 0;
82  for (; bb != nb_dofs / 6; ++bb) {
83  t_nf(L) += t_row_base_fun * t_residual(L);
84  ++t_nf;
85  ++t_row_base_fun;
86  }
87  for (; bb != nb_base_functions; ++bb)
88  ++t_row_base_fun;
89 
90  ++t_w;
91  ++t_approx_P_adjont_log_du;
92  ++t_P;
93  ++t_dot_log_u;
94  ++t_diff_u;
95  }
96  MoFEMFunctionReturn(0);
97 }
98 
99 VolUserDataOperator *PhysicalEquations::returnOpSpatialPhysical(
100  const std::string &field_name,
101  boost::shared_ptr<DataAtIntegrationPts> data_ptr, const double alpha_u) {
102  return new OpSpatialPhysical(field_name, data_ptr, alpha_u);
103 }
104 
105 struct OpSpatialPhysical_du_du : public OpAssembleVolume {
106  OpSpatialPhysical_du_du(std::string row_field, std::string col_field,
107  boost::shared_ptr<DataAtIntegrationPts> data_ptr,
108  const double alpha)
109  : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false),
110  alphaU(alpha) {
111  sYmm = false;
112  }
113  MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
114  MoFEMErrorCode integratePiola(EntData &row_data, EntData &col_data);
115 
116 private:
117  const double alphaU;
118  MatrixDouble dP;
119 
120 };
121 
122 MoFEMErrorCode OpSpatialPhysical_du_du::integrate(EntData &row_data,
123  EntData &col_data) {
124  return integratePiola(row_data, col_data);
125 }
126 
127 MoFEMErrorCode OpSpatialPhysical_du_du::integratePiola(EntData &row_data,
128  EntData &col_data) {
129  MoFEMFunctionBegin;
130 
131  FTensor::Index<'L', size_symm> L;
132  FTensor::Index<'J', size_symm> J;
133  auto t_L = symm_L_tensor();
134  auto t_diff = diff_tensor();
135 
136  int nb_integration_pts = row_data.getN().size1();
137  int row_nb_dofs = row_data.getIndices().size();
138  int col_nb_dofs = col_data.getIndices().size();
139 
140  auto get_ftensor2 = [](MatrixDouble &m, const int r, const int c) {
141  return FTensor::Tensor2<FTensor::PackPtr<double *, 6>, size_symm,
142  size_symm>(
143 
144  &m(r + 0, c + 0), &m(r + 0, c + 1), &m(r + 0, c + 2), &m(r + 0, c + 3),
145  &m(r + 0, c + 4), &m(r + 0, c + 5),
146 
147  &m(r + 1, c + 0), &m(r + 1, c + 1), &m(r + 1, c + 2), &m(r + 1, c + 3),
148  &m(r + 1, c + 4), &m(r + 1, c + 5),
149 
150  &m(r + 2, c + 0), &m(r + 2, c + 1), &m(r + 2, c + 2), &m(r + 2, c + 3),
151  &m(r + 2, c + 4), &m(r + 2, c + 5),
152 
153  &m(r + 3, c + 0), &m(r + 3, c + 1), &m(r + 3, c + 2), &m(r + 3, c + 3),
154  &m(r + 3, c + 4), &m(r + 3, c + 5),
155 
156  &m(r + 4, c + 0), &m(r + 4, c + 1), &m(r + 4, c + 2), &m(r + 4, c + 3),
157  &m(r + 4, c + 4), &m(r + 4, c + 5),
158 
159  &m(r + 5, c + 0), &m(r + 5, c + 1), &m(r + 5, c + 2), &m(r + 5, c + 3),
160  &m(r + 5, c + 4), &m(r + 5, c + 5)
161 
162  );
163  };
164  FTensor::Index<'i', 3> i;
165  FTensor::Index<'j', 3> j;
166  FTensor::Index<'k', 3> k;
167  FTensor::Index<'l', 3> l;
168  FTensor::Index<'m', 3> m;
169  FTensor::Index<'n', 3> n;
170 
171  auto v = getVolume();
172  auto t_w = getFTensor0IntegrationWeight();
173 
174  auto get_dP = [&]() {
175  dP.resize(size_symm * size_symm, nb_integration_pts, false);
176  auto ts_a = getTSa();
177 
178  auto t_P = getFTensor2FromMat<3, 3>(dataAtPts->PAtPts);
179  auto r_P_du = getFTensor4FromMat<3, 3, 3, 3>(dataAtPts->P_du);
180  auto t_approx_P_adjont_dstretch =
181  getFTensor2FromMat<3, 3>(dataAtPts->adjointPdstretchAtPts);
182  auto t_dot_log_u =
183  getFTensor2SymmetricFromMat<3>(dataAtPts->logStretchDotTensorAtPts);
184  auto t_u = getFTensor2SymmetricFromMat<3>(dataAtPts->stretchTensorAtPts);
185  auto t_diff_u =
186  getFTensor4DdgFromMat<3, 3, 1>(dataAtPts->diffStretchTensorAtPts);
187  auto t_eigen_vals = getFTensor1FromMat<3>(dataAtPts->eigenVals);
188  auto t_eigen_vecs = getFTensor2FromMat<3, 3>(dataAtPts->eigenVecs);
189  auto &nbUniq = dataAtPts->nbUniq;
190 
191  auto t_dP = getFTensor2FromMat<size_symm, size_symm>(dP);
192  for (auto gg = 0; gg != nb_integration_pts; ++gg) {
193 
194  FTensor::Tensor2<double, 3, 3> t_deltaP;
195  t_deltaP(i, j) = t_approx_P_adjont_dstretch(i, j) - t_P(i, j);
196 
197  FTensor::Tensor3<double, 3, 3, size_symm> t_Ldiff_u;
198  t_Ldiff_u(i, j, L) = t_diff_u(i, j, m, n) * t_L(m, n, L);
199  t_dP(L, J) =
200  -t_Ldiff_u(i, j, L) * (r_P_du(i, j, k, l) * t_Ldiff_u(k, l, J));
201  // viscous stress derivative
202  t_dP(L, J) -= (alphaU * ts_a) *
203  (t_L(i, j, L) * (t_diff(i, j, k, l) * t_L(k, l, J)));
204 
205  if (EshelbianCore::stretchSelector > LINEAR) {
206  FTensor::Tensor2_symmetric<double, 3> t_deltaP_sym;
207  t_deltaP_sym(i, j) = (t_deltaP(i, j) || t_deltaP(j, i));
208  t_deltaP_sym(i, j) /= 2.0;
209  auto t_diff2_uP2 = EigenMatrix::getDiffDiffMat(
210  t_eigen_vals, t_eigen_vecs, EshelbianCore::f, EshelbianCore::d_f,
211  EshelbianCore::dd_f, t_deltaP_sym, nbUniq[gg]);
212  t_dP(L, J) += t_L(i, j, L) * (t_diff2_uP2(i, j, k, l) * t_L(k, l, J));
213  }
214 
215  ++t_P;
216  ++t_dP;
217  ++r_P_du;
218  ++t_approx_P_adjont_dstretch;
219  ++t_dot_log_u;
220  ++t_u;
221  ++t_diff_u;
222  ++t_eigen_vals;
223  ++t_eigen_vecs;
224  }
225 
226  return getFTensor2FromMat<size_symm, size_symm>(dP);
227  };
228 
229  int row_nb_base_functions = row_data.getN().size2();
230  auto t_row_base_fun = row_data.getFTensor0N();
231 
232  auto t_dP = get_dP();
233  for (int gg = 0; gg != nb_integration_pts; ++gg) {
234  double a = v * t_w;
235 
236  int rr = 0;
237  for (; rr != row_nb_dofs / 6; ++rr) {
238  auto t_col_base_fun = col_data.getFTensor0N(gg, 0);
239  auto t_m = get_ftensor2(K, 6 * rr, 0);
240  for (int cc = 0; cc != col_nb_dofs / 6; ++cc) {
241  const double b = a * t_row_base_fun * t_col_base_fun;
242  t_m(L, J) += b * t_dP(L, J);
243  ++t_m;
244  ++t_col_base_fun;
245  }
246  ++t_row_base_fun;
247  }
248 
249  for (; rr != row_nb_base_functions; ++rr) {
250  ++t_row_base_fun;
251  }
252 
253  ++t_w;
254  ++t_dP;
255  }
256  MoFEMFunctionReturn(0);
257 }
258 
259 VolUserDataOperator *PhysicalEquations::returnOpSpatialPhysical_du_du(
260  std::string row_field, std::string col_field,
261  boost::shared_ptr<DataAtIntegrationPts> data_ptr, const double alpha) {
262  return new OpSpatialPhysical_du_du(row_field, col_field, data_ptr, alpha);
263 }
264 
265 VolUserDataOperator *PhysicalEquations::returnOpCalculateEnergy(
266  boost::shared_ptr<DataAtIntegrationPts> data_ptr,
267  boost::shared_ptr<double> total_energy_ptr) {
268  return nullptr;
269 }
270 
271 VolUserDataOperator *PhysicalEquations::returnOpCalculateStretchFromStress(
272  boost::shared_ptr<DataAtIntegrationPts> data_ptr,
273  boost::shared_ptr<PhysicalEquations> physics_ptr) {
274  return nullptr;
275 }
276 
277 struct OpHMHH : public OpJacobian {
278  OpHMHH(const int tag, const bool eval_rhs, const bool eval_lhs,
279  boost::shared_ptr<DataAtIntegrationPts> data_ptr,
280  boost::shared_ptr<PhysicalEquations> physics_ptr)
281  : OpJacobian(tag, eval_rhs, eval_lhs, data_ptr, physics_ptr) {}
282 
283  MoFEMErrorCode evaluateRhs(EntData &data);
284  MoFEMErrorCode evaluateLhs(EntData &data);
285 };
286 
287 MoFEMErrorCode OpHMHH::evaluateRhs(EntData &ent_data) {
288  MoFEMFunctionBegin;
289  FTensor::Index<'i', 3> i;
290  FTensor::Index<'j', 3> j;
291  FTensor::Index<'k', 3> k;
292  FTensor::Index<'l', 3> l;
293  FTensor::Index<'m', 3> m;
294  FTensor::Index<'n', 3> n;
295 
296  const auto nb_integration_pts = getGaussPts().size2();
297  auto iu = getFTensor2SymmetricFromMat<3>(dataAtPts->stretchTensorAtPts);
298  auto t_grad_h1 = getFTensor2FromMat<3, 3>(dataAtPts->wGradH1AtPts);
299 
300  auto create_data_vec = [nb_integration_pts](auto &v) {
301  v.resize(nb_integration_pts, false);
302  };
303  auto create_data_mat = [nb_integration_pts](auto &m) {
304  m.resize(9, nb_integration_pts, false);
305  };
306 
307  create_data_mat(dataAtPts->PAtPts);
308 
309  constexpr auto t_kd = FTensor::Kronecker_Delta<int>();
310  auto r_P = getFTensor2FromMat<3, 3>(dataAtPts->PAtPts);
311  for (unsigned int gg = 0; gg != nb_integration_pts; ++gg) {
312 
313  FTensor::Tensor2<double, 3, 3> t_h1;
314 
315  switch (EshelbianCore::gradApproximator) {
316  case NO_H1_CONFIGURATION:
317  t_h1(i, j) = t_kd(i, j);
318  physicsPtr->get_h()(i, j) = iu(i, j);
319  break;
320  case LARGE_ROT:
321  case MODERATE_ROT:
322  t_h1(i, j) = t_grad_h1(i, j) + t_kd(i, j);
323  physicsPtr->get_h()(i, j) = iu(i, k) * t_h1(k, j);
324  break;
325  case SMALL_ROT:
326  physicsPtr->get_h()(i, j) = iu(i, j);
327  break;
328  };
329 
330  int r = ::function(tAg, physicsPtr->dependentVariablesPiola.size(),
331  physicsPtr->activeVariables.size(),
332  &physicsPtr->activeVariables[0],
333  &physicsPtr->dependentVariablesPiola[0]);
334  if (r < 0) { // function is locally analytic
335  SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
336  "ADOL-C function evaluation with error r = %d", r);
337  }
338 
339  switch (EshelbianCore::gradApproximator) {
340  case NO_H1_CONFIGURATION:
341  r_P(i, j) = physicsPtr->get_P()(i, j);
342  break;
343  case LARGE_ROT:
344  case MODERATE_ROT: {
345  FTensor::Tensor4<double, 3, 3, 3, 3> t_h1_du;
346  t_h1_du(i, j, m, n) = t_kd(i, m) * (t_kd(k, n) * t_h1(k, j));
347  r_P(k, l) = physicsPtr->get_P()(i, j) * t_h1_du(i, j, k, l);
348  }; break;
349  case SMALL_ROT:
350  r_P(i, j) = physicsPtr->get_P()(i, j);
351  break;
352  };
353 
354  ++iu;
355  ++t_grad_h1;
356  ++r_P;
357  }
358  MoFEMFunctionReturn(0);
359 }
360 
361 MoFEMErrorCode OpHMHH::evaluateLhs(EntData &ent_data) {
362  MoFEMFunctionBegin;
363  FTensor::Index<'i', 3> i;
364  FTensor::Index<'j', 3> j;
365  FTensor::Index<'k', 3> k;
366  FTensor::Index<'l', 3> l;
367  FTensor::Index<'m', 3> m;
368  FTensor::Index<'n', 3> n;
369  FTensor::Index<'o', 3> o;
370  FTensor::Index<'p', 3> p;
371 
372  const int number_of_active_variables = physicsPtr->activeVariables.size();
373  const int number_of_dependent_variables =
374  physicsPtr->dependentVariablesPiola.size();
375  std::vector<double *> jac_ptr(number_of_dependent_variables);
376  for (unsigned int n = 0; n != number_of_dependent_variables; ++n) {
377  jac_ptr[n] =
378  &(physicsPtr
379  ->dependentVariablesPiolaDirevatives[n *
380  number_of_active_variables]);
381  }
382 
383  const auto nb_integration_pts = getGaussPts().size2();
384 
385  auto create_data_mat = [nb_integration_pts](auto &m) {
386  m.resize(9, nb_integration_pts, false);
387  };
388 
389  dataAtPts->P_du.resize(81, nb_integration_pts, false);
390 
391  auto iu = getFTensor2SymmetricFromMat<3>(dataAtPts->stretchTensorAtPts);
392  auto t_grad_h1 = getFTensor2FromMat<3, 3>(dataAtPts->wGradH1AtPts);
393  auto r_P_du = getFTensor4FromMat<3, 3, 3, 3>(dataAtPts->P_du);
394 
395  FTensor::Number<0> N0;
396  FTensor::Number<1> N1;
397  FTensor::Number<2> N2;
398 
399  constexpr auto t_kd = FTensor::Kronecker_Delta<int>();
400 
401  for (unsigned int gg = 0; gg != nb_integration_pts; ++gg) {
402 
403  FTensor::Tensor2<double, 3, 3> t_h1;
404 
405  switch (EshelbianCore::gradApproximator) {
406  case NO_H1_CONFIGURATION:
407  t_h1(i, j) = t_kd(i, j);
408  physicsPtr->get_h()(i, j) = iu(i, k) * t_h1(k, j);
409  break;
410  case LARGE_ROT:
411  case MODERATE_ROT:
412  t_h1(i, j) = t_grad_h1(i, j) + t_kd(i, j);
413  physicsPtr->get_h()(i, j) = iu(i, k) * t_h1(k, j);
414  break;
415  case SMALL_ROT:
416  physicsPtr->get_h()(i, j) = iu(i, j);
417  break;
418  };
419 
420  // play recorder for jacobians
421  int r = ::jacobian(tAg, number_of_dependent_variables,
422  number_of_active_variables,
423  &physicsPtr->activeVariables[0], &jac_ptr[0]);
424  if (r < 0) {
425  SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
426  "ADOL-C function evaluation with error");
427  }
428 
429  FTensor::Tensor4<double, 3, 3, 3, 3> t_P_dh_tmp;
430  t_P_dh_tmp(i, j, N0, k) = physicsPtr->get_P_dh0()(i, j, k);
431  t_P_dh_tmp(i, j, N1, k) = physicsPtr->get_P_dh1()(i, j, k);
432  t_P_dh_tmp(i, j, N2, k) = physicsPtr->get_P_dh2()(i, j, k);
433 
434  switch (EshelbianCore::gradApproximator) {
435  case NO_H1_CONFIGURATION:
436  case LARGE_ROT:
437  case MODERATE_ROT: {
438  FTensor::Tensor4<double, 3, 3, 3, 3> t_h1_du;
439  t_h1_du(i, j, m, n) = t_kd(i, m) * (t_kd(k, n) * t_h1(k, j));
440  r_P_du(k, l, m, n) =
441  (t_P_dh_tmp(i, j, o, p) * t_h1_du(o, p, m, n)) * t_h1_du(i, j, k, l);
442  } break;
443  case SMALL_ROT:
444  r_P_du(i, j, m, n) = t_P_dh_tmp(i, j, m, n);
445  break;
446  };
447 
448  ++iu;
449  ++t_grad_h1;
450  ++r_P_du;
451  }
452  MoFEMFunctionReturn(0);
453 }
454 
455 } // namespace EshelbianPlasticity
456 
457 #include <impl/HMHHStVenantKirchhoff.cpp>
458 #include <impl/HMHNeohookean.cpp>
459 #include <impl/HMHPMooneyRivlinWriggersEq63.cpp>
460 #include <impl/Hencky.cpp>
461 
462 namespace EshelbianPlasticity {
463 
464 MoFEMErrorCode EshelbianCore::addMaterial_HMHHStVenantKirchhoff(
465  const int tape, const double lambda, const double mu,
466  const double sigma_y) {
467  MoFEMFunctionBegin;
468  physicalEquations = boost::make_shared<HMHStVenantKirchhoff>(lambda, mu);
469  CHKERR physicalEquations->recordTape(tape, nullptr);
470  MoFEMFunctionReturn(0);
471 }
472 
473 MoFEMErrorCode EshelbianCore::addMaterial_HMHMooneyRivlin(
474  const int tape, const double alpha, const double beta, const double lambda,
475  const double sigma_y) {
476  MoFEMFunctionBegin;
477  physicalEquations =
478  boost::make_shared<HMHPMooneyRivlinWriggersEq63>(alpha, beta, lambda);
479  CHKERR physicalEquations->recordTape(tape, nullptr);
480  MoFEMFunctionReturn(0);
481 }
482 MoFEMErrorCode EshelbianCore::addMaterial_HMHNeohookean(const int tape,
483  const double c10,
484  const double K) {
485  MoFEMFunctionBegin;
486  physicalEquations = boost::make_shared<HMHNeohookean>(c10, K);
487  CHKERR physicalEquations->recordTape(tape, nullptr);
488  MoFEMFunctionReturn(0);
489 }
490 
491 MoFEMErrorCode EshelbianCore::addMaterial_Hencky(double E, double nu) {
492  MoFEMFunctionBegin;
493  physicalEquations = boost::make_shared<HMHHencky>(mField, E, nu);
494  MoFEMFunctionReturn(0);
495 }
496 
497 }; // namespace EshelbianPlasticity
MoFEM::K
VectorDouble K
Definition: Projection10NodeCoordsOnField.cpp:125
MoFEM::EntitiesFieldData::EntData
Data on single entity (This is passed as argument to DataOperator::doWork)
Definition: EntitiesFieldData.hpp:128
EshelbianPlasticity::LINEAR
@ LINEAR
Definition: EshelbianPlasticity.hpp:44
FTensor::Tensor1
Definition: Tensor1_value.hpp:8
Hencky.cpp
Implementation of Hencky material.
EshelbianPlasticity::OpSpatialPhysical_du_du::dP
MatrixDouble dP
Definition: EshelbianADOL-C.cpp:118
PlasticOps::diff_tensor
auto diff_tensor(FTensor::Number< DIM >)
[Lambda functions]
Definition: PlasticOpsGeneric.hpp:10
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
E
MoFEM::Types::MatrixDouble
UBlasMatrix< double > MatrixDouble
Definition: Types.hpp:77
HMHHStVenantKirchhoff.cpp
Implementation StVenantKirchhoff.
HenckyOps::d_f
auto d_f
Definition: HenckyOps.hpp:16
FTensor::Kronecker_Delta
Kronecker Delta class.
Definition: Kronecker_Delta.hpp:15
EshelbianPlasticity
Definition: CGGTonsorialBubbleBase.hpp:11
MoFEM.hpp
J
FTensor::Index< 'J', DIM1 > J
Definition: level_set.cpp:30
FTensor::Tensor2_symmetric
Definition: Tensor2_symmetric_value.hpp:13
EshelbianPlasticity::NO_H1_CONFIGURATION
@ NO_H1_CONFIGURATION
Definition: EshelbianPlasticity.hpp:43
EshelbianPlasticity::OpSpatialPhysical::alphaU
const double alphaU
Definition: EshelbianADOL-C.cpp:31
EshelbianPlasticity::OpSpatialPhysical::OpSpatialPhysical
OpSpatialPhysical(const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const double alpha_u)
Definition: EshelbianADOL-C.cpp:23
sdf.r
int r
Definition: sdf.py:8
FTensor::Tensor2
Definition: Tensor2_value.hpp:16
EshelbianPlasticity::OpSpatialPhysical_du_du::alphaU
const double alphaU
Definition: EshelbianADOL-C.cpp:117
MoFEM::EntitiesFieldData::EntData::getFTensor0N
FTensor::Tensor0< FTensor::PackPtr< double *, 1 > > getFTensor0N(const FieldApproximationBase base)
Get base function as Tensor0.
Definition: EntitiesFieldData.hpp:1502
c
const double c
speed of light (cm/ns)
Definition: initial_diffusion.cpp:39
FTensor::Number< 0 >
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:548
FTensor::Tensor3
Definition: Tensor3_value.hpp:12
MoFEM
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
a
constexpr double a
Definition: approx_sphere.cpp:30
HMHPMooneyRivlinWriggersEq63.cpp
Implement of MooneyRivlinWriggersEq63.
EshelbianPlasticity::OpAssembleVolume
Definition: EshelbianPlasticity.hpp:517
MoFEM::EntitiesFieldData::EntData::getIndices
const VectorInt & getIndices() const
Get global indices of dofs on entity.
Definition: EntitiesFieldData.hpp:1214
EshelbianPlasticity::OpHMHH::OpHMHH
OpHMHH(const int tag, const bool eval_rhs, const bool eval_lhs, boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr)
Definition: EshelbianADOL-C.cpp:278
MatrixFunction.hpp
EshelbianPlasticity::OpHMHH
Definition: EshelbianADOL-C.cpp:277
MoFEM::L
VectorDouble L
Definition: Projection10NodeCoordsOnField.cpp:124
EshelbianPlasticity.hpp
Eshelbian plasticity interface.
HenckyOps::dd_f
auto dd_f
Definition: HenckyOps.hpp:17
MOFEM_OPERATION_UNSUCCESSFUL
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition: definitions.h:34
FTensor::Tensor4
Definition: Tensor4_value.hpp:18
size_symm
constexpr auto size_symm
Definition: plastic.cpp:42
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
t_kd
constexpr auto t_kd
Definition: free_surface.cpp:137
EshelbianPlasticity::OpSpatialPhysical_du_du
Definition: EshelbianADOL-C.cpp:105
MoFEM::VolumeElementForcesAndSourcesCore::UserDataOperator
Definition: VolumeElementForcesAndSourcesCore.hpp:108
field_name
constexpr auto field_name
Definition: poisson_2d_homogeneous.cpp:13
FTensor::Index
Definition: Index.hpp:23
convert.n
n
Definition: convert.py:82
EshelbianPlasticity::OpSpatialPhysical_du_du::OpSpatialPhysical_du_du
OpSpatialPhysical_du_du(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const double alpha)
Definition: EshelbianADOL-C.cpp:106
v
const double v
phase velocity of light in medium (cm/ns)
Definition: initial_diffusion.cpp:40
EshelbianPlasticity::SMALL_ROT
@ SMALL_ROT
Definition: EshelbianPlasticity.hpp:43
EshelbianPlasticity::LARGE_ROT
@ LARGE_ROT
Definition: EshelbianPlasticity.hpp:43
PlasticOps::symm_L_tensor
auto symm_L_tensor(FTensor::Number< DIM >)
Definition: PlasticOpsGeneric.hpp:21
MoFEM::EntitiesFieldData::EntData::getN
MatrixDouble & getN(const FieldApproximationBase base)
get base functions this return matrix (nb. of rows is equal to nb. of Gauss pts, nb....
Definition: EntitiesFieldData.hpp:1318
HenckyOps::f
auto f
Definition: HenckyOps.hpp:15
EshelbianPlasticity::OpJacobian
Definition: EshelbianPlasticity.hpp:380
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
mu
double mu
Definition: dynamic_first_order_con_law.cpp:98
lambda
static double lambda
Definition: incompressible_elasticity.cpp:199
EigenMatrix::getDiffDiffMat
FTensor::Ddg< double, 3, 3 > getDiffDiffMat(Val< double, 3 > &t_val, Vec< double, 3 > &t_vec, Fun< double > f, Fun< double > d_f, Fun< double > dd_f, FTensor::Tensor2< double, 3, 3 > &t_S, const int nb)
Definition: MatrixFunction.cpp:78
EshelbianAux.hpp
Auxilary functions for Eshelbian plasticity.
m
FTensor::Index< 'm', 3 > m
Definition: shallow_wave.cpp:80
HMHNeohookean.cpp
Implementation of NeoHookean material.
third
constexpr double third
Definition: EshelbianADOL-C.cpp:17
EshelbianPlasticity::MODERATE_ROT
@ MODERATE_ROT
Definition: EshelbianPlasticity.hpp:43
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:429
EshelbianPlasticity::OpSpatialPhysical
Definition: EshelbianADOL-C.cpp:21
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21
Generated by Doxygen 1.8.17 and hosted at University of Glasgow