v0.14.0
Loading...
Searching...
No Matches
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>
7using namespace MoFEM;
8
10
12#include <boost/math/constants/constants.hpp>
13
14constexpr double third = boost::math::constants::third<double>();
15
16namespace EshelbianPlasticity {
17
18struct OpHMHH : public OpJacobian {
19 OpHMHH(const int tag, const bool eval_rhs, const bool eval_lhs,
20 boost::shared_ptr<DataAtIntegrationPts> &data_ptr,
21 boost::shared_ptr<PhysicalEquations> &physics_ptr)
22 : OpJacobian(tag, eval_rhs, eval_lhs, data_ptr, physics_ptr) {}
23
26};
27
36
37 const auto nb_integration_pts = getGaussPts().size2();
38 auto iu = getFTensor2SymmetricFromMat<3>(dataAtPts->stretchTensorAtPts);
39 auto t_grad_h1 = getFTensor2FromMat<3, 3>(dataAtPts->wGradH1AtPts);
40
41 auto create_data_vec = [nb_integration_pts](auto &v) {
42 v.resize(nb_integration_pts, false);
43 };
44 auto create_data_mat = [nb_integration_pts](auto &m) {
45 m.resize(9, nb_integration_pts, false);
46 };
47
48 create_data_mat(dataAtPts->PAtPts);
49
50 constexpr auto t_kd = FTensor::Kronecker_Delta<int>();
51 auto r_P = getFTensor2FromMat<3, 3>(dataAtPts->PAtPts);
52 for (unsigned int gg = 0; gg != nb_integration_pts; ++gg) {
53
55
57 case LARGE_ROT:
58 case MODERATE_ROT:
59 t_h1(i, j) = t_grad_h1(i, j) + t_kd(i, j);
60 physicsPtr->get_h()(i, j) = iu(i, k) * t_h1(k, j);
61 break;
62 case SMALL_ROT:
63 physicsPtr->get_h()(i, j) = iu(i, j);
64 break;
65 };
66
67 int r = ::function(tAg, physicsPtr->dependentVariablesPiola.size(),
68 physicsPtr->activeVariables.size(),
69 &physicsPtr->activeVariables[0],
70 &physicsPtr->dependentVariablesPiola[0]);
71 if (r < 0) { // function is locally analytic
72 SETERRQ1(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
73 "ADOL-C function evaluation with error r = %d", r);
74 }
75
77 case LARGE_ROT:
78 case MODERATE_ROT: {
80 t_h1_du(i, j, m, n) = t_kd(i, m) * (t_kd(k, n) * t_h1(k, j));
81 r_P(k, l) = physicsPtr->get_P()(i, j) * t_h1_du(i, j, k, l);
82 }; break;
83 case SMALL_ROT:
84 r_P(i, j) = physicsPtr->get_P()(i, j);
85 break;
86 };
87
88 ++iu;
89 ++t_grad_h1;
90 ++r_P;
91 }
93}
94
105
106 const int number_of_active_variables = physicsPtr->activeVariables.size();
107 const int number_of_dependent_variables =
108 physicsPtr->dependentVariablesPiola.size();
109 std::vector<double *> jac_ptr(number_of_dependent_variables);
110 for (unsigned int n = 0; n != number_of_dependent_variables; ++n) {
111 jac_ptr[n] =
112 &(physicsPtr
113 ->dependentVariablesPiolaDirevatives[n *
114 number_of_active_variables]);
115 }
116
117 const auto nb_integration_pts = getGaussPts().size2();
118
119 auto create_data_mat = [nb_integration_pts](auto &m) {
120 m.resize(9, nb_integration_pts, false);
121 };
122
123 dataAtPts->P_du.resize(81, nb_integration_pts, false);
124
125 auto iu = getFTensor2SymmetricFromMat<3>(dataAtPts->stretchTensorAtPts);
126 auto t_grad_h1 = getFTensor2FromMat<3, 3>(dataAtPts->wGradH1AtPts);
127 auto r_P_du = getFTensor4FromMat<3, 3, 3, 3>(dataAtPts->P_du);
128
132
133 constexpr auto t_kd = FTensor::Kronecker_Delta<int>();
134
135 for (unsigned int gg = 0; gg != nb_integration_pts; ++gg) {
136
138
140 case LARGE_ROT:
141 case MODERATE_ROT:
142 t_h1(i, j) = t_grad_h1(i, j) + t_kd(i, j);
143 physicsPtr->get_h()(i, j) = iu(i, k) * t_h1(k, j);
144 break;
145 case SMALL_ROT:
146 physicsPtr->get_h()(i, j) = iu(i, j);
147 break;
148 };
149
150 // play recorder for jacobians
151 int r = ::jacobian(tAg, number_of_dependent_variables,
152 number_of_active_variables,
153 &physicsPtr->activeVariables[0], &jac_ptr[0]);
154 if (r < 0) {
155 SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
156 "ADOL-C function evaluation with error");
157 }
158
160 t_P_dh_tmp(i, j, N0, k) = physicsPtr->get_P_dh0()(i, j, k);
161 t_P_dh_tmp(i, j, N1, k) = physicsPtr->get_P_dh1()(i, j, k);
162 t_P_dh_tmp(i, j, N2, k) = physicsPtr->get_P_dh2()(i, j, k);
163
165 case LARGE_ROT:
166 case MODERATE_ROT: {
168 t_h1_du(i, j, m, n) = t_kd(i, m) * (t_kd(k, n) * t_h1(k, j));
169 r_P_du(k, l, m, n) =
170 (t_P_dh_tmp(i, j, o, p) * t_h1_du(o, p, m, n)) * t_h1_du(i, j, k, l);
171 } break;
172 case SMALL_ROT:
173 r_P_du(i, j, m, n) = t_P_dh_tmp(i, j, m, n);
174 break;
175 };
176
177 ++iu;
178 ++t_grad_h1;
179 ++r_P_du;
180 }
182}
183
185
186 static constexpr int numberOfActiveVariables = 9;
187 static constexpr int numberOfDependentVariables = 9;
188
189 HMHStVenantKirchhoff(const double lambda, const double mu)
191 lambda(lambda), mu(mu) {}
192
195
196 double E = 1;
197 double nu = 0;
198
199 CHKERR PetscOptionsBegin(PETSC_COMM_WORLD, "stvenant_", "", "none");
200
201 CHKERR PetscOptionsScalar("-young_modulus", "Young modulus", "", E, &E,
202 PETSC_NULL);
203 CHKERR PetscOptionsScalar("-poisson_ratio", "poisson ratio", "", nu, &nu,
204 PETSC_NULL);
205
206 ierr = PetscOptionsEnd();
207 CHKERRG(ierr);
208
209 MOFEM_LOG("EP", Sev::inform) << "St Venant Kirchhoff model parameters: "
210 << "E = " << E << ", nu = " << nu;
211
212 lambda = LAMBDA(E, nu);
213 mu = MU(E, nu);
214
216 }
217
218 virtual OpJacobian *
219 returnOpJacobian(const int tag, const bool eval_rhs, const bool eval_lhs,
220 boost::shared_ptr<DataAtIntegrationPts> &data_ptr,
221 boost::shared_ptr<PhysicalEquations> &physics_ptr) {
222 return (new OpHMHH(tag, eval_rhs, eval_lhs, data_ptr, physics_ptr));
223 }
224
225 double lambda;
226 double mu;
227 double sigmaY;
228
237
247
249
250 MoFEMErrorCode recordTape(const int tape, DTensor2Ptr *t_h_ptr) {
259
261
263
264 auto ih = get_h();
265 // auto iH = get_H();
266 if (t_h_ptr)
267 ih(i, j) = (*t_h_ptr)(i, j);
268 else {
269 ih(i, j) = t_kd(i, j);
270 }
271
272 auto r_P = get_P();
273
274 enableMinMaxUsingAbs();
275 trace_on(tape);
276
277 // Set active variables to ADOL-C
278 th(i, j) <<= get_h()(i, j);
279
280 tF(i, I) = th(i, I);
283
284 // Deformation and strain
285 tC(I, J) = tF(i, I) * tF(i, J);
286 tE(I, J) = tC(I, J);
287 tE(N0, N0) -= 1;
288 tE(N1, N1) -= 1;
289 tE(N2, N2) -= 1;
290 tE(I, J) *= 0.5;
291
292 // Energy
293 trE = tE(I, I);
294 energy = 0.5 * lambda * trE * trE + mu * (tE(I, J) * tE(I, J));
295
296 // Stress Piola II
297 tS(I, J) = tE(I, J);
298 tS(I, J) *= 2 * mu;
299 tS(N0, N0) += lambda * trE;
300 tS(N1, N1) += lambda * trE;
301 tS(N2, N2) += lambda * trE;
302 // Stress Piola I
303 tP(i, J) = tF(i, I) * tS(I, J);
304
305 // Set dependent variables to ADOL-C
306 tP(i, j) >>= r_P(i, j);
307
308 trace_off();
309
311 }
312};
313
315
316 static constexpr int numberOfActiveVariables = 9;
317 static constexpr int numberOfDependentVariables = 9;
318
319 HMHPMooneyRivlinWriggersEq63(const double alpha, const double beta,
320 const double lambda)
323
324 virtual OpJacobian *
325 returnOpJacobian(const int tag, const bool eval_rhs, const bool eval_lhs,
326 boost::shared_ptr<DataAtIntegrationPts> &data_ptr,
327 boost::shared_ptr<PhysicalEquations> &physics_ptr) {
328 return (new OpHMHH(tag, eval_rhs, eval_lhs, data_ptr, physics_ptr));
329 }
330
333 CHKERR PetscOptionsBegin(PETSC_COMM_WORLD, "mooneyrivlin_", "", "none");
334
335 alpha = 1;
336 CHKERR PetscOptionsScalar("-alpha", "Alpha", "", alpha, &alpha, PETSC_NULL);
337 beta = 1;
338 CHKERR PetscOptionsScalar("-beta", "Beta", "", beta, &beta, PETSC_NULL);
339
340 lambda = 1;
341 CHKERR PetscOptionsScalar("-lambda", "Lambda", "", lambda, &lambda,
342 PETSC_NULL);
343
344 epsilon = 0;
345 CHKERR PetscOptionsScalar("-epsilon", "Epsilon", "", epsilon, &epsilon,
346 PETSC_NULL);
347
348 ierr = PetscOptionsEnd();
349 CHKERRG(ierr);
351 }
352
353 double alpha;
354 double beta;
355 double lambda;
356 double epsilon;
357
361
366
369
371 // ATensor3 tCofT1;
372 // ATensor3 tCofT2;
376
381
383
384 MoFEMErrorCode recordTape(const int tape, DTensor2Ptr *t_h_ptr) {
386
396
398
400
401 auto ih = get_h();
402 // auto iH = get_H();
403 if (t_h_ptr)
404 ih(i, j) = (*t_h_ptr)(i, j);
405 else {
406 ih(i, j) = t_kd(i, j);
407 }
408
409 auto r_P = get_P();
410
411 enableMinMaxUsingAbs();
412 trace_on(tape);
413
414 // Set active variables to ADOL-C
415 th(i, j) <<= get_h()(i, j);
416
417 tF(i, I) = th(i, I);
420
421 tCof(i, I) = detF * tInvF(I, i);
422
423 A = tF(k, K) * tF(k, K);
424 B = tCof(k, K) * tCof(k, K);
425
426 tBF(i, I) = 4 * alpha * (A * tF(i, I));
427 tBCof(i, I) = 4 * beta * (B * tCof(i, I));
428 tBj = (-12 * alpha - 24 * beta) / detF +
429 0.5 * (lambda / epsilon) *
430 (pow(detF, epsilon - 1) - pow(detF, -epsilon - 1));
431
432 tP(i, I) = tBF(i, I);
433 tP(i, I) += (levi_civita(i, j, k) * tBCof(j, J)) *
434 (levi_civita(I, J, K) * tF(k, K));
435 tP(i, I) += tCof(i, I) * tBj;
436
437 // Set dependent variables to ADOL-C
438 tP(i, j) >>= r_P(i, j);
439
440 trace_off();
441
443 }
444};
445
447 const int tape, const double lambda, const double mu,
448 const double sigma_y) {
450 physicalEquations = boost::make_shared<HMHStVenantKirchhoff>(lambda, mu);
451 CHKERR physicalEquations->recordTape(tape, nullptr);
453}
454
456 const int tape, const double alpha, const double beta, const double lambda,
457 const double sigma_y) {
460 boost::make_shared<HMHPMooneyRivlinWriggersEq63>(alpha, beta, lambda);
461 CHKERR physicalEquations->recordTape(tape, nullptr);
463}
464
466
467 HMHHencky(MoFEM::Interface &m_field, const double E, const double nu)
468 : PhysicalEquations(0, 0), mField(m_field), E(E), nu(nu) {}
469
470 MoFEMErrorCode recordTape(const int tag, DTensor2Ptr *t_h) { return 0; }
471
472 struct OpHenckyJacobian : public OpJacobian {
473 OpHenckyJacobian(boost::shared_ptr<DataAtIntegrationPts> data_ptr,
474 boost::shared_ptr<HMHHencky> hencky_ptr)
475 : OpJacobian(), dataAtGaussPts(data_ptr), henckyPtr(hencky_ptr) {
477 "getOptions failed");
478 CHK_THROW_MESSAGE(henckyPtr->extractBlockData(Sev::inform),
479 "Can not get data from block");
480 }
481
485
486 for (auto &b : henckyPtr->blockData) {
487
488 if (b.blockEnts.find(getFEEntityHandle()) != b.blockEnts.end()) {
489 CHKERR henckyPtr->getMatDPtr(dataAtGaussPts->getMatDPtr(),
490 b.bulkModulusK, b.shearModulusG);
492 }
493 }
494
495 const auto E = henckyPtr->E;
496 const auto nu = henckyPtr->nu;
497
498 double bulk_modulus_K = E / (3 * (1 - 2 * nu));
499 double shear_modulus_G = E / (2 * (1 + nu));
500
501 CHKERR henckyPtr->getMatDPtr(dataAtGaussPts->getMatDPtr(), bulk_modulus_K,
503
505 }
506
507 MoFEMErrorCode evaluateRhs(EntData &data) { return 0; }
508 MoFEMErrorCode evaluateLhs(EntData &data) { return 0; }
509
510 private:
511 boost::shared_ptr<DataAtIntegrationPts> dataAtGaussPts;
512 boost::shared_ptr<HMHHencky> henckyPtr;
513 };
514
515 virtual OpJacobian *
516 returnOpJacobian(const int tag, const bool eval_rhs, const bool eval_lhs,
517 boost::shared_ptr<DataAtIntegrationPts> &data_ptr,
518 boost::shared_ptr<PhysicalEquations> &physics_ptr) {
519 return (new OpHenckyJacobian(
520 data_ptr, boost::dynamic_pointer_cast<HMHHencky>(physics_ptr)));
521 }
522
523 MoFEMErrorCode getOptions(boost::shared_ptr<DataAtIntegrationPts> data_ptr) {
525 CHKERR PetscOptionsBegin(PETSC_COMM_WORLD, "hencky_", "", "none");
526
527 CHKERR PetscOptionsScalar("-young_modulus", "Young modulus", "", E, &E,
528 PETSC_NULL);
529 CHKERR PetscOptionsScalar("-poisson_ratio", "poisson ratio", "", nu, &nu,
530 PETSC_NULL);
531
532 ierr = PetscOptionsEnd();
533 CHKERRG(ierr);
534
536 }
537
539 return extractBlockData(
540
542
543 (boost::format("%s(.*)") % "MAT_ELASTIC").str()
544
545 )),
546
547 sev);
548 }
549
551 extractBlockData(std::vector<const CubitMeshSets *> meshset_vec_ptr,
552 Sev sev) {
554
555 for (auto m : meshset_vec_ptr) {
556 MOFEM_TAG_AND_LOG("WORLD", sev, "MatBlock") << *m;
557 std::vector<double> block_data;
558 CHKERR m->getAttributes(block_data);
559 if (block_data.size() != 2) {
560 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
561 "Expected that block has two attribute");
562 }
563 auto get_block_ents = [&]() {
564 Range ents;
565 CHKERR mField.get_moab().get_entities_by_handle(m->meshset, ents, true);
566 return ents;
567 };
568
569 double young_modulus = block_data[0];
570 double poisson_ratio = block_data[1];
571 double bulk_modulus_K = young_modulus / (3 * (1 - 2 * poisson_ratio));
572 double shear_modulus_G = young_modulus / (2 * (1 + poisson_ratio));
573
574 MOFEM_TAG_AND_LOG("WORLD", sev, "MatBlock")
575 << "E = " << young_modulus << " nu = " << poisson_ratio;
576
577 blockData.push_back({bulk_modulus_K, shear_modulus_G, get_block_ents()});
578 }
579 MOFEM_LOG_CHANNEL("WORLD");
581 }
582
583 MoFEMErrorCode getMatDPtr(boost::shared_ptr<MatrixDouble> mat_D_ptr,
584 double bulk_modulus_K, double shear_modulus_G) {
586 //! [Calculate elasticity tensor]
587 auto set_material_stiffness = [&]() {
593 double A = (SPACE_DIM == 2)
594 ? 2 * shear_modulus_G /
595 (bulk_modulus_K + (4. / 3.) * shear_modulus_G)
596 : 1;
597 auto t_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(*mat_D_ptr);
598 t_D(i, j, k, l) = 2 * shear_modulus_G * ((t_kd(i, k) ^ t_kd(j, l)) / 4.) +
599 A * (bulk_modulus_K - (2. / 3.) * shear_modulus_G) *
600 t_kd(i, j) * t_kd(k, l);
601 };
602 //! [Calculate elasticity tensor]
603 constexpr auto size_symm = (SPACE_DIM * (SPACE_DIM + 1)) / 2;
604 mat_D_ptr->resize(size_symm * size_symm, 1);
605 set_material_stiffness();
607 }
608
609private:
611
612 struct BlockData {
616 };
617 std::vector<BlockData> blockData;
618
619 double E;
620 double nu;
621};
622
625 physicalEquations = boost::make_shared<HMHHencky>(mField, E, nu);
627}
628
629}; // namespace EshelbianPlasticity
static Index< 'o', 3 > o
static Index< 'J', 3 > J
static Number< 2 > N2
static Index< 'p', 3 > p
static Number< 1 > N1
static Number< 0 > N0
constexpr double third
Eshelbian plasticity interface.
#define MOFEM_TAG_AND_LOG(channel, severity, tag)
Tag and log in channel.
Definition: LogManager.hpp:362
constexpr int SPACE_DIM
Kronecker Delta class symmetric.
Kronecker Delta class.
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition: definitions.h:595
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:447
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
#define CHKERRG(n)
Check error code of MoFEM/MOAB/PETSc function.
Definition: definitions.h:483
@ MOFEM_OPERATION_UNSUCCESSFUL
Definition: definitions.h:34
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
#define CHKERR
Inline error check.
Definition: definitions.h:535
double bulk_modulus_K
double shear_modulus_G
#define MU(E, NU)
Definition: fem_tools.h:23
#define LAMBDA(E, NU)
Definition: fem_tools.h:22
FTensor::Index< 'n', SPACE_DIM > n
FTensor::Index< 'm', SPACE_DIM > m
constexpr auto t_kd
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
SeverityLevel
Severity levels.
Definition: LogManager.hpp:33
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
Definition: LogManager.hpp:284
MoFEMErrorCode getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
get cubit meshset
FTensor::Index< 'i', SPACE_DIM > i
static double lambda
const double v
phase velocity of light in medium (cm/ns)
FTensor::Index< 'l', 3 > l
FTensor::Index< 'j', 3 > j
FTensor::Index< 'k', 3 > k
static constexpr auto size_symm
static MoFEMErrorCodeGeneric< PetscErrorCode > ierr
Definition: Exceptions.hpp:76
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
MoFEMErrorCode invertTensor3by3(ublas::matrix< T, L, A > &jac_data, ublas::vector< T, A > &det_data, ublas::matrix< T, L, A > &inv_jac_data)
Calculate inverse of tensor rank 2 at integration points.
Definition: Templates.hpp:1608
static auto determinantTensor3by3(T &t)
Calculate the determinant of a 3x3 matrix or a tensor of rank 2.
Definition: Templates.hpp:1557
constexpr IntegrationType I
constexpr AssemblyType A
double young_modulus
Young modulus.
Definition: plastic.cpp:172
MoFEMErrorCode addMaterial_Hencky(double E, double nu)
MoFEMErrorCode addMaterial_HMHHStVenantKirchhoff(const int tape, const double lambda, const double mu, const double sigma_y)
MoFEMErrorCode addMaterial_HMHMooneyRivlin(const int tape, const double alpha, const double beta, const double lambda, const double sigma_y)
boost::shared_ptr< PhysicalEquations > physicalEquations
OpHenckyJacobian(boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< HMHHencky > hencky_ptr)
boost::shared_ptr< DataAtIntegrationPts > dataAtGaussPts
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
virtual OpJacobian * returnOpJacobian(const int tag, const bool eval_rhs, const bool eval_lhs, boost::shared_ptr< DataAtIntegrationPts > &data_ptr, boost::shared_ptr< PhysicalEquations > &physics_ptr)
MoFEMErrorCode extractBlockData(Sev sev)
std::vector< BlockData > blockData
MoFEMErrorCode extractBlockData(std::vector< const CubitMeshSets * > meshset_vec_ptr, Sev sev)
MoFEMErrorCode getMatDPtr(boost::shared_ptr< MatrixDouble > mat_D_ptr, double bulk_modulus_K, double shear_modulus_G)
HMHHencky(MoFEM::Interface &m_field, const double E, const double nu)
MoFEMErrorCode getOptions(boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode recordTape(const int tag, DTensor2Ptr *t_h)
HMHPMooneyRivlinWriggersEq63(const double alpha, const double beta, const double lambda)
virtual OpJacobian * returnOpJacobian(const int tag, const bool eval_rhs, const bool eval_lhs, boost::shared_ptr< DataAtIntegrationPts > &data_ptr, boost::shared_ptr< PhysicalEquations > &physics_ptr)
MoFEMErrorCode recordTape(const int tape, DTensor2Ptr *t_h_ptr)
HMHStVenantKirchhoff(const double lambda, const double mu)
virtual OpJacobian * returnOpJacobian(const int tag, const bool eval_rhs, const bool eval_lhs, boost::shared_ptr< DataAtIntegrationPts > &data_ptr, boost::shared_ptr< PhysicalEquations > &physics_ptr)
MoFEMErrorCode recordTape(const int tape, DTensor2Ptr *t_h_ptr)
OpHMHH(const int tag, const bool eval_rhs, const bool eval_lhs, boost::shared_ptr< DataAtIntegrationPts > &data_ptr, boost::shared_ptr< PhysicalEquations > &physics_ptr)
MoFEMErrorCode evaluateLhs(EntData &data)
MoFEMErrorCode evaluateRhs(EntData &data)
boost::shared_ptr< PhysicalEquations > physicsPtr
material physical equations
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
virtual moab::Interface & get_moab()=0
Deprecated interface functions.
Data on single entity (This is passed as argument to DataOperator::doWork)
Interface for managing meshsets containing materials and boundary conditions.
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce to pointer of interface.