v0.15.0
Loading...
Searching...
No Matches
EshelbianOperators.hpp
Go to the documentation of this file.
1/**
2 * @file EshelbianOperators.hpp
3 * @author your name (you@domain.com)
4 * @brief
5 * @version 0.1
6 * @date 2024-12-31
7 *
8 * @copyright Copyright (c) 2024
9 *
10 */
11
12
13
15
16 OpJacobian(const int tag, const bool eval_rhs, const bool eval_lhs,
17 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
18 boost::shared_ptr<PhysicalEquations> physics_ptr)
19 : UserDataOperator(NOSPACE, OPSPACE), tAg(tag), evalRhs(eval_rhs),
20 evalLhs(eval_lhs), dataAtPts(data_ptr), physicsPtr(physics_ptr) {}
21
22 virtual MoFEMErrorCode evaluateRhs(EntData &data) = 0;
23 virtual MoFEMErrorCode evaluateLhs(EntData &data) = 0;
24
25 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
26
27protected:
29
30 int tAg = -1; ///< adol-c tape
31 bool evalRhs = false;
32 bool evalLhs = false;
33
34 boost::shared_ptr<DataAtIntegrationPts>
35 dataAtPts; ///< data at integration pts
36 boost::shared_ptr<PhysicalEquations>
37 physicsPtr; ///< material physical equations
38};
39
40template <typename T> struct OpAssembleBasic : public T {
41
42 using ScaleOff = boost::function<double()>;
43 const bool assembleSymmetry;
44
45 boost::shared_ptr<DataAtIntegrationPts>
46 dataAtPts; ///< data at integration pts
47
48 OpAssembleBasic(const std::string &field_name,
49 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
50 const char type)
51 : T(field_name, type), dataAtPts(data_ptr), assembleSymmetry(false) {}
52
54 std::string row_field, std::string col_field,
55 boost::shared_ptr<DataAtIntegrationPts> data_ptr, const char type,
56 const bool assemble_symmetry, ScaleOff scale_off = []() { return 1; })
57 : T(row_field, col_field, type, false), dataAtPts(data_ptr),
58 assembleSymmetry(assemble_symmetry), scaleOff(scale_off) {}
59
61 : T(space, T::OPSPACE), assembleSymmetry(false) {}
62
63 VectorDouble nF; ///< local right hand side vector
64 MatrixDouble K; ///< local tangent matrix
65 MatrixDouble transposeK;
66
68
69 virtual MoFEMErrorCode integrate(EntData &data) {
71 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "Not yet implemented");
73 }
74
75 virtual MoFEMErrorCode integrate(int row_side, EntityType row_type,
76 EntData &data) {
78 CHKERR integrate(data);
80 }
81
82 virtual MoFEMErrorCode assemble(EntData &data) {
84 double *vec_ptr = &*nF.begin();
85 int nb_dofs = data.getIndices().size();
86 int *ind_ptr = &*data.getIndices().begin();
87 CHKERR VecSetValues(this->getTSf(), nb_dofs, ind_ptr, vec_ptr, ADD_VALUES);
89 }
90
91 virtual MoFEMErrorCode assemble(int row_side, EntityType row_type,
92 EntData &data) {
94 CHKERR assemble(data);
96 }
97
98 virtual MoFEMErrorCode integrate(EntData &row_data, EntData &col_data) {
100 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "Not yet implemented");
102 }
103
104 virtual MoFEMErrorCode assemble(int row_side, int col_side,
105 EntityType row_type, EntityType col_type,
106 EntData &row_data, EntData &col_data) {
108
109 if (assembleSymmetry) {
110 const auto row_nb_dofs = row_data.getIndices().size();
111 const auto col_nb_dofs = col_data.getIndices().size();
112 transposeK.resize(col_nb_dofs, row_nb_dofs, false);
113 noalias(transposeK) = trans(K);
114 transposeK *= scaleOff();
115 }
116
117 CHKERR MatSetValues<AssemblyTypeSelector<A>>(this->getTSB(), row_data,
118 col_data, K, ADD_VALUES);
119 if (assembleSymmetry) {
120 CHKERR MatSetValues<AssemblyTypeSelector<A>>(
121 this->getTSB(), col_data, row_data, transposeK, ADD_VALUES);
122 }
123
125 }
126
127 MoFEMErrorCode doWork(int side, EntityType type, EntData &data) {
129 if (data.getIndices().empty())
131 nF.resize(data.getIndices().size(), false);
132 nF.clear();
133 CHKERR integrate(side, type, data);
134 CHKERR assemble(side, type, data);
136 }
137
138 MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
139 EntityType col_type, EntData &row_data,
140 EntData &col_data) {
142 if (row_data.getIndices().empty())
144 if (col_data.getIndices().empty())
146 K.resize(row_data.getIndices().size(), col_data.getIndices().size(), false);
147 K.clear();
148 CHKERR integrate(row_data, col_data);
149 CHKERR assemble(row_side, col_side, row_type, col_type, row_data, col_data);
151 }
152
153};
154
155struct OpAssembleVolume : public OpAssembleBasic<VolUserDataOperator> {
158 MoFEMErrorCode assemble(int row_side, int col_side, EntityType row_type,
159 EntityType col_type, EntData &row_data,
160 EntData &col_data) {
162 CHKERR OP::assemble(row_side, col_side, row_type, col_type, row_data,
163 col_data);
164 constexpr bool store_matrices = false;
165 if constexpr (store_matrices) {
167 m.resize(K.size1(), K.size2(), false);
168 noalias(m) = K;
169 if (assembleSymmetry) {
171 m.resize(K.size2(), K.size1(), false);
172 noalias(m) = transposeK;
173 }
174 }
176 };
177
178protected:
179 static inline std::map<std::pair<std::string, std::string>, MatrixDouble>
181};
182
185 using OP::OpAssembleVolume;
187 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
188};
189
190struct OpAssembleFace : public OpAssembleBasic<FaceUserDataOperator> {
191 using OpAssembleBasic<FaceUserDataOperator>::OpAssembleBasic;
192};
193
195 using OpAssembleVolume::OpAssembleVolume;
196 MoFEMErrorCode doWork(int side, EntityType type, EntData &data) {
198 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
199 "OpAssembleVolumePositiveDefine not implemented");
201 }
202
203 MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
204 EntityType col_type, EntData &row_data,
205 EntData &col_data) {
207 if (row_data.getIndices().empty())
209 if (col_data.getIndices().empty())
211 K.resize(row_data.getIndices().size(), col_data.getIndices().size(), false);
212 K.clear();
213 CHKERR integrate(row_data, col_data);
214
215 constexpr bool run_psd = true;
216
217 if (run_psd) {
218
219 auto symmetrize = [](MatrixDouble &mat) {
220 MatrixDouble r = (mat + trans(mat)) / 2.0;
221 return r;
222 };
223 auto check_positive_definite = [](MatrixDouble &mat) {
224 int n = mat.size1();
225 return (lapack_dpotrf('U', n, mat.data().data(), n) == 0);
226 };
227 auto frobenius_norm = [](MatrixDouble &mat) {
228 double sum = 0.0;
229 for (std::size_t i = 0; i < mat.size1(); ++i)
230 for (std::size_t j = 0; j < mat.size2(); ++j)
231 sum += mat(i, j) * mat(i, j);
232 return std::sqrt(sum);
233 };
234
235 auto higham_method_one_pass = [&](MatrixDouble &mat) {
236 int n = mat.size1();
237 const int lda = n;
238 const int size = (n + 2) * n;
239 int lwork = size;
240 double *work = new double[size];
241
242 VectorDouble eig(n, 0.0);
243 MatrixDouble eigen_vec = prod(trans(mat), mat);
244 if (lapack_dsyev('V', 'U', n, eigen_vec.data().data(), lda,
245 eig.data().data(), work, lwork) > 0)
247 "The algorithm failed to compute eigenvalues.");
248 delete[] work;
249
250 for (auto &e : eig) {
251 constexpr double eps = std::numeric_limits<double>::epsilon();
252 e = std::max(std::sqrt(std::abs(e)), eps);
253 }
254
255 auto diagonal_matrix =
256 ublas::diagonal_matrix<double, ublas::row_major,
257 VecAllocator<double>>(n, eig.data());
258 MatrixDouble symm_mat;
259 symm_mat = prod(trans(eigen_vec), diagonal_matrix);
260 symm_mat = prod(symm_mat, eigen_vec);
261
262 MatrixDouble hat_m = (mat + symm_mat) / 2.0;
263
264 return hat_m;
265 };
266
267 auto hat_k = higham_method_one_pass(K);
268 K.swap(hat_k);
269 }
270
271 CHKERR assemble(row_side, col_side, row_type, col_type, row_data, col_data);
273 }
274
275private:
276};
277
278// Add operator to calculate Eshelby tensor
279
281 : public ForcesAndSourcesCore::UserDataOperator {
282 OpCalculateEshelbyStress(boost::shared_ptr<DataAtIntegrationPts> data_ptr)
284 dataAtPts(data_ptr) {}
285 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
286
287private:
288 boost::shared_ptr<DataAtIntegrationPts>
289 dataAtPts; ///< data at integration pts
290};
291
293
295 boost::shared_ptr<DataAtIntegrationPts> data_ptr, double alpha_omega = 0)
297 alphaOmega(alpha_omega) {}
298 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
299
300private:
301 boost::shared_ptr<DataAtIntegrationPts>
302 dataAtPts; ///< data at integration pts
304};
305
308 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
309 : SideEleOp(NOSPACE, SideEleOp::OPSPACE), dataAtPts(data_ptr) {
310 std::fill(&doEntities[MBVERTEX], &doEntities[MBMAXTYPE], false);
311 for (auto t = moab::CN::TypeDimensionMap[SPACE_DIM].first;
312 t <= moab::CN::TypeDimensionMap[SPACE_DIM].second; ++t)
313 doEntities[t] = true;
314 sYmm = false;
315 }
316 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
317
318private:
319 boost::shared_ptr<DataAtIntegrationPts>
320 dataAtPts; ///< data at integration pts
321};
322
323struct OpCalculateReactionForces : public FaceUserDataOperator {
324 OpCalculateReactionForces(boost::shared_ptr<DataAtIntegrationPts> data_ptr,
325 std::string block_name, Range block_entities,
326 std::array<double, 6> &reaction_vec)
327 : FaceUserDataOperator(NOSPACE, OPSPACE), dataAtPts(data_ptr),
328 blockName(block_name), blockEntities(block_entities),
329 reactionVec(reaction_vec) {}
330 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
331
332private:
333 boost::shared_ptr<DataAtIntegrationPts>
334 dataAtPts; ///< data at integration pts
336 std::string blockName;
337 std::array<double, 6> &reactionVec;
338};
339
342 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
343 const double alpha, const double rho)
344 : OpAssembleVolume(field_name, data_ptr, OPROW), alphaW(alpha),
345 alphaRho(rho) {}
346 MoFEMErrorCode integrate(EntData &data);
347
348private:
349 const double alphaW;
350 const double alphaRho;
351
352};
353
355 OpSpatialRotation(const std::string &field_name,
356 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
357 double alpha_omega)
358 : OpAssembleVolume(field_name, data_ptr, OPROW), alphaOmega(alpha_omega) {
359 }
360 MoFEMErrorCode integrate(EntData &data);
361
362private:
364};
365
368 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
369 : OpAssembleVolume(field_name, data_ptr, OPROW) {}
370 MoFEMErrorCode integrate(EntData &data);
371
372private:
373};
374
377 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
378 : OpAssembleVolume(field_name, data_ptr, OPROW) {}
379 MoFEMErrorCode integrate(EntData &data);
380
381private:
382};
383
386 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
387 : OpAssembleVolume(field_name, data_ptr, OPROW) {}
388 MoFEMErrorCode integrate(EntData &data);
389};
390
391template <int INTERP_ORDER>
393 OpGetInternalStress(boost::shared_ptr<DataAtIntegrationPts> data_ptr,
394 std::string tag_name = "")
395 : UserDataOperator(H1, OPLAST), dataAtPts(data_ptr), tagName(tag_name) {
396 std::fill(&doEntities[MBVERTEX], &doEntities[MBMAXTYPE], false);
397 doEntities[MBVERTEX] = true;
398 }
399 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
400
401private:
402 boost::shared_ptr<DataAtIntegrationPts> dataAtPts;
403 std::string tagName;
404};
405
406template <bool VOIGT>
409 const std::string &field_name,
410 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
411 : OpAssembleVolume(field_name, data_ptr, OPROW) {}
412 MoFEMErrorCode integrate(EntData &row_data);
413};
414
415
416template <AssemblyType A, IntegrationType I> struct OpDispBcImpl;
417
418template <AssemblyType A>
419struct OpDispBcImpl<A, GAUSS>
420 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
421
422 using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
424
426 boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
427 boost::shared_ptr<BcDispVec> &bc_disp_ptr,
428 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
429 boost::shared_ptr<Range> ents_ptr = nullptr)
430 : OP(broken_base_side_data, ents_ptr), bcDispPtr(bc_disp_ptr),
431 scalingMethodsMap(smv) {}
432
433protected:
434 MoFEMErrorCode iNtegrate(EntData &data);
435 boost::shared_ptr<BcDispVec> bcDispPtr;
436 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
437};
438
439struct OpDispBc : public OpDispBcImpl<PETSC, GAUSS> {
441 using OP::OpDispBcImpl;
442
443protected:
444 MoFEMErrorCode iNtegrate(EntData &data);
445};
446
447template <AssemblyType A, IntegrationType I> struct OpRotationBcImpl;
448
449template <AssemblyType A>
450struct OpRotationBcImpl<A, GAUSS>
451 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
452
453 using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
455
457 boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
458 boost::shared_ptr<BcRotVec> &bc_rot_ptr,
459 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
460 boost::shared_ptr<Range> ents_ptr = nullptr)
461 : OP(broken_base_side_data, ents_ptr), bcRotPtr(bc_rot_ptr),
462 scalingMethodsMap(smv) {}
463
464protected:
465 MoFEMErrorCode iNtegrate(EntData &data);
466 boost::shared_ptr<BcRotVec> bcRotPtr;
467 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
468};
469
470/**
471 * @brief Apply rotation boundary condition
472 *
473 * The boundary condition is applied getting data from the SPATIAL_ROTATION_BC
474 * blockset.
475 *
476 * Centre of rotation is given by the first three attributes of the blockset.
477 * The fort parameter is angle of rotation
478 *
479 */
480struct OpRotationBc : public OpRotationBcImpl<PETSC, GAUSS> {
482 using OP::OpRotationBcImpl;
483
484protected:
485 MoFEMErrorCode iNtegrate(EntData &data);
486};
487
489 : public FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase {
491 const std::string row_field, boost::shared_ptr<TractionBcVec> bc_data,
492 boost::shared_ptr<double> piola_scale_ptr,
493 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv)
494 : FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase(
495 row_field, row_field, FaceUserDataOperator::OPROW),
496 bcData(bc_data), piolaScalePtr(), scalingMethodsMap(smv) {}
497
498 MoFEMErrorCode iNtegrate(EntData &data);
499
500protected:
501 boost::shared_ptr<TractionBcVec> bcData;
502 boost::shared_ptr<double> piolaScalePtr;
503 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
504};
505
507 : public FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase {
509 const std::string row_field, boost::shared_ptr<PressureBcVec> bc_data,
510 boost::shared_ptr<double> piola_scale_ptr,
511 boost::shared_ptr<MatrixDouble> hybrid_grad_disp,
512 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv)
513 : FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase(
514 row_field, row_field, FaceUserDataOperator::OPROW),
515 bcData(bc_data), piolaScalePtr(), hybridGradDispPtr(hybrid_grad_disp),
516 scalingMethodsMap(smv) {}
517
518 MoFEMErrorCode iNtegrate(EntData &data);
519
520protected:
521 boost::shared_ptr<PressureBcVec> bcData;
522 boost::shared_ptr<double> piolaScalePtr;
523 boost::shared_ptr<MatrixDouble> hybridGradDispPtr;
524 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
525};
526
527template <AssemblyType A, IntegrationType I> struct OpBrokenPressureBcLhsImpl_dU;
528
529template <AssemblyType A>
531 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBase {
532
533 using OP =
534 typename FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBase;
535
537 std::string row_field, boost::shared_ptr<PressureBcVec> bc_data,
538 boost::shared_ptr<MatrixDouble> hybrid_grad_disp,
539 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv)
540 : OP(row_field, row_field, OP::OPROWCOL), bcData(bc_data),
541 hybridGradDispPtr(hybrid_grad_disp), scalingMethodsMap(smv) {}
542
543protected:
544 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
545 boost::shared_ptr<PressureBcVec> bcData;
546 boost::shared_ptr<MatrixDouble> hybridGradDispPtr;
547 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
548};
549
553
554protected:
555 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
556};
557
559 : public FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase {
561 const std::string row_field, boost::shared_ptr<AnalyticalTractionBcVec> bc_data,
562 boost::shared_ptr<double> piola_scale_ptr,
563 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv)
564 : FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase(
565 row_field, row_field, FaceUserDataOperator::OPROW),
566 bcData(bc_data), piolaScalePtr(), scalingMethodsMap(smv) {}
567
568 MoFEMErrorCode iNtegrate(EntData &data);
569
570protected:
571 boost::shared_ptr<AnalyticalTractionBcVec> bcData;
572 boost::shared_ptr<double> piolaScalePtr;
573 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
574};
575
576template <AssemblyType A, IntegrationType I> struct OpNormalDispBcRhsImpl;
577template <AssemblyType A, IntegrationType I> struct OpNormalDispBcLhsImpl_dU;
578template <AssemblyType A, IntegrationType I> struct OpNormalDispBcLhsImpl_dP;
579
580template <AssemblyType A>
581struct OpNormalDispBcRhsImpl<A, GAUSS>
582 : public FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase {
583
584 using OP =
585 typename FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase;
586
588 std::string row_field, boost::shared_ptr<MatrixDouble> hybrid_disp_ptr,
589 boost::shared_ptr<MatrixDouble> piola_stress_ptr,
590 boost::shared_ptr<NormalDisplacementBcVec> &bc_disp_ptr,
591 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
592 boost::shared_ptr<Range> ents_ptr = nullptr)
593 : FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase(
594 row_field, row_field, OP::OPROW),
595 hybridDispPtr(hybrid_disp_ptr), piolaStressPtr(piola_stress_ptr),
596 bcDispPtr(bc_disp_ptr), scalingMethodsMap(smv) {}
597
598protected:
599 MoFEMErrorCode iNtegrate(EntData &data);
600 boost::shared_ptr<MatrixDouble> hybridDispPtr;
601 boost::shared_ptr<MatrixDouble> piolaStressPtr;
602 boost::shared_ptr<NormalDisplacementBcVec> bcDispPtr;
603 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
604};
605
606template <AssemblyType A>
608 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBase {
609
610 using OP =
611 typename FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBase;
612
614 std::string row_field,
615 boost::shared_ptr<NormalDisplacementBcVec> &bc_disp_ptr,
616 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
617 boost::shared_ptr<Range> ents_ptr = nullptr)
618 : OP(row_field, row_field, OP::OPROWCOL), bcDispPtr(bc_disp_ptr),
619 scalingMethodsMap(smv) {}
620
621protected:
622 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
623 boost::shared_ptr<NormalDisplacementBcVec> bcDispPtr;
624 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
625};
626
627template <AssemblyType A>
629 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
630
631 using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
633
635 std::string row_field,
636 boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
637 boost::shared_ptr<NormalDisplacementBcVec> &bc_disp_ptr,
638 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
639 boost::shared_ptr<Range> ents_ptr = nullptr)
640 : OP(row_field, broken_base_side_data, false, false, ents_ptr),
641 bcDispPtr(bc_disp_ptr), scalingMethodsMap(smv) {}
642
643protected:
644 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
645 boost::shared_ptr<NormalDisplacementBcVec> bcDispPtr;
646 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
647};
648
649struct OpNormalDispRhsBc : public OpNormalDispBcRhsImpl<PETSC, GAUSS> {
651 using OP::OpNormalDispBcRhsImpl;
652
653protected:
654 MoFEMErrorCode iNtegrate(EntData &data);
655};
656
660
661protected:
662 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
663};
664
668
669protected:
670 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
671};
672
673template <AssemblyType A, IntegrationType I> struct OpAnalyticalDispBcImpl;
674
675template <AssemblyType A>
677 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
678
679 using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
681
683 boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
684 boost::shared_ptr<AnalyticalDisplacementBcVec> &bc_disp_ptr,
685 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
686 boost::shared_ptr<Range> ents_ptr = nullptr)
687 : OP(broken_base_side_data, ents_ptr), bcDispPtr(bc_disp_ptr),
688 scalingMethodsMap(smv) {}
689
690protected:
691 MoFEMErrorCode iNtegrate(EntData &data);
692 boost::shared_ptr<AnalyticalDisplacementBcVec> bcDispPtr;
693 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
694};
695
696struct OpAnalyticalDispBc : public OpAnalyticalDispBcImpl<PETSC, GAUSS> {
698 using OP::OpAnalyticalDispBcImpl;
699
700protected:
701 MoFEMErrorCode iNtegrate(EntData &data);
702};
703
705 OpSpatialEquilibrium_dw_dP(std::string row_field, std::string col_field,
706 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
707 const bool assemble_off = false)
708 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
709 assemble_off) {
710 sYmm = false;
711 }
712 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
713};
714
716 const double alphaW;
717 const double alphaRho;
718 OpSpatialEquilibrium_dw_dw(std::string row_field, std::string col_field,
719 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
720 const double alpha, const double rho)
721 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false),
722 alphaW(alpha), alphaRho(rho) {
723 sYmm = true;
724 }
725 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
726};
727
729 OpSpatialPhysical_du_dP(std::string row_field, std::string col_field,
730 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
731 const bool assemble_off = false)
732 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
733 assemble_off) {
734 sYmm = false;
735 }
736
737 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
738};
739
741 OpSpatialPhysical_du_dBubble(std::string row_field, std::string col_field,
742 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
743 const bool assemble_off = false)
744 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
745 assemble_off) {
746 sYmm = false;
747 }
748
749 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
750};
751
753 using OpAssembleVolume::OpAssembleVolume;
754 OpSpatialPhysical_du_domega(std::string row_field, std::string col_field,
755 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
756 const bool assemble_off)
757 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
758 assemble_off) {
759 sYmm = false;
760 }
761 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
762};
763
765 OpSpatialRotation_domega_du(std::string row_field, std::string col_field,
766 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
767 double alpha_omega)
768 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
769 sYmm = false;
770 }
771 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
772private:
773};
774
776 OpSpatialRotation_domega_dP(std::string row_field, std::string col_field,
777 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
778 const bool assemble_off)
779 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
780 assemble_off) {
781 sYmm = false;
782 }
783 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
784};
785
788 std::string row_field, std::string col_field,
789 boost::shared_ptr<DataAtIntegrationPts> data_ptr, const bool assemble_off)
790 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
791 assemble_off) {
792 sYmm = false;
793 }
794 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
795};
796
797
800 std::string row_field, std::string col_field,
801 boost::shared_ptr<DataAtIntegrationPts> data_ptr, double alpha_omega)
802 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false),
803 alphaOmega(alpha_omega) {
804 sYmm = false;
805 }
806 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
807
808private:
810};
811
813 OpSpatialConsistency_dP_dP(std::string row_field, std::string col_field,
814 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
815 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
816 sYmm = false;
817 }
818 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
819
820private:
821 template <int S>
822 MoFEMErrorCode integrateImpl(EntData &row_data, EntData &col_data);
823};
824
827 std::string row_field, std::string col_field,
828 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
829 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
830 sYmm = false;
831 }
832 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
833
834private:
835 template <int S>
836 MoFEMErrorCode integrateImpl(EntData &row_data, EntData &col_data);
837};
838
841 std::string row_field, std::string col_field,
842 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
843 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, true) {
844 sYmm = false;
845 }
846 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
847
848private:
849 template <int S>
850 MoFEMErrorCode integrateImpl(EntData &row_data, EntData &col_data);
851};
852
855 std::string row_field, std::string col_field,
856 boost::shared_ptr<DataAtIntegrationPts> data_ptr, const bool assemble_off)
857 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
858 assemble_off) {
859 sYmm = false;
860 }
861 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
862
863private:
864};
865
868 std::string row_field, std::string col_field,
869 boost::shared_ptr<DataAtIntegrationPts> data_ptr, const bool assemble_off)
870 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
871 assemble_off) {
872 sYmm = false;
873 }
874 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
875
876private:
877};
878
880 : public VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator {
881
882 using OP = VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator;
883
884 moab::Interface &postProcMesh;
885 std::vector<EntityHandle> &mapGaussPts;
886 boost::shared_ptr<DataAtIntegrationPts> dataAtPts;
887
888 OpPostProcDataStructure(moab::Interface &post_proc_mesh,
889 std::vector<EntityHandle> &map_gauss_pts,
890 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
891 int sense)
892 : OP(NOSPACE, UserDataOperator::OPSPACE), postProcMesh(post_proc_mesh),
893 mapGaussPts(map_gauss_pts), dataAtPts(data_ptr), tagSense(sense) {}
894
895 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
896
897private:
899};
900
902 OpSpatialPrj(std::string row_field,
903 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
904 : OpAssembleVolume(row_field, data_ptr, OPROW) {}
905 MoFEMErrorCode integrate(EntData &row_data);
906};
907
909 OpSpatialPrj_dx_dx(std::string row_field, std::string col_field,
910 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
911 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
912 // FIXME: That is symmetric
913 sYmm = false;
914 }
915 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
916};
917
919 OpSpatialPrj_dx_dw(std::string row_field, std::string col_field,
920 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
921 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
922 sYmm = false;
923 }
924 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
925};
926
928 : public VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator {
929
930 // @note This is not on the side, since, integrate energy in the volume
931 using OP = VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator;
932
933 OpFaceSideMaterialForce(boost::shared_ptr<DataAtIntegrationPts> data_ptr)
934 : OP(NOSPACE, OPSPACE), dataAtPts(data_ptr) {}
935
936 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
937
938private:
939 boost::shared_ptr<DataAtIntegrationPts>
940 dataAtPts; ///< data at integration pts
941};
942
944 : public FaceElementForcesAndSourcesCore::UserDataOperator {
945
946 // @note This is not on the side, since, integrate energy in the volume
947 using OP = FaceElementForcesAndSourcesCore::UserDataOperator;
948
949 OpFaceMaterialForce(boost::shared_ptr<DataAtIntegrationPts> data_ptr)
950 : OP(NOSPACE, OPSPACE), dataAtPts(data_ptr) {}
951
952 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
953
954private:
955 boost::shared_ptr<DataAtIntegrationPts>
956 dataAtPts; ///< data at integration pts
957};
958
959template <int FE_DIM, int PROBLEM_DIM, int SPACE_DIM> struct AddHOOps;
960
961template <> struct AddHOOps<2, 3, 3> {
962 AddHOOps() = delete;
963 static MoFEMErrorCode
964 add(boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
965 std::vector<FieldSpace> space, std::string geom_field_name,
966 boost::shared_ptr<Range> crack_front_edges_ptr);
967};
968
969template <> struct AddHOOps<2, 2, 3> {
970 AddHOOps() = delete;
971 static MoFEMErrorCode
972 add(boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
973 std::vector<FieldSpace> space, std::string geom_field_name,
974 boost::shared_ptr<Range> crack_front_edges_ptr);
975};
976
977template <> struct AddHOOps<3, 3, 3> {
978 AddHOOps() = delete;
979 static MoFEMErrorCode
980 add(boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
981 std::vector<FieldSpace> space, std::string geom_field_name,
982 boost::shared_ptr<Range> crack_front_edges_ptr);
983};
984
ForcesAndSourcesCore::UserDataOperator UserDataOperator
static const double eps
constexpr int SPACE_DIM
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
FieldSpace
approximation spaces
Definition definitions.h:82
@ H1
continuous field
Definition definitions.h:85
@ NOSPACE
Definition definitions.h:83
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
@ MOFEM_INVALID_DATA
Definition definitions.h:36
@ MOFEM_NOT_IMPLEMENTED
Definition definitions.h:32
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
FTensor::Index< 'i', SPACE_DIM > i
const double n
refractive index of diffusive medium
static __CLPK_integer lapack_dpotrf(char uplo, __CLPK_integer n, __CLPK_doublereal *a, __CLPK_integer lda)
static __CLPK_integer lapack_dsyev(char jobz, char uplo, __CLPK_integer n, __CLPK_doublereal *a, __CLPK_integer lda, __CLPK_doublereal *w, __CLPK_doublereal *work, __CLPK_integer lwork)
FTensor::Index< 'j', 3 > j
double rho
Definition plastic.cpp:144
constexpr double t
plate stiffness
Definition plate.cpp:58
constexpr auto field_name
OpBaseImpl< PETSC, EdgeEleOp > OpBase
Definition radiation.cpp:29
FTensor::Index< 'm', 3 > m
static MoFEMErrorCode add(boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, std::vector< FieldSpace > space, std::string geom_field_name, boost::shared_ptr< Range > crack_front_edges_ptr)
static MoFEMErrorCode add(boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, std::vector< FieldSpace > space, std::string geom_field_name, boost::shared_ptr< Range > crack_front_edges_ptr)
static MoFEMErrorCode add(boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, std::vector< FieldSpace > space, std::string geom_field_name, boost::shared_ptr< Range > crack_front_edges_ptr)
bool sYmm
If true assume that matrix is symmetric structure.
Data on single entity (This is passed as argument to DataOperator::doWork)
const VectorInt & getIndices() const
Get global indices of dofs on entity.
@ OPROW
operator doWork function is executed on FE rows
@ OPROWCOL
operator doWork is executed on FE rows &columns
@ OPSPACE
operator do Work is execute on space data
boost::shared_ptr< AnalyticalDisplacementBcVec > bcDispPtr
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
MoFEMErrorCode iNtegrate(EntData &data)
OpAnalyticalDispBcImpl(boost::shared_ptr< std::vector< BrokenBaseSideData > > broken_base_side_data, boost::shared_ptr< AnalyticalDisplacementBcVec > &bc_disp_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv, boost::shared_ptr< Range > ents_ptr=nullptr)
MoFEMErrorCode iNtegrate(EntData &data)
MatrixDouble K
local tangent matrix
virtual MoFEMErrorCode integrate(int row_side, EntityType row_type, EntData &data)
VectorDouble nF
local right hand side vector
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
virtual MoFEMErrorCode assemble(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
virtual MoFEMErrorCode integrate(EntData &data)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
virtual MoFEMErrorCode assemble(EntData &data)
OpAssembleBasic(const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const char type)
virtual MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
boost::function< double()> ScaleOff
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
OpAssembleBasic(const FieldSpace space)
virtual MoFEMErrorCode assemble(int row_side, EntityType row_type, EntData &data)
OpAssembleBasic(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const char type, const bool assemble_symmetry, ScaleOff scale_off=[]() { return 1;})
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Operator for linear form, usually to calculate values on right hand side.
MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
Operator for bi-linear form, usually to calculate values on left hand side.
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Operator for linear form, usually to calculate values on right hand side.
static std::map< std::pair< std::string, std::string >, MatrixDouble > mapMatrix
MoFEMErrorCode assemble(int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
boost::shared_ptr< AnalyticalTractionBcVec > bcData
OpBrokenAnalyticalTractionBc(const std::string row_field, boost::shared_ptr< AnalyticalTractionBcVec > bc_data, boost::shared_ptr< double > piola_scale_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv)
boost::shared_ptr< double > piolaScalePtr
MoFEMErrorCode iNtegrate(EntData &data)
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
boost::shared_ptr< MatrixDouble > hybridGradDispPtr
OpBrokenPressureBcLhsImpl_dU(std::string row_field, boost::shared_ptr< PressureBcVec > bc_data, boost::shared_ptr< MatrixDouble > hybrid_grad_disp, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv)
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
boost::shared_ptr< PressureBcVec > bcData
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
boost::shared_ptr< MatrixDouble > hybridGradDispPtr
boost::shared_ptr< double > piolaScalePtr
MoFEMErrorCode iNtegrate(EntData &data)
OpBrokenPressureBc(const std::string row_field, boost::shared_ptr< PressureBcVec > bc_data, boost::shared_ptr< double > piola_scale_ptr, boost::shared_ptr< MatrixDouble > hybrid_grad_disp, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv)
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
boost::shared_ptr< PressureBcVec > bcData
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
OpBrokenTractionBc(const std::string row_field, boost::shared_ptr< TractionBcVec > bc_data, boost::shared_ptr< double > piola_scale_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv)
boost::shared_ptr< double > piolaScalePtr
boost::shared_ptr< TractionBcVec > bcData
MoFEMErrorCode iNtegrate(EntData &data)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Operator for linear form, usually to calculate values on right hand side.
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
OpCalculateEshelbyStress(boost::shared_ptr< DataAtIntegrationPts > data_ptr)
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
std::array< double, 6 > & reactionVec
OpCalculateReactionForces(boost::shared_ptr< DataAtIntegrationPts > data_ptr, std::string block_name, Range block_entities, std::array< double, 6 > &reaction_vec)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
Operator for linear form, usually to calculate values on right hand side.
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
OpCalculateRotationAndSpatialGradient(boost::shared_ptr< DataAtIntegrationPts > data_ptr, double alpha_omega=0)
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
OpCalculateTractionFromSideEl(boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
OpDispBcImpl(boost::shared_ptr< std::vector< BrokenBaseSideData > > broken_base_side_data, boost::shared_ptr< BcDispVec > &bc_disp_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv, boost::shared_ptr< Range > ents_ptr=nullptr)
MoFEMErrorCode iNtegrate(EntData &data)
boost::shared_ptr< BcDispVec > bcDispPtr
MoFEMErrorCode iNtegrate(EntData &data)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
FaceElementForcesAndSourcesCore::UserDataOperator OP
OpFaceMaterialForce(boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
OpFaceSideMaterialForce(boost::shared_ptr< DataAtIntegrationPts > data_ptr)
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator OP
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
OpGetInternalStress(boost::shared_ptr< DataAtIntegrationPts > data_ptr, std::string tag_name="")
virtual MoFEMErrorCode evaluateLhs(EntData &data)=0
boost::shared_ptr< PhysicalEquations > physicsPtr
material physical equations
virtual MoFEMErrorCode evaluateRhs(EntData &data)=0
OpJacobian(const int tag, const bool eval_rhs, const bool eval_lhs, boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< PhysicalEquations > physics_ptr)
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
int tAg
adol-c tape
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
boost::shared_ptr< NormalDisplacementBcVec > bcDispPtr
OpNormalDispBcLhsImpl_dP(std::string row_field, boost::shared_ptr< std::vector< BrokenBaseSideData > > broken_base_side_data, boost::shared_ptr< NormalDisplacementBcVec > &bc_disp_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv, boost::shared_ptr< Range > ents_ptr=nullptr)
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
OpNormalDispBcLhsImpl_dU(std::string row_field, boost::shared_ptr< NormalDisplacementBcVec > &bc_disp_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv, boost::shared_ptr< Range > ents_ptr=nullptr)
boost::shared_ptr< NormalDisplacementBcVec > bcDispPtr
boost::shared_ptr< MatrixDouble > hybridDispPtr
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
MoFEMErrorCode iNtegrate(EntData &data)
boost::shared_ptr< NormalDisplacementBcVec > bcDispPtr
boost::shared_ptr< MatrixDouble > piolaStressPtr
OpNormalDispBcRhsImpl(std::string row_field, boost::shared_ptr< MatrixDouble > hybrid_disp_ptr, boost::shared_ptr< MatrixDouble > piola_stress_ptr, boost::shared_ptr< NormalDisplacementBcVec > &bc_disp_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv, boost::shared_ptr< Range > ents_ptr=nullptr)
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data)
MoFEMErrorCode iNtegrate(EntData &data)
std::vector< EntityHandle > & mapGaussPts
OpPostProcDataStructure(moab::Interface &post_proc_mesh, std::vector< EntityHandle > &map_gauss_pts, boost::shared_ptr< DataAtIntegrationPts > data_ptr, int sense)
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator OP
OpRotationBcImpl(boost::shared_ptr< std::vector< BrokenBaseSideData > > broken_base_side_data, boost::shared_ptr< BcRotVec > &bc_rot_ptr, std::map< std::string, boost::shared_ptr< ScalingMethod > > smv, boost::shared_ptr< Range > ents_ptr=nullptr)
MoFEMErrorCode iNtegrate(EntData &data)
std::map< std::string, boost::shared_ptr< ScalingMethod > > scalingMethodsMap
boost::shared_ptr< BcRotVec > bcRotPtr
Apply rotation boundary condition.
MoFEMErrorCode iNtegrate(EntData &data)
MoFEMErrorCode integrate(EntData &data)
OpSpatialConsistencyBubble(const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode integrate(EntData &data)
OpSpatialConsistencyDivTerm(const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode integrate(EntData &data)
OpSpatialConsistencyP(const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialConsistency_dBubble_dBubble(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode integrateImpl(EntData &row_data, EntData &col_data)
OpSpatialConsistency_dBubble_dP(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode integrateImpl(EntData &row_data, EntData &col_data)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialConsistency_dBubble_domega(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const bool assemble_off)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
MoFEMErrorCode integrateImpl(EntData &row_data, EntData &col_data)
OpSpatialConsistency_dP_dP(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialConsistency_dP_domega(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const bool assemble_off)
OpSpatialEquilibrium_dw_dP(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const bool assemble_off=false)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialEquilibrium_dw_dw(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const double alpha, const double rho)
MoFEMErrorCode integrate(EntData &data)
OpSpatialEquilibrium(const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const double alpha, const double rho)
MoFEMErrorCode integrate(EntData &row_data)
OpSpatialPhysicalInternalStress(const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
OpSpatialPhysical_du_dBubble(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const bool assemble_off=false)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialPhysical_du_dP(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const bool assemble_off=false)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialPhysical_du_domega(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const bool assemble_off)
OpSpatialPrj_dx_dw(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialPrj_dx_dx(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
OpSpatialPrj(std::string row_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr)
MoFEMErrorCode integrate(EntData &row_data)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialRotation_domega_dBubble(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const bool assemble_off)
OpSpatialRotation_domega_dP(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const bool assemble_off)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialRotation_domega_domega(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, double alpha_omega)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialRotation_domega_du(std::string row_field, std::string col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, double alpha_omega)
MoFEMErrorCode integrate(EntData &row_data, EntData &col_data)
OpSpatialRotation(const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr, double alpha_omega)
MoFEMErrorCode integrate(EntData &data)