v0.14.0
ElasticityMixedFormulation.hpp
Go to the documentation of this file.
1 /**
2  * \file ElasticityMixedFormulation.hpp
3  * \example ElasticityMixedFormulation.hpp
4  *
5  * \brief Operator implementation of U-P (mixed) finite element.
6  *
7  */
8 
9 #ifndef __ELASTICITYMIXEDFORMULATION_HPP__
10 #define __ELASTICITYMIXEDFORMULATION_HPP__
11 
12 struct BlockData {
13  int iD;
14  int oRder;
15  double yOung;
16  double pOisson;
17  Range tEts;
18  BlockData() : oRder(-1), yOung(-1), pOisson(-2) {}
19 };
20 struct DataAtIntegrationPts {
21 
22  boost::shared_ptr<MatrixDouble> gradDispPtr;
23  boost::shared_ptr<VectorDouble> pPtr;
24  FTensor::Ddg<double, 3, 3> tD;
25 
26  double pOisson;
27  double yOung;
28  double lAmbda;
29  double mU;
30 
31  std::map<int, BlockData> setOfBlocksData;
32 
33  DataAtIntegrationPts(MoFEM::Interface &m_field) : mField(m_field) {
34 
35  // Setting default values for coeffcients
36  gradDispPtr = boost::shared_ptr<MatrixDouble>(new MatrixDouble());
37  pPtr = boost::shared_ptr<VectorDouble>(new VectorDouble());
38 
39  ierr = setBlocks();
40  CHKERRABORT(PETSC_COMM_WORLD, ierr);
41  }
42 
43  MoFEMErrorCode getParameters() {
44  MoFEMFunctionBegin; // They will be overwriten by BlockData
45  CHKERR PetscOptionsBegin(PETSC_COMM_WORLD, "", "Problem", "none");
46 
47  ierr = PetscOptionsEnd();
48  CHKERRQ(ierr);
49  MoFEMFunctionReturn(0);
50  }
51 
52  MoFEMErrorCode getBlockData(BlockData &data) {
53  MoFEMFunctionBegin;
54 
55  yOung = data.yOung;
56  pOisson = data.pOisson;
57  lAmbda = (yOung * pOisson) / ((1. + pOisson) * (1. - 2. * pOisson));
58  mU = yOung / (2. * (1. + pOisson));
59 
60  FTensor::Index<'i', 3> i;
61  FTensor::Index<'j', 3> j;
62  FTensor::Index<'k', 3> k;
63  FTensor::Index<'l', 3> l;
64 
65  tD(i, j, k, l) = 0.;
66 
67  tD(0, 0, 0, 0) = 2 * mU;
68  tD(0, 1, 0, 1) = mU;
69  tD(0, 1, 1, 0) = mU;
70  tD(0, 2, 0, 2) = mU;
71  tD(0, 2, 2, 0) = mU;
72  tD(1, 0, 0, 1) = mU;
73  tD(1, 0, 1, 0) = mU;
74  tD(1, 1, 1, 1) = 2 * mU;
75  tD(1, 2, 1, 2) = mU;
76  tD(1, 2, 2, 1) = mU;
77  tD(2, 0, 0, 2) = mU;
78  tD(2, 0, 2, 0) = mU;
79  tD(2, 1, 1, 2) = mU;
80  tD(2, 1, 2, 1) = mU;
81  tD(2, 2, 2, 2) = 2 * mU;
82 
83  MoFEMFunctionReturn(0);
84  }
85 
86  MoFEMErrorCode setBlocks() {
87  MoFEMFunctionBegin;
88  for (_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(
89  mField, BLOCKSET | MAT_ELASTICSET, it)) {
90  Mat_Elastic mydata;
91  CHKERR it->getAttributeDataStructure(mydata);
92  int id = it->getMeshsetId();
93  EntityHandle meshset = it->getMeshset();
94  CHKERR mField.get_moab().get_entities_by_type(
95  meshset, MBTET, setOfBlocksData[id].tEts, true);
96  setOfBlocksData[id].iD = id;
97  setOfBlocksData[id].yOung = mydata.data.Young;
98  setOfBlocksData[id].pOisson = mydata.data.Poisson;
99  }
100  MoFEMFunctionReturn(0);
101  }
102 
103 private:
104  MoFEM::Interface &mField;
105 };
106 
107 /** * @brief Assemble P *
108  * \f[
109  * {\bf{P}} = - \int\limits_\Omega {{\bf{N}}_p^T\frac{1}{\lambda
110  }{{\bf{N}}_p}d\Omega }
111  * \f]
112  *
113  */
114 struct OpAssembleP
115  : public VolumeElementForcesAndSourcesCore::UserDataOperator {
116 
117  DataAtIntegrationPts &commonData;
118  MatrixDouble locP;
119  MatrixDouble translocP;
120  BlockData &dAta;
121 
122  OpAssembleP(DataAtIntegrationPts &common_data, BlockData &data)
123  : VolumeElementForcesAndSourcesCore::UserDataOperator(
124  "P", "P", UserDataOperator::OPROWCOL),
125  commonData(common_data), dAta(data) {
126  sYmm = true;
127  }
128 
129  PetscErrorCode doWork(int row_side, int col_side, EntityType row_type,
130  EntityType col_type,
131  EntitiesFieldData::EntData &row_data,
132  EntitiesFieldData::EntData &col_data) {
133 
134  MoFEMFunctionBegin;
135  const int row_nb_dofs = row_data.getIndices().size();
136  if (!row_nb_dofs)
137  MoFEMFunctionReturnHot(0);
138  const int col_nb_dofs = col_data.getIndices().size();
139  if (!col_nb_dofs)
140  MoFEMFunctionReturnHot(0);
141 
142  if (dAta.tEts.find(getNumeredEntFiniteElementPtr()->getEnt()) ==
143  dAta.tEts.end()) {
144  MoFEMFunctionReturnHot(0);
145  }
146  CHKERR commonData.getBlockData(dAta);
147  // Set size can clear local tangent matrix
148  locP.resize(row_nb_dofs, col_nb_dofs, false);
149  locP.clear();
150 
151  const int row_nb_gauss_pts = row_data.getN().size1();
152  if (!row_nb_gauss_pts)
153  MoFEMFunctionReturnHot(0);
154  const int row_nb_base_functions = row_data.getN().size2();
155  auto row_base_functions = row_data.getFTensor0N();
156 
157  // get data
158  FTensor::Index<'i', 3> i;
159  FTensor::Index<'j', 3> j;
160  const double lambda = commonData.lAmbda;
161 
162  double coefficient = commonData.pOisson == 0.5 ? 0. : 1 / lambda;
163 
164  // integration
165  if (coefficient != 0.) {
166  for (int gg = 0; gg != row_nb_gauss_pts; gg++) {
167 
168  // Get volume and integration weight
169  double w = getVolume() * getGaussPts()(3, gg);
170 
171  // INTEGRATION
172  int row_bb = 0;
173  for (; row_bb != row_nb_dofs; row_bb++) {
174  auto col_base_functions = col_data.getFTensor0N(gg, 0);
175  for (int col_bb = 0; col_bb != col_nb_dofs; col_bb++) {
176 
177  locP(row_bb, col_bb) -=
178  w * row_base_functions * col_base_functions * coefficient;
179 
180  ++col_base_functions;
181  }
182  ++row_base_functions;
183  }
184  for (; row_bb != row_nb_base_functions; row_bb++) {
185  ++row_base_functions;
186  }
187  }
188  }
189 
190 
191  CHKERR MatSetValues(
192  getFEMethod()->ksp_B, row_nb_dofs, &*row_data.getIndices().begin(),
193  col_nb_dofs, &*col_data.getIndices().begin(), &locP(0, 0), ADD_VALUES);
194 
195  // is symmetric
196  if (row_side != col_side || row_type != col_type) {
197  translocP.resize(col_nb_dofs, row_nb_dofs, false);
198  noalias(translocP) = trans(locP);
199  CHKERR MatSetValues(getFEMethod()->ksp_B, col_nb_dofs,
200  &*col_data.getIndices().begin(), row_nb_dofs,
201  &*row_data.getIndices().begin(), &translocP(0, 0),
202  ADD_VALUES);
203  }
204 
205  MoFEMFunctionReturn(0);
206  }
207 };
208 
209 /** * @brief Assemble G *
210  * \f[
211  * {\bf{G}} = - \int\limits_\Omega {{{\bf{B}}^T}{\bf m}{{\bf{N}}_p}d\Omega }
212  * \f]
213  *
214  */
215 struct OpAssembleG
216  : public VolumeElementForcesAndSourcesCore::UserDataOperator {
217 
218  DataAtIntegrationPts &commonData;
219  MatrixDouble locG;
220  BlockData &dAta;
221 
222  OpAssembleG(DataAtIntegrationPts &common_data, BlockData &data)
223  : VolumeElementForcesAndSourcesCore::UserDataOperator(
224  "U", "P", UserDataOperator::OPROWCOL),
225  commonData(common_data), dAta(data) {
226  sYmm = false;
227  }
228 
229  PetscErrorCode doWork(int row_side, int col_side, EntityType row_type,
230  EntityType col_type,
231  EntitiesFieldData::EntData &row_data,
232  EntitiesFieldData::EntData &col_data) {
233 
234  MoFEMFunctionBegin;
235 
236  const int row_nb_dofs = row_data.getIndices().size();
237  if (!row_nb_dofs)
238  MoFEMFunctionReturnHot(0);
239  const int col_nb_dofs = col_data.getIndices().size();
240  if (!col_nb_dofs)
241  MoFEMFunctionReturnHot(0);
242 
243  if (dAta.tEts.find(getNumeredEntFiniteElementPtr()->getEnt()) ==
244  dAta.tEts.end()) {
245  MoFEMFunctionReturnHot(0);
246  }
247  commonData.getBlockData(dAta);
248 
249  // Set size can clear local tangent matrix
250  locG.resize(row_nb_dofs, col_nb_dofs, false);
251  locG.clear();
252  const int row_nb_gauss_pts = row_data.getN().size1();
253  if (!row_nb_gauss_pts)
254  MoFEMFunctionReturnHot(0);
255  const int row_nb_base_functions = row_data.getN().size2();
256  auto row_diff_base_functions = row_data.getFTensor1DiffN<3>();
257 
258  FTensor::Tensor1<double, 3> t1;
259  FTensor::Index<'i', 3> i;
260  FTensor::Index<'j', 3> j;
261 
262  // INTEGRATION
263  for (int gg = 0; gg != row_nb_gauss_pts; gg++) {
264 
265  // Get volume and integration weight
266  double w = getVolume() * getGaussPts()(3, gg);
267 
268  int row_bb = 0;
269  for (; row_bb != row_nb_dofs / 3; row_bb++) {
270 
271  t1(i) = w * row_diff_base_functions(i);
272 
273  auto base_functions = col_data.getFTensor0N(gg, 0);
274  for (int col_bb = 0; col_bb != col_nb_dofs; col_bb++) {
275 
276  FTensor::Tensor1<double *, 3> k(&locG(3 * row_bb + 0, col_bb),
277  &locG(3 * row_bb + 1, col_bb),
278  &locG(3 * row_bb + 2, col_bb));
279 
280  k(i) += t1(i) * base_functions;
281  ++base_functions;
282  }
283  ++row_diff_base_functions;
284  }
285  for (; row_bb != row_nb_base_functions; row_bb++) {
286  ++row_diff_base_functions;
287  }
288  }
289 
290  CHKERR MatSetValues(getFEMethod()->ksp_B, row_nb_dofs,
291  &*row_data.getIndices().begin(), col_nb_dofs,
292  &*col_data.getIndices().begin(), &*locG.data().begin(),
293  ADD_VALUES);
294 
295  // ASSEMBLE THE TRANSPOSE
296  locG = trans(locG);
297  CHKERR MatSetValues(getFEMethod()->ksp_B, col_nb_dofs,
298  &*col_data.getIndices().begin(), row_nb_dofs,
299  &*row_data.getIndices().begin(), &*locG.data().begin(),
300  ADD_VALUES);
301  MoFEMFunctionReturn(0);
302  }
303 };
304 
305 /** * @brief Assemble K *
306  * \f[
307  * {\bf{K}} = \int\limits_\Omega {{{\bf{B}}^T}{{\bf{D}}_d}{\bf{B}}d\Omega }
308  * \f]
309  *
310  */
311 struct OpAssembleK
312  : public VolumeElementForcesAndSourcesCore::UserDataOperator {
313 
314  MatrixDouble locK;
315  MatrixDouble translocK;
316  FTensor::Tensor2<double, 3, 3> diffDiff;
317 
318  DataAtIntegrationPts &commonData;
319  BlockData &dAta;
320 
321  OpAssembleK(DataAtIntegrationPts &common_data, BlockData &data,
322  bool symm = true)
323  : VolumeElementForcesAndSourcesCore::UserDataOperator("U", "U", OPROWCOL,
324  symm),
325  commonData(common_data), dAta(data) {}
326 
327  PetscErrorCode doWork(int row_side, int col_side, EntityType row_type,
328  EntityType col_type,
329  EntitiesFieldData::EntData &row_data,
330  EntitiesFieldData::EntData &col_data) {
331  MoFEMFunctionBegin;
332 
333  auto get_tensor2 = [](MatrixDouble &m, const int r, const int c) {
334  return FTensor::Tensor2<double *, 3, 3>(
335  &m(r + 0, c + 0), &m(r + 0, c + 1), &m(r + 0, c + 2),
336  &m(r + 1, c + 0), &m(r + 1, c + 1), &m(r + 1, c + 2),
337  &m(r + 2, c + 0), &m(r + 2, c + 1), &m(r + 2, c + 2));
338  };
339 
340  const int row_nb_dofs = row_data.getIndices().size();
341  if (!row_nb_dofs)
342  MoFEMFunctionReturnHot(0);
343  const int col_nb_dofs = col_data.getIndices().size();
344  if (!col_nb_dofs)
345  MoFEMFunctionReturnHot(0);
346  if (dAta.tEts.find(getNumeredEntFiniteElementPtr()->getEnt()) ==
347  dAta.tEts.end()) {
348  MoFEMFunctionReturnHot(0);
349  }
350  commonData.getBlockData(dAta);
351 
352  const bool diagonal_block =
353  (row_type == col_type) && (row_side == col_side);
354  // get number of integration points
355  // Set size can clear local tangent matrix
356  locK.resize(row_nb_dofs, col_nb_dofs, false);
357  locK.clear();
358 
359  const int row_nb_gauss_pts = row_data.getN().size1();
360  const int row_nb_base_functions = row_data.getN().size2();
361 
362  auto row_diff_base_functions = row_data.getFTensor1DiffN<3>();
363 
364  FTensor::Index<'i', 3> i;
365  FTensor::Index<'j', 3> j;
366  FTensor::Index<'k', 3> k;
367  FTensor::Index<'l', 3> l;
368 
369  // integrate local matrix for entity block
370  for (int gg = 0; gg != row_nb_gauss_pts; gg++) {
371 
372  // Get volume and integration weight
373  double w = getVolume() * getGaussPts()(3, gg);
374 
375  int row_bb = 0;
376  for (; row_bb != row_nb_dofs / 3; row_bb++) {
377 
378  auto col_diff_base_functions = col_data.getFTensor1DiffN<3>(gg, 0);
379  const int final_bb = diagonal_block ? row_bb + 1 : col_nb_dofs / 3;
380  int col_bb = 0;
381  for (; col_bb != final_bb; col_bb++) {
382 
383  auto t_assemble = get_tensor2(locK, 3 * row_bb, 3 * col_bb);
384 
385  diffDiff(j, l) =
386  w * row_diff_base_functions(j) * col_diff_base_functions(l);
387 
388  t_assemble(i, k) += diffDiff(j, l) * commonData.tD(i, j, k, l);
389  // Next base function for column
390  ++col_diff_base_functions;
391  }
392 
393  ++row_diff_base_functions;
394  }
395  for (; row_bb != row_nb_base_functions; row_bb++) {
396  ++row_diff_base_functions;
397  }
398  }
399 
400  if (diagonal_block) {
401  for (int row_bb = 0; row_bb != row_nb_dofs / 3; row_bb++) {
402  int col_bb = 0;
403  for (; col_bb != row_bb + 1; col_bb++) {
404  auto t_assemble = get_tensor2(locK, 3 * row_bb, 3 * col_bb);
405  auto t_off_side = get_tensor2(locK, 3 * col_bb, 3 * row_bb);
406  t_off_side(i, k) = t_assemble(k, i);
407  }
408  }
409  }
410 
411  const int *row_ind = &*row_data.getIndices().begin();
412  const int *col_ind = &*col_data.getIndices().begin();
413  Mat B = getFEMethod()->ksp_B != PETSC_NULL ? getFEMethod()->ksp_B
414  : getFEMethod()->ksp_B;
415  CHKERR MatSetValues(B, row_nb_dofs, row_ind, col_nb_dofs, col_ind,
416  &locK(0, 0), ADD_VALUES);
417 
418  if (row_type != col_type || row_side != col_side) {
419  translocK.resize(col_nb_dofs, row_nb_dofs, false);
420  noalias(translocK) = trans(locK);
421  CHKERR MatSetValues(B, col_nb_dofs, col_ind, row_nb_dofs, row_ind,
422  &translocK(0, 0), ADD_VALUES);
423  }
424 
425  MoFEMFunctionReturn(0);
426  }
427 };
428 
429 struct OpPostProcStress
430  : public MoFEM::VolumeElementForcesAndSourcesCore::UserDataOperator {
431  DataAtIntegrationPts &commonData;
432  moab::Interface &postProcMesh;
433  std::vector<EntityHandle> &mapGaussPts;
434  BlockData &dAta;
435 
436  OpPostProcStress(moab::Interface &post_proc_mesh,
437  std::vector<EntityHandle> &map_gauss_pts,
438  DataAtIntegrationPts &common_data, BlockData &data)
439  : VolumeElementForcesAndSourcesCore::UserDataOperator(
440  "U", UserDataOperator::OPROW),
441  commonData(common_data), postProcMesh(post_proc_mesh),
442  mapGaussPts(map_gauss_pts), dAta(data) {
443  doVertices = true;
444  doEdges = false;
445  doQuads = false;
446  doTris = false;
447  doTets = false;
448  doPrisms = false;
449  }
450 
451  PetscErrorCode doWork(int side, EntityType type,
452  EntitiesFieldData::EntData &data) {
453  MoFEMFunctionBegin;
454  if (type != MBVERTEX)
455  PetscFunctionReturn(9);
456  double def_VAL[9];
457  bzero(def_VAL, 9 * sizeof(double));
458 
459  if (dAta.tEts.find(getNumeredEntFiniteElementPtr()->getEnt()) ==
460  dAta.tEts.end()) {
461  MoFEMFunctionReturnHot(0);
462  }
463  commonData.getBlockData(dAta);
464 
465  Tag th_stress;
466  CHKERR postProcMesh.tag_get_handle("STRESS", 9, MB_TYPE_DOUBLE, th_stress,
467  MB_TAG_CREAT | MB_TAG_SPARSE, def_VAL);
468  Tag th_strain;
469  CHKERR postProcMesh.tag_get_handle("STRAIN", 9, MB_TYPE_DOUBLE, th_strain,
470  MB_TAG_CREAT | MB_TAG_SPARSE, def_VAL);
471  Tag th_psi;
472  CHKERR postProcMesh.tag_get_handle("ENERGY", 1, MB_TYPE_DOUBLE, th_psi,
473  MB_TAG_CREAT | MB_TAG_SPARSE, def_VAL);
474 
475  auto grad = getFTensor2FromMat<3, 3>(*commonData.gradDispPtr);
476  auto p = getFTensor0FromVec(*commonData.pPtr);
477 
478  const int nb_gauss_pts = commonData.gradDispPtr->size2();
479  const double mu = commonData.mU;
480 
481  FTensor::Index<'i', 3> i;
482  FTensor::Index<'j', 3> j;
483  FTensor::Tensor2<double, 3, 3> strain;
484  FTensor::Tensor2<double, 3, 3> stress;
485 
486  for (int gg = 0; gg != nb_gauss_pts; gg++) {
487  strain(i, j) = 0.5 * (grad(i, j) + grad(j, i));
488  double psi = 0.5 * p * p + mu * strain(i, j) * strain(i, j);
489 
490  stress(i, j) = 2 * mu * strain(i, j);
491  stress(1, 1) -= p;
492  stress(0, 0) -= p;
493  stress(2, 2) -= p;
494 
495  CHKERR postProcMesh.tag_set_data(th_psi, &mapGaussPts[gg], 1, &psi);
496  CHKERR postProcMesh.tag_set_data(th_strain, &mapGaussPts[gg], 1,
497  &strain(0, 0));
498  CHKERR postProcMesh.tag_set_data(th_stress, &mapGaussPts[gg], 1,
499  &stress(0, 0));
500  ++p;
501  ++grad;
502  }
503 
504  MoFEMFunctionReturn(0);
505  }
506 };
507 
508 #endif //__ELASTICITYMIXEDFORMULATION_HPP__
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:460
DataAtIntegrationPts::getParameters
MoFEMErrorCode getParameters()
Definition: ElasticityMixedFormulation.hpp:43
MoFEM::DataOperator::doTris
bool & doTris
\deprectaed
Definition: DataOperators.hpp:93
OpPostProcStress::commonData
DataAtIntegrationPts & commonData
Definition: ElasticityMixedFormulation.hpp:431
MoFEM::MatSetValues
MoFEMErrorCode MatSetValues(Mat M, const EntitiesFieldData::EntData &row_data, const EntitiesFieldData::EntData &col_data, const double *ptr, InsertMode iora)
Assemble PETSc matrix.
Definition: EntitiesFieldData.hpp:1644
OpAssembleK::translocK
MatrixDouble translocK
Definition: ElasticityMixedFormulation.hpp:315
OpAssembleG::OpAssembleG
OpAssembleG(DataAtIntegrationPts &common_data, BlockData &data)
Definition: ElasticityMixedFormulation.hpp:222
FTensor::Tensor1< double, 3 >
EntityHandle
OpAssembleK::dAta
BlockData & dAta
Definition: ElasticityMixedFormulation.hpp:319
BlockData::pOisson
double pOisson
Definition: ElasticityMixedFormulation.hpp:16
DataAtIntegrationPts::mU
double mU
Definition: ElasticityMixedFormulation.hpp:29
BlockData::oRder
int oRder
Definition: ElasticityMixedFormulation.hpp:14
OpPostProcStress::postProcMesh
moab::Interface & postProcMesh
Definition: ElasticityMixedFormulation.hpp:432
OpPostProcStress::OpPostProcStress
OpPostProcStress(moab::Interface &post_proc_mesh, std::vector< EntityHandle > &map_gauss_pts, DataAtIntegrationPts &common_data, BlockData &data)
Definition: ElasticityMixedFormulation.hpp:436
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
_IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_
#define _IT_CUBITMESHSETS_BY_BCDATA_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet in a moFEM field.
Definition: MeshsetsManager.hpp:49
MoFEM::Types::MatrixDouble
UBlasMatrix< double > MatrixDouble
Definition: Types.hpp:77
MoFEM::DataOperator::doPrisms
bool & doPrisms
\deprectaed
Definition: DataOperators.hpp:95
DataAtIntegrationPts::pOisson
double pOisson
Definition: ElasticityMixedFormulation.hpp:26
DataAtIntegrationPts::setOfBlocksData
std::map< int, BlockData > setOfBlocksData
Definition: ElasticityMixedFormulation.hpp:31
MoFEM::DataOperator::doTets
bool & doTets
\deprectaed
Definition: DataOperators.hpp:94
DataAtIntegrationPts::getBlockData
MoFEMErrorCode getBlockData(BlockData &data)
Definition: ElasticityMixedFormulation.hpp:52
MoFEM::DataOperator::doVertices
bool & doVertices
\deprectaed If false skip vertices
Definition: DataOperators.hpp:90
sdf.r
int r
Definition: sdf.py:8
FTensor::Tensor2< double, 3, 3 >
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
OpPostProcStress
Definition: ElasticityMixedFormulation.hpp:429
OpAssembleP::doWork
PetscErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Definition: ElasticityMixedFormulation.hpp:129
MoFEM::Interface
DeprecatedCoreInterface Interface
Definition: Interface.hpp:2010
DataAtIntegrationPts::lAmbda
double lAmbda
Definition: ElasticityMixedFormulation.hpp:28
c
const double c
speed of light (cm/ns)
Definition: initial_diffusion.cpp:39
OpPostProcStress::mapGaussPts
std::vector< EntityHandle > & mapGaussPts
Definition: ElasticityMixedFormulation.hpp:433
OpAssembleP::translocP
MatrixDouble translocP
Definition: ElasticityMixedFormulation.hpp:119
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:548
OpAssembleG::locG
MatrixDouble locG
Definition: ElasticityMixedFormulation.hpp:219
OpAssembleK::diffDiff
FTensor::Tensor2< double, 3, 3 > diffDiff
Definition: ElasticityMixedFormulation.hpp:316
OpAssembleG::commonData
DataAtIntegrationPts & commonData
Definition: ElasticityMixedFormulation.hpp:218
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
OpAssembleK
Assemble K *.
Definition: ElasticityMixedFormulation.hpp:311
OpAssembleP::OpAssembleP
OpAssembleP(DataAtIntegrationPts &common_data, BlockData &data)
Definition: ElasticityMixedFormulation.hpp:122
BlockData
Definition: ElasticityMixedFormulation.hpp:12
MoFEM::ForcesAndSourcesCore::UserDataOperator
Definition: ForcesAndSourcesCore.hpp:549
convert.type
type
Definition: convert.py:64
OpAssembleG::doWork
PetscErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Definition: ElasticityMixedFormulation.hpp:229
OpAssembleG::dAta
BlockData & dAta
Definition: ElasticityMixedFormulation.hpp:220
MoFEM::getFTensor0FromVec
static auto getFTensor0FromVec(ublas::vector< T, A > &data)
Get tensor rank 0 (scalar) form data vector.
Definition: Templates.hpp:135
MAT_ELASTICSET
@ MAT_ELASTICSET
block name is "MAT_ELASTIC"
Definition: definitions.h:172
DataAtIntegrationPts
Definition: ElasticityMixedFormulation.hpp:20
OpPostProcStress::dAta
BlockData & dAta
Definition: ElasticityMixedFormulation.hpp:434
DataAtIntegrationPts::mField
MoFEM::Interface & mField
Definition: ElasticityMixedFormulation.hpp:104
MoFEM::ForcesAndSourcesCore::UserDataOperator::getNumeredEntFiniteElementPtr
boost::shared_ptr< const NumeredEntFiniteElement > getNumeredEntFiniteElementPtr() const
Return raw pointer to NumeredEntFiniteElement.
Definition: ForcesAndSourcesCore.hpp:1000
OpAssembleP
Assemble P *.
Definition: ElasticityMixedFormulation.hpp:114
MoFEM::DataOperator::doQuads
bool & doQuads
\deprectaed
Definition: DataOperators.hpp:92
BlockData::iD
int iD
Definition: ElasticityMixedFormulation.hpp:13
OpPostProcStress::doWork
PetscErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
Definition: ElasticityMixedFormulation.hpp:451
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
MoFEM::VolumeElementForcesAndSourcesCore::UserDataOperator
Definition: VolumeElementForcesAndSourcesCore.hpp:108
EntData
EntitiesFieldData::EntData EntData
Definition: child_and_parent.cpp:37
FTensor::Index< 'i', 3 >
OpAssembleP::commonData
DataAtIntegrationPts & commonData
Definition: ElasticityMixedFormulation.hpp:117
BlockData::BlockData
BlockData()
Definition: ElasticityMixedFormulation.hpp:18
BlockData::tEts
Range tEts
Definition: ElasticityMixedFormulation.hpp:17
DataAtIntegrationPts::yOung
double yOung
Definition: ElasticityMixedFormulation.hpp:27
Range
MoFEM::DataOperator::doEdges
bool & doEdges
\deprectaed If false skip edges
Definition: DataOperators.hpp:91
DataAtIntegrationPts::pPtr
boost::shared_ptr< VectorDouble > pPtr
Definition: ElasticityMixedFormulation.hpp:23
DataAtIntegrationPts::gradDispPtr
boost::shared_ptr< MatrixDouble > gradDispPtr
Definition: ElasticityMixedFormulation.hpp:22
OpAssembleK::locK
MatrixDouble locK
Definition: ElasticityMixedFormulation.hpp:314
OpAssembleP::dAta
BlockData & dAta
Definition: ElasticityMixedFormulation.hpp:120
UserDataOperator
ForcesAndSourcesCore::UserDataOperator UserDataOperator
Definition: HookeElement.hpp:75
BLOCKSET
@ BLOCKSET
Definition: definitions.h:161
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
FTensor::Ddg< double, 3, 3 >
DataAtIntegrationPts::DataAtIntegrationPts
DataAtIntegrationPts(MoFEM::Interface &m_field)
Definition: ElasticityMixedFormulation.hpp:33
MoFEM::Exceptions::ierr
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition: Exceptions.hpp:76
mu
double mu
Definition: dynamic_first_order_con_law.cpp:98
lambda
static double lambda
Definition: incompressible_elasticity.cpp:199
DataAtIntegrationPts::tD
FTensor::Ddg< double, 3, 3 > tD
Definition: ElasticityMixedFormulation.hpp:24
DataAtIntegrationPts::setBlocks
MoFEMErrorCode setBlocks()
Definition: ElasticityMixedFormulation.hpp:86
OpAssembleK::commonData
DataAtIntegrationPts & commonData
Definition: ElasticityMixedFormulation.hpp:318
OpAssembleK::doWork
PetscErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
Definition: ElasticityMixedFormulation.hpp:327
MoFEM::Types::VectorDouble
UBlasVector< double > VectorDouble
Definition: Types.hpp:68
sdf_wavy_2d.w
int w
Definition: sdf_wavy_2d.py:6
BlockData::yOung
double yOung
Definition: ElasticityMixedFormulation.hpp:15
m
FTensor::Index< 'm', 3 > m
Definition: shallow_wave.cpp:80
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
OpAssembleP::locP
MatrixDouble locP
Definition: ElasticityMixedFormulation.hpp:118
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:429
OpAssembleK::OpAssembleK
OpAssembleK(DataAtIntegrationPts &common_data, BlockData &data, bool symm=true)
Definition: ElasticityMixedFormulation.hpp:321
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
MoFEM::ForcesAndSourcesCore::UserDataOperator::OPROW
@ OPROW
operator doWork function is executed on FE rows
Definition: ForcesAndSourcesCore.hpp:567
OpAssembleG
Assemble G *.
Definition: ElasticityMixedFormulation.hpp:215
Generated by Doxygen 1.8.17 and hosted at University of Glasgow