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
183
184struct OpAssembleFace : public OpAssembleBasic<FaceUserDataOperator> {
185 using OpAssembleBasic<FaceUserDataOperator>::OpAssembleBasic;
186};
187
189 using OpAssembleVolume::OpAssembleVolume;
190 MoFEMErrorCode doWork(int side, EntityType type, EntData &data) {
192 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
193 "OpAssembleVolumePositiveDefine not implemented");
195 }
196
197 MoFEMErrorCode doWork(int row_side, int col_side, EntityType row_type,
198 EntityType col_type, EntData &row_data,
199 EntData &col_data) {
201 if (row_data.getIndices().empty())
203 if (col_data.getIndices().empty())
205 K.resize(row_data.getIndices().size(), col_data.getIndices().size(), false);
206 K.clear();
207 CHKERR integrate(row_data, col_data);
208
209 constexpr bool run_psd = true;
210
211 if (run_psd) {
212
213 auto symmetrize = [](MatrixDouble &mat) {
214 MatrixDouble r = (mat + trans(mat)) / 2.0;
215 return r;
216 };
217 auto check_positive_definite = [](MatrixDouble &mat) {
218 int n = mat.size1();
219 return (lapack_dpotrf('U', n, mat.data().data(), n) == 0);
220 };
221 auto frobenius_norm = [](MatrixDouble &mat) {
222 double sum = 0.0;
223 for (std::size_t i = 0; i < mat.size1(); ++i)
224 for (std::size_t j = 0; j < mat.size2(); ++j)
225 sum += mat(i, j) * mat(i, j);
226 return std::sqrt(sum);
227 };
228
229 auto higham_method_one_pass = [&](MatrixDouble &mat) {
230 int n = mat.size1();
231 const int lda = n;
232 const int size = (n + 2) * n;
233 int lwork = size;
234 double *work = new double[size];
235
236 VectorDouble eig(n, 0.0);
237 MatrixDouble eigen_vec = prod(trans(mat), mat);
238 if (lapack_dsyev('V', 'U', n, eigen_vec.data().data(), lda,
239 eig.data().data(), work, lwork) > 0)
241 "The algorithm failed to compute eigenvalues.");
242 delete[] work;
243
244 for (auto &e : eig) {
245 constexpr double eps = std::numeric_limits<double>::epsilon();
246 e = std::max(std::sqrt(std::abs(e)), eps);
247 }
248
249 auto diagonal_matrix =
250 ublas::diagonal_matrix<double, ublas::row_major,
251 VecAllocator<double>>(n, eig.data());
252 MatrixDouble symm_mat;
253 symm_mat = prod(trans(eigen_vec), diagonal_matrix);
254 symm_mat = prod(symm_mat, eigen_vec);
255
256 MatrixDouble hat_m = (mat + symm_mat) / 2.0;
257
258 return hat_m;
259 };
260
261 auto hat_k = higham_method_one_pass(K);
262 K.swap(hat_k);
263 }
264
265 CHKERR assemble(row_side, col_side, row_type, col_type, row_data, col_data);
267 }
268
269private:
270};
271
272// Add operator to calculate Eshelby tensor
273
275 : public ForcesAndSourcesCore::UserDataOperator {
276 OpCalculateEshelbyStress(boost::shared_ptr<DataAtIntegrationPts> data_ptr)
278 dataAtPts(data_ptr) {}
279 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
280
281private:
282 boost::shared_ptr<DataAtIntegrationPts>
283 dataAtPts; ///< data at integration pts
284};
285
287
289 boost::shared_ptr<DataAtIntegrationPts> data_ptr, double alpha_omega = 0)
291 alphaOmega(alpha_omega) {}
292 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
293
294private:
295 boost::shared_ptr<DataAtIntegrationPts>
296 dataAtPts; ///< data at integration pts
298};
299
302 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
303 : SideEleOp(NOSPACE, SideEleOp::OPSPACE), dataAtPts(data_ptr) {
304 std::fill(&doEntities[MBVERTEX], &doEntities[MBMAXTYPE], false);
305 for (auto t = moab::CN::TypeDimensionMap[SPACE_DIM].first;
306 t <= moab::CN::TypeDimensionMap[SPACE_DIM].second; ++t)
307 doEntities[t] = true;
308 sYmm = false;
309 }
310 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
311
312private:
313 boost::shared_ptr<DataAtIntegrationPts>
314 dataAtPts; ///< data at integration pts
315};
316
317struct OpCalculateReactionForces : public FaceUserDataOperator {
318 OpCalculateReactionForces(boost::shared_ptr<DataAtIntegrationPts> data_ptr,
319 std::string block_name, Range block_entities,
320 std::array<double, 6> &reaction_vec)
321 : FaceUserDataOperator(NOSPACE, OPSPACE), dataAtPts(data_ptr),
322 blockName(block_name), blockEntities(block_entities),
323 reactionVec(reaction_vec) {}
324 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
325
326private:
327 boost::shared_ptr<DataAtIntegrationPts>
328 dataAtPts; ///< data at integration pts
330 std::string blockName;
331 std::array<double, 6> &reactionVec;
332};
333
336 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
337 const double alpha, const double rho)
338 : OpAssembleVolume(field_name, data_ptr, OPROW), alphaW(alpha),
339 alphaRho(rho) {}
340 MoFEMErrorCode integrate(EntData &data);
341
342private:
343 const double alphaW;
344 const double alphaRho;
345
346};
347
349 OpSpatialRotation(const std::string &field_name,
350 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
351 double alpha_omega)
352 : OpAssembleVolume(field_name, data_ptr, OPROW), alphaOmega(alpha_omega) {
353 }
354 MoFEMErrorCode integrate(EntData &data);
355
356private:
358};
359
362 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
363 : OpAssembleVolume(field_name, data_ptr, OPROW) {}
364 MoFEMErrorCode integrate(EntData &data);
365
366private:
367};
368
371 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
372 : OpAssembleVolume(field_name, data_ptr, OPROW) {}
373 MoFEMErrorCode integrate(EntData &data);
374
375private:
376};
377
380 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
381 : OpAssembleVolume(field_name, data_ptr, OPROW) {}
382 MoFEMErrorCode integrate(EntData &data);
383};
384
385template <int INTERP_ORDER>
387 OpGetInternalStress(boost::shared_ptr<DataAtIntegrationPts> data_ptr,
388 std::string tag_name = "")
389 : UserDataOperator(H1, OPLAST), dataAtPts(data_ptr), tagName(tag_name) {
390 std::fill(&doEntities[MBVERTEX], &doEntities[MBMAXTYPE], false);
391 doEntities[MBVERTEX] = true;
392 }
393 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
394
395private:
396 boost::shared_ptr<DataAtIntegrationPts> dataAtPts;
397 std::string tagName;
398};
399
400template <bool VOIGT>
403 const std::string &field_name,
404 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
405 : OpAssembleVolume(field_name, data_ptr, OPROW) {}
406 MoFEMErrorCode integrate(EntData &row_data);
407};
408
409
410template <AssemblyType A, IntegrationType I> struct OpDispBcImpl;
411
412template <AssemblyType A>
413struct OpDispBcImpl<A, GAUSS>
414 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
415
416 using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
418
420 boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
421 boost::shared_ptr<BcDispVec> &bc_disp_ptr,
422 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
423 boost::shared_ptr<Range> ents_ptr = nullptr)
424 : OP(broken_base_side_data, ents_ptr), bcDispPtr(bc_disp_ptr),
425 scalingMethodsMap(smv) {}
426
427protected:
428 MoFEMErrorCode iNtegrate(EntData &data);
429 boost::shared_ptr<BcDispVec> bcDispPtr;
430 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
431};
432
433struct OpDispBc : public OpDispBcImpl<PETSC, GAUSS> {
435 using OP::OpDispBcImpl;
436
437protected:
438 MoFEMErrorCode iNtegrate(EntData &data);
439};
440
441template <AssemblyType A, IntegrationType I> struct OpRotationBcImpl;
442
443template <AssemblyType A>
444struct OpRotationBcImpl<A, GAUSS>
445 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
446
447 using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
449
451 boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
452 boost::shared_ptr<BcRotVec> &bc_rot_ptr,
453 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
454 boost::shared_ptr<Range> ents_ptr = nullptr)
455 : OP(broken_base_side_data, ents_ptr), bcRotPtr(bc_rot_ptr),
456 scalingMethodsMap(smv) {}
457
458protected:
459 MoFEMErrorCode iNtegrate(EntData &data);
460 boost::shared_ptr<BcRotVec> bcRotPtr;
461 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
462};
463
464/**
465 * @brief Apply rotation boundary condition
466 *
467 * The boundary condition is applied getting data from the SPATIAL_ROTATION_BC
468 * blockset.
469 *
470 * Centre of rotation is given by the first three attributes of the blockset.
471 * The fort parameter is angle of rotation
472 *
473 */
474struct OpRotationBc : public OpRotationBcImpl<PETSC, GAUSS> {
476 using OP::OpRotationBcImpl;
477
478protected:
479 MoFEMErrorCode iNtegrate(EntData &data);
480};
481
483 : public FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase {
485 const std::string row_field, boost::shared_ptr<TractionBcVec> bc_data,
486 boost::shared_ptr<double> piola_scale_ptr,
487 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv)
488 : FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase(
489 row_field, row_field, FaceUserDataOperator::OPROW),
490 bcData(bc_data), piolaScalePtr(), scalingMethodsMap(smv) {}
491
492 MoFEMErrorCode iNtegrate(EntData &data);
493
494protected:
495 boost::shared_ptr<TractionBcVec> bcData;
496 boost::shared_ptr<double> piolaScalePtr;
497 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
498};
499
501 : public FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase {
503 const std::string row_field, boost::shared_ptr<PressureBcVec> bc_data,
504 boost::shared_ptr<double> piola_scale_ptr,
505 boost::shared_ptr<MatrixDouble> hybrid_grad_disp,
506 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv)
507 : FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase(
508 row_field, row_field, FaceUserDataOperator::OPROW),
509 bcData(bc_data), piolaScalePtr(), hybridGradDispPtr(hybrid_grad_disp),
510 scalingMethodsMap(smv) {}
511
512 MoFEMErrorCode iNtegrate(EntData &data);
513
514protected:
515 boost::shared_ptr<PressureBcVec> bcData;
516 boost::shared_ptr<double> piolaScalePtr;
517 boost::shared_ptr<MatrixDouble> hybridGradDispPtr;
518 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
519};
520
521template <AssemblyType A, IntegrationType I> struct OpBrokenPressureBcLhsImpl_dU;
522
523template <AssemblyType A>
525 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBase {
526
527 using OP =
528 typename FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBase;
529
531 std::string row_field, boost::shared_ptr<PressureBcVec> bc_data,
532 boost::shared_ptr<MatrixDouble> hybrid_grad_disp,
533 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv)
534 : OP(row_field, row_field, OP::OPROWCOL), bcData(bc_data),
535 hybridGradDispPtr(hybrid_grad_disp), scalingMethodsMap(smv) {}
536
537protected:
538 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
539 boost::shared_ptr<PressureBcVec> bcData;
540 boost::shared_ptr<MatrixDouble> hybridGradDispPtr;
541 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
542};
543
547
548protected:
549 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
550};
551
553 : public FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase {
555 const std::string row_field, boost::shared_ptr<AnalyticalTractionBcVec> bc_data,
556 boost::shared_ptr<double> piola_scale_ptr,
557 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv)
558 : FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase(
559 row_field, row_field, FaceUserDataOperator::OPROW),
560 bcData(bc_data), piolaScalePtr(), scalingMethodsMap(smv) {}
561
562 MoFEMErrorCode iNtegrate(EntData &data);
563
564protected:
565 boost::shared_ptr<AnalyticalTractionBcVec> bcData;
566 boost::shared_ptr<double> piolaScalePtr;
567 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
568};
569
570template <AssemblyType A, IntegrationType I> struct OpNormalDispBcRhsImpl;
571template <AssemblyType A, IntegrationType I> struct OpNormalDispBcLhsImpl_dU;
572template <AssemblyType A, IntegrationType I> struct OpNormalDispBcLhsImpl_dP;
573
574template <AssemblyType A>
576 : public FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase {
577
578 using OP =
579 typename FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase;
580
582 std::string row_field, boost::shared_ptr<MatrixDouble> hybrid_disp_ptr,
583 boost::shared_ptr<MatrixDouble> piola_stress_ptr,
584 boost::shared_ptr<NormalDisplacementBcVec> &bc_disp_ptr,
585 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
586 boost::shared_ptr<Range> ents_ptr = nullptr)
587 : FormsIntegrators<FaceUserDataOperator>::Assembly<PETSC>::OpBase(
588 row_field, row_field, OP::OPROW),
589 hybridDispPtr(hybrid_disp_ptr), piolaStressPtr(piola_stress_ptr),
590 bcDispPtr(bc_disp_ptr), scalingMethodsMap(smv) {}
591
592protected:
593 MoFEMErrorCode iNtegrate(EntData &data);
594 boost::shared_ptr<MatrixDouble> hybridDispPtr;
595 boost::shared_ptr<MatrixDouble> piolaStressPtr;
596 boost::shared_ptr<NormalDisplacementBcVec> bcDispPtr;
597 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
598};
599
600template <AssemblyType A>
602 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBase {
603
604 using OP =
605 typename FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBase;
606
608 std::string row_field,
609 boost::shared_ptr<NormalDisplacementBcVec> &bc_disp_ptr,
610 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
611 boost::shared_ptr<Range> ents_ptr = nullptr)
612 : OP(row_field, row_field, OP::OPROWCOL), bcDispPtr(bc_disp_ptr),
613 scalingMethodsMap(smv) {}
614
615protected:
616 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
617 boost::shared_ptr<NormalDisplacementBcVec> bcDispPtr;
618 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
619};
620
621template <AssemblyType A>
623 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
624
625 using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
627
629 std::string row_field,
630 boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
631 boost::shared_ptr<NormalDisplacementBcVec> &bc_disp_ptr,
632 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
633 boost::shared_ptr<Range> ents_ptr = nullptr)
634 : OP(row_field, broken_base_side_data, false, false, ents_ptr),
635 bcDispPtr(bc_disp_ptr), scalingMethodsMap(smv) {}
636
637protected:
638 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
639 boost::shared_ptr<NormalDisplacementBcVec> bcDispPtr;
640 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
641};
642
643struct OpNormalDispRhsBc : public OpNormalDispBcRhsImpl<PETSC, GAUSS> {
645 using OP::OpNormalDispBcRhsImpl;
646
647protected:
648 MoFEMErrorCode iNtegrate(EntData &data);
649};
650
654
655protected:
656 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
657};
658
662
663protected:
664 MoFEMErrorCode iNtegrate(EntData &row_data, EntData &col_data);
665};
666
667template <AssemblyType A, IntegrationType I> struct OpAnalyticalDispBcImpl;
668
669template <AssemblyType A>
671 : public FormsIntegrators<FaceUserDataOperator>::Assembly<A>::OpBrokenBase {
672
673 using OP = typename FormsIntegrators<FaceUserDataOperator>::Assembly<
675
677 boost::shared_ptr<std::vector<BrokenBaseSideData>> broken_base_side_data,
678 boost::shared_ptr<AnalyticalDisplacementBcVec> &bc_disp_ptr,
679 std::map<std::string, boost::shared_ptr<ScalingMethod>> smv,
680 boost::shared_ptr<Range> ents_ptr = nullptr)
681 : OP(broken_base_side_data, ents_ptr), bcDispPtr(bc_disp_ptr),
682 scalingMethodsMap(smv) {}
683
684protected:
685 MoFEMErrorCode iNtegrate(EntData &data);
686 boost::shared_ptr<AnalyticalDisplacementBcVec> bcDispPtr;
687 std::map<std::string, boost::shared_ptr<ScalingMethod>> scalingMethodsMap;
688};
689
690struct OpAnalyticalDispBc : public OpAnalyticalDispBcImpl<PETSC, GAUSS> {
692 using OP::OpAnalyticalDispBcImpl;
693
694protected:
695 MoFEMErrorCode iNtegrate(EntData &data);
696};
697
699 OpSpatialEquilibrium_dw_dP(std::string row_field, std::string col_field,
700 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
701 const bool assemble_off = false)
702 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
703 assemble_off) {
704 sYmm = false;
705 }
706 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
707};
708
710 const double alphaW;
711 const double alphaRho;
712 OpSpatialEquilibrium_dw_dw(std::string row_field, std::string col_field,
713 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
714 const double alpha, const double rho)
715 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false),
716 alphaW(alpha), alphaRho(rho) {
717 sYmm = true;
718 }
719 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
720};
721
723 OpSpatialPhysical_du_dP(std::string row_field, std::string col_field,
724 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
725 const bool assemble_off = false)
726 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
727 assemble_off) {
728 sYmm = false;
729 }
730
731 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
732};
733
735 OpSpatialPhysical_du_dBubble(std::string row_field, std::string col_field,
736 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
737 const bool assemble_off = false)
738 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
739 assemble_off) {
740 sYmm = false;
741 }
742
743 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
744};
745
747 using OpAssembleVolume::OpAssembleVolume;
748 OpSpatialPhysical_du_domega(std::string row_field, std::string col_field,
749 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
750 const bool assemble_off)
751 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
752 assemble_off) {
753 sYmm = false;
754 }
755 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
756};
757
759 OpSpatialRotation_domega_du(std::string row_field, std::string col_field,
760 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
761 double alpha_omega)
762 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
763 sYmm = false;
764 }
765 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
766private:
767};
768
770 OpSpatialRotation_domega_dP(std::string row_field, std::string col_field,
771 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
772 const bool assemble_off)
773 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
774 assemble_off) {
775 sYmm = false;
776 }
777 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
778};
779
782 std::string row_field, std::string col_field,
783 boost::shared_ptr<DataAtIntegrationPts> data_ptr, const bool assemble_off)
784 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
785 assemble_off) {
786 sYmm = false;
787 }
788 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
789};
790
791
794 std::string row_field, std::string col_field,
795 boost::shared_ptr<DataAtIntegrationPts> data_ptr, double alpha_omega)
796 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false),
797 alphaOmega(alpha_omega) {
798 sYmm = false;
799 }
800 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
801
802private:
804};
805
807 OpSpatialConsistency_dP_dP(std::string row_field, std::string col_field,
808 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
809 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
810 sYmm = false;
811 }
812 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
813
814private:
815 template <int S>
816 MoFEMErrorCode integrateImpl(EntData &row_data, EntData &col_data);
817};
818
821 std::string row_field, std::string col_field,
822 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
823 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
824 sYmm = false;
825 }
826 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
827
828private:
829 template <int S>
830 MoFEMErrorCode integrateImpl(EntData &row_data, EntData &col_data);
831};
832
835 std::string row_field, std::string col_field,
836 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
837 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, true) {
838 sYmm = false;
839 }
840 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
841
842private:
843 template <int S>
844 MoFEMErrorCode integrateImpl(EntData &row_data, EntData &col_data);
845};
846
849 std::string row_field, std::string col_field,
850 boost::shared_ptr<DataAtIntegrationPts> data_ptr, const bool assemble_off)
851 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
852 assemble_off) {
853 sYmm = false;
854 }
855 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
856
857private:
858};
859
862 std::string row_field, std::string col_field,
863 boost::shared_ptr<DataAtIntegrationPts> data_ptr, const bool assemble_off)
864 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL,
865 assemble_off) {
866 sYmm = false;
867 }
868 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
869
870private:
871};
872
874 : public VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator {
875
876 using OP = VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator;
877
878 moab::Interface &postProcMesh;
879 std::vector<EntityHandle> &mapGaussPts;
880 boost::shared_ptr<DataAtIntegrationPts> dataAtPts;
881
882 OpPostProcDataStructure(moab::Interface &post_proc_mesh,
883 std::vector<EntityHandle> &map_gauss_pts,
884 boost::shared_ptr<DataAtIntegrationPts> data_ptr,
885 int sense)
886 : OP(NOSPACE, UserDataOperator::OPSPACE), postProcMesh(post_proc_mesh),
887 mapGaussPts(map_gauss_pts), dataAtPts(data_ptr), tagSense(sense) {}
888
889 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
890
891private:
893};
894
896 OpSpatialPrj(std::string row_field,
897 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
898 : OpAssembleVolume(row_field, data_ptr, OPROW) {}
899 MoFEMErrorCode integrate(EntData &row_data);
900};
901
903 OpSpatialPrj_dx_dx(std::string row_field, std::string col_field,
904 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
905 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
906 // FIXME: That is symmetric
907 sYmm = false;
908 }
909 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
910};
911
913 OpSpatialPrj_dx_dw(std::string row_field, std::string col_field,
914 boost::shared_ptr<DataAtIntegrationPts> data_ptr)
915 : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false) {
916 sYmm = false;
917 }
918 MoFEMErrorCode integrate(EntData &row_data, EntData &col_data);
919};
920
922 : public VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator {
923
924 // @note This is not on the side, since, integrate energy in the volume
925 using OP = VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator;
926
927 OpFaceSideMaterialForce(boost::shared_ptr<DataAtIntegrationPts> data_ptr)
928 : OP(NOSPACE, OPSPACE), dataAtPts(data_ptr) {}
929
930 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
931
932private:
933 boost::shared_ptr<DataAtIntegrationPts>
934 dataAtPts; ///< data at integration pts
935};
936
938 : public FaceElementForcesAndSourcesCore::UserDataOperator {
939
940 // @note This is not on the side, since, integrate energy in the volume
941 using OP = FaceElementForcesAndSourcesCore::UserDataOperator;
942
943 OpFaceMaterialForce(boost::shared_ptr<DataAtIntegrationPts> data_ptr)
944 : OP(NOSPACE, OPSPACE), dataAtPts(data_ptr) {}
945
946 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
947
948private:
949 boost::shared_ptr<DataAtIntegrationPts>
950 dataAtPts; ///< data at integration pts
951};
952
953template <int FE_DIM, int PROBLEM_DIM, int SPACE_DIM> struct AddHOOps;
954
955template <> struct AddHOOps<2, 3, 3> {
956 AddHOOps() = delete;
957 static MoFEMErrorCode
958 add(boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
959 std::vector<FieldSpace> space, std::string geom_field_name,
960 boost::shared_ptr<Range> crack_front_edges_ptr);
961};
962
963template <> struct AddHOOps<2, 2, 3> {
964 AddHOOps() = delete;
965 static MoFEMErrorCode
966 add(boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
967 std::vector<FieldSpace> space, std::string geom_field_name,
968 boost::shared_ptr<Range> crack_front_edges_ptr);
969};
970
971template <> struct AddHOOps<3, 3, 3> {
972 AddHOOps() = delete;
973 static MoFEMErrorCode
974 add(boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
975 std::vector<FieldSpace> space, std::string geom_field_name,
976 boost::shared_ptr<Range> crack_front_edges_ptr,
977 boost::shared_ptr<MatrixDouble> jac = nullptr,
978 boost::shared_ptr<VectorDouble> det = nullptr,
979 boost::shared_ptr<MatrixDouble> inv_jac = nullptr);
980};
981
982/**
983 * @brief Zeroes the DOFs which aro not at side for broken base field
984 */
986 using OP = SideEleOp;
988 MoFEMErrorCode doWork(int side, EntityType type, EntData &data);
989};
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
constexpr AssemblyType A
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, boost::shared_ptr< MatrixDouble > jac=nullptr, boost::shared_ptr< VectorDouble > det=nullptr, boost::shared_ptr< MatrixDouble > inv_jac=nullptr)
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 degrees of freedom 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.
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)
Caluclate face material force and normal pressure at gauss points.
OpFaceSideMaterialForce(boost::shared_ptr< DataAtIntegrationPts > data_ptr)
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
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)
Zeroes the DOFs which aro not at side for broken base field.
OpZeroNoSideBrokenDofs(std::string field_name)
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
EleOnSide::UserDataOperator SideEleOp