23#ifndef EXECUTABLE_DIMENSION
24 #define EXECUTABLE_DIMENSION 2
49 GAUSS>::OpGradSymTensorGrad<1, SPACE_DIM, SPACE_DIM, 0>;
63 GAUSS>::OpGradTensorGrad<1, SPACE_DIM, SPACE_DIM, 1>;
94 GAUSS>::OpMixDivTimesScalar<SPACE_DIM>;
108 GAUSS>::OpBaseTimesVector<3, 3, 1>;
115 GAUSS>::OpMixDivTimesU<3, 1, 2>;
123 GAUSS>::OpBaseTimesScalarField<1>;
153 GAUSS>::OpEssentialRhs<HeatFluxCubitBcData, 3, SPACE_DIM>;
156 GAUSS>::OpEssentialLhs<HeatFluxCubitBcData, 3, SPACE_DIM>;
169auto save_range = [](moab::Interface &moab,
const std::string name,
173 CHKERR moab.add_entities(*out_meshset, r);
174 CHKERR moab.write_file(name.c_str(),
"VTK",
"", out_meshset->get_ptr(), 1);
201 :
public boost::enable_shared_from_this<BlockedParameters> {
206 return boost::shared_ptr<MatrixDouble>(shared_from_this(), &
mD);
215 boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
216 std::string block_elastic_name, std::string block_thermal_name,
217 boost::shared_ptr<BlockedParameters> blockedParamsPtr,
Sev sev);
221 boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
222 std::string block_elastic_name, std::string block_thermal_name,
223 boost::shared_ptr<BlockedParameters> blockedParamsPtr,
Sev sev) {
227 OpMatElasticBlocks(boost::shared_ptr<MatrixDouble>
m,
double bulk_modulus_K,
230 std::vector<const CubitMeshSets *> meshset_vec_ptr)
235 "Can not get data from block");
242 for (
auto &b : blockData) {
244 if (b.blockEnts.find(getFEEntityHandle()) != b.blockEnts.end()) {
245 CHKERR getMatDPtr(matDPtr, b.bulkModulusK, b.shearModulusG);
250 CHKERR getMatDPtr(matDPtr, bulkModulusKDefault, shearModulusGDefault);
255 boost::shared_ptr<MatrixDouble> matDPtr;
259 double shearModulusG;
263 double bulkModulusKDefault;
264 double shearModulusGDefault;
265 std::vector<BlockData> blockData;
269 std::vector<const CubitMeshSets *> meshset_vec_ptr,
273 for (
auto m : meshset_vec_ptr) {
275 std::vector<double> block_data;
276 CHKERR m->getAttributes(block_data);
277 if (block_data.size() < 2) {
279 "Expected that block has two attributes");
281 auto get_block_ents = [&]() {
284 m_field.
get_moab().get_entities_by_handle(
m->meshset, ents,
true);
304 MoFEMErrorCode getMatDPtr(boost::shared_ptr<MatrixDouble> mat_D_ptr,
308 auto set_material_stiffness = [&]() {
327 set_material_stiffness();
332 double default_bulk_modulus_K =
334 double default_shear_modulus_G =
337 pipeline.push_back(
new OpMatElasticBlocks(
338 blockedParamsPtr->getDPtr(), default_bulk_modulus_K,
339 default_shear_modulus_G,
mField, sev,
344 (boost::format(
"%s(.*)") % block_elastic_name).str()
351 OpMatFluidBlocks(boost::shared_ptr<double> conductivity_ptr,
353 std::vector<const CubitMeshSets *> meshset_vec_ptr)
355 conductivityPtr(conductivity_ptr) {
357 "Can not get data from block");
364 for (
auto &b : blockData) {
366 if (b.blockEnts.find(getFEEntityHandle()) != b.blockEnts.end()) {
367 *conductivityPtr = b.conductivity;
383 std::vector<BlockData> blockData;
387 std::vector<const CubitMeshSets *> meshset_vec_ptr,
391 for (
auto m : meshset_vec_ptr) {
393 std::vector<double> block_data;
394 CHKERR m->getAttributes(block_data);
395 if (block_data.size() < 1) {
397 "Expected that block has two attributes");
399 auto get_block_ents = [&]() {
402 m_field.
get_moab().get_entities_by_handle(
m->meshset, ents,
true);
407 <<
m->getName() <<
": conductivity = " << block_data[0];
409 blockData.push_back({block_data[0], get_block_ents()});
415 boost::shared_ptr<double> expansionPtr;
416 boost::shared_ptr<double> conductivityPtr;
417 boost::shared_ptr<double> capacityPtr;
420 pipeline.push_back(
new OpMatFluidBlocks(
421 blockedParamsPtr->getConductivityPtr(),
mField, sev,
426 (boost::format(
"%s(.*)") % block_thermal_name).str()
478 auto get_command_line_parameters = [&]() {
505 CHKERR get_command_line_parameters();
522 simple->getProblemName(),
"U");
524 simple->getProblemName(),
"FLUX",
false);
526 auto get_skin = [&]() {
531 CHKERR skin.find_skin(0, body_ents,
false, skin_ents);
535 auto filter_flux_blocks = [&](
auto skin) {
536 auto remove_cubit_blocks = [&](
auto c) {
546 skin = subtract(skin, ents);
551 auto remove_named_blocks = [&](
auto n) {
556 (boost::format(
"%s(.*)") %
n).str()
564 skin = subtract(skin, ents);
570 "remove_cubit_blocks");
572 "remove_cubit_blocks");
581 ParallelComm *pcomm =
583 CHKERR pcomm->filter_pstatus(skin, PSTATUS_SHARED | PSTATUS_MULTISHARED,
584 PSTATUS_NOT, -1, &boundary_ents);
585 return boundary_ents;
593 MOFEM_LOG(
"SYNC", Sev::noisy) << remove_flux_ents << endl;
606 simple->getProblemName(),
"FLUX", remove_flux_ents);
619 auto boundary_marker =
620 bc_mng->getMergedBlocksMarker(vector<string>{
"FLUIDFLUX"});
622 auto u_grad_ptr = boost::make_shared<MatrixDouble>();
623 auto dot_u_grad_ptr = boost::make_shared<MatrixDouble>();
624 auto trace_dot_u_grad_ptr = boost::make_shared<VectorDouble>();
625 auto h_ptr = boost::make_shared<VectorDouble>();
626 auto dot_h_ptr = boost::make_shared<VectorDouble>();
627 auto flux_ptr = boost::make_shared<MatrixDouble>();
628 auto div_flux_ptr = boost::make_shared<VectorDouble>();
629 auto strain_ptr = boost::make_shared<MatrixDouble>();
630 auto stress_ptr = boost::make_shared<MatrixDouble>();
632 auto time_scale = boost::make_shared<TimeScale>();
634 auto block_params = boost::make_shared<BlockedParameters>();
635 auto mDPtr = block_params->getDPtr();
636 auto conductivity_ptr = block_params->getConductivityPtr();
647 auto add_domain_base_ops = [&](
auto &pip) {
658 "U", dot_u_grad_ptr));
660 trace_dot_u_grad_ptr));
666 "FLUX", div_flux_ptr));
671 auto add_domain_ops_lhs_mechanical = [&](
auto &pip) {
673 pip.push_back(
new OpKCauchy(
"U",
"U", mDPtr));
676 [](
const double,
const double,
const double) {
return -9.81; },
true,
681 auto add_domain_ops_rhs_mechanical = [&](
auto &pip) {
685 pip,
mField,
"U", {time_scale},
"BODY_FORCE", Sev::inform);
689 strain_ptr, stress_ptr, mDPtr));
697 auto add_domain_ops_lhs_seepage = [&](
auto &pip,
auto &fe) {
699 auto resistance = [conductivity_ptr](
const double,
const double,
701 return (1. / *(conductivity_ptr));
704 auto unity = []()
constexpr {
return -1; };
705 pip.push_back(
new OpHdivHdiv(
"FLUX",
"FLUX", resistance));
706 pip.push_back(
new OpHdivQ(
"FLUX",
"H", unity,
true));
708 "H",
"U", [](
double,
double,
double)
constexpr {
return -1; },
false,
710 op_base_div_u->feScalingFun = [](
const FEMethod *fe_ptr) {
713 pip.push_back(op_base_div_u);
718 auto add_domain_ops_rhs_seepage = [&](
auto &pip) {
721 return (1. / (*conductivity_ptr));
725 pip.push_back(
new OpHdivFlux(
"FLUX", flux_ptr, resistance));
726 pip.push_back(
new OpHDivH(
"FLUX", h_ptr, minus_one));
727 pip.push_back(
new OpBaseDotH(
"H", trace_dot_u_grad_ptr, minus_one));
728 pip.push_back(
new OpBaseDivFlux(
"H", div_flux_ptr, minus_one));
733 auto add_boundary_rhs_ops = [&](
auto &pip) {
738 pip.push_back(
new OpSetBc(
"FLUX",
true, boundary_marker));
741 pipeline_mng->getOpBoundaryRhsPipeline(),
mField,
"U", {time_scale},
742 "FORCE", Sev::inform);
745 pipeline_mng->getOpBoundaryRhsPipeline(),
mField,
"FLUX", {time_scale},
746 "PRESSURE", Sev::inform);
750 auto mat_flux_ptr = boost::make_shared<MatrixDouble>();
755 mField, pip,
simple->getProblemName(),
"FLUX", mat_flux_ptr,
761 auto add_boundary_lhs_ops = [&](
auto &pip) {
774 CHKERR add_domain_base_ops(pipeline_mng->getOpDomainLhsPipeline());
775 CHKERR add_domain_ops_lhs_mechanical(pipeline_mng->getOpDomainLhsPipeline());
776 CHKERR add_domain_ops_lhs_seepage(pipeline_mng->getOpDomainLhsPipeline(),
777 pipeline_mng->getDomainLhsFE());
780 CHKERR add_domain_base_ops(pipeline_mng->getOpDomainRhsPipeline());
781 CHKERR add_domain_ops_rhs_mechanical(pipeline_mng->getOpDomainRhsPipeline());
782 CHKERR add_domain_ops_rhs_seepage(pipeline_mng->getOpDomainRhsPipeline());
784 CHKERR add_boundary_rhs_ops(pipeline_mng->getOpBoundaryRhsPipeline());
785 CHKERR add_boundary_lhs_ops(pipeline_mng->getOpBoundaryLhsPipeline());
797 auto dm =
simple->getDM();
801 auto set_section_monitor = [&](
auto solver) {
804 CHKERR TSGetSNES(solver, &snes);
805 CHKERR SNESMonitorSet(snes,
808 (
void *)(snes_ctx_ptr.get()),
nullptr);
812 auto create_post_process_element = [&]() {
813 auto post_proc_fe = boost::make_shared<PostProcEle>(
mField);
815 auto block_params = boost::make_shared<BlockedParameters>();
816 auto mDPtr = block_params->getDPtr();
818 "MAT_FLUID", block_params, Sev::verbose);
820 post_proc_fe->getOpPtrVector(), {H1, HDIV});
822 auto mat_grad_ptr = boost::make_shared<MatrixDouble>();
823 auto mat_strain_ptr = boost::make_shared<MatrixDouble>();
824 auto mat_stress_ptr = boost::make_shared<MatrixDouble>();
826 auto h_ptr = boost::make_shared<VectorDouble>();
827 auto mat_flux_ptr = boost::make_shared<MatrixDouble>();
829 post_proc_fe->getOpPtrVector().push_back(
831 post_proc_fe->getOpPtrVector().push_back(
834 auto u_ptr = boost::make_shared<MatrixDouble>();
835 post_proc_fe->getOpPtrVector().push_back(
837 post_proc_fe->getOpPtrVector().push_back(
840 post_proc_fe->getOpPtrVector().push_back(
842 post_proc_fe->getOpPtrVector().push_back(
844 mat_strain_ptr, mat_stress_ptr, mDPtr));
848 post_proc_fe->getOpPtrVector().push_back(
852 post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
856 {{
"U", u_ptr}, {
"FLUX", mat_flux_ptr}},
860 {{
"STRAIN", mat_strain_ptr}, {
"STRESS", mat_stress_ptr}}
869 auto create_creaction_fe = [&]() {
870 auto fe_ptr = boost::make_shared<DomainEle>(mField);
871 fe_ptr->getRuleHook = [](int, int,
int o) {
return 2 * o; };
873 auto &pip = fe_ptr->getOpPtrVector();
875 auto block_params = boost::make_shared<BlockedParameters>();
876 auto mDPtr = block_params->getDPtr();
881 auto u_grad_ptr = boost::make_shared<MatrixDouble>();
882 auto strain_ptr = boost::make_shared<MatrixDouble>();
883 auto stress_ptr = boost::make_shared<MatrixDouble>();
891 strain_ptr, stress_ptr, mDPtr));
894 fe_ptr->postProcessHook =
900 auto monitor_ptr = boost::make_shared<FEMethod>();
901 auto post_proc_fe = create_post_process_element();
903 auto rections_fe = create_creaction_fe();
905 auto set_time_monitor = [&](
auto dm,
auto solver) {
907 monitor_ptr->preProcessHook = [&]() {
912 monitor_ptr->getCacheWeakPtr());
913 CHKERR post_proc_fe->writeFile(
914 "out_" + boost::lexical_cast<std::string>(monitor_ptr->ts_step) +
917 rections_fe->f = res;
920 monitor_ptr->getCacheWeakPtr());
922 CHKERR VecAssemblyBegin(res);
923 CHKERR VecAssemblyEnd(res);
925 CHKERR VecNorm(res, NORM_2, &nrm);
927 <<
"Residual norm " << nrm <<
" at time step "
928 << monitor_ptr->ts_step;
932 auto scalar_field_ptr = boost::make_shared<VectorDouble>();
933 auto vector_field_ptr = boost::make_shared<MatrixDouble>();
934 auto tensor_field_ptr = boost::make_shared<MatrixDouble>();
937 ->getData<DomainEle>();
940 ->buildTree<SPACE_DIM>(field_eval_data,
simple->getDomainFEName());
942 field_eval_data->setEvalPoints(fieldEvalCoords.data(), 1);
943 auto no_rule = [](int, int, int) {
return -1; };
945 auto field_eval_ptr = field_eval_data->feMethodPtr.lock();
946 field_eval_ptr->getRuleHook = no_rule;
948 auto u_grad_ptr = boost::make_shared<MatrixDouble>();
949 auto strain_ptr = boost::make_shared<MatrixDouble>();
950 auto stress_ptr = boost::make_shared<MatrixDouble>();
951 auto h_ptr = boost::make_shared<VectorDouble>();
953 auto block_params = boost::make_shared<BlockedParameters>();
954 auto mDPtr = block_params->getDPtr();
956 "MAT_FLUID", block_params, Sev::noisy);
958 field_eval_ptr->getOpPtrVector(), {H1, HDIV});
959 field_eval_ptr->getOpPtrVector().push_back(
962 field_eval_ptr->getOpPtrVector().push_back(
964 field_eval_ptr->getOpPtrVector().push_back(
966 field_eval_ptr->getOpPtrVector().push_back(
968 strain_ptr, stress_ptr, mDPtr));
971 ->evalFEAtThePoint<SPACE_DIM>(
972 fieldEvalCoords.data(), 1e-12,
simple->getProblemName(),
973 simple->getDomainFEName(), field_eval_data,
974 mField.get_comm_rank(), mField.get_comm_rank(),
nullptr,
978 <<
"Eval point hydrostatic hight: " << *h_ptr;
980 <<
"Eval point skeleton stress pressure: " << *stress_ptr;
986 auto null = boost::shared_ptr<FEMethod>();
992 auto set_fieldsplit_preconditioner = [&](
auto solver) {
996 CHKERR TSGetSNES(solver, &snes);
998 CHKERR SNESGetKSP(snes, &ksp);
1000 CHKERR KSPGetPC(ksp, &pc);
1001 PetscBool is_pcfs = PETSC_FALSE;
1002 PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
1005 if (is_pcfs == PETSC_TRUE) {
1006 auto bc_mng = mField.getInterface<
BcManager>();
1008 auto name_prb =
simple->getProblemName();
1011 CHKERR is_mng->isCreateProblemFieldAndRank(name_prb,
ROW,
"U", 0,
1014 CHKERR is_mng->isCreateProblemFieldAndRank(name_prb,
ROW,
"FLUX", 0, 0,
1017 CHKERR is_mng->isCreateProblemFieldAndRank(name_prb,
ROW,
"H", 0, 0,
1020 CHKERR ISExpand(is_H, is_flux, &is_tmp);
1023 auto is_all_bc = bc_mng->getBlockIS(name_prb,
"FLUIDFLUX",
"FLUX", 0, 0);
1025 CHKERR ISGetSize(is_all_bc, &is_all_bc_size);
1027 <<
"Field split block size " << is_all_bc_size;
1028 if (is_all_bc_size) {
1030 CHKERR ISDifference(is_Flux, is_all_bc, &is_tmp2);
1032 CHKERR PCFieldSplitSetIS(pc, PETSC_NULLPTR,
1038 CHKERR PCFieldSplitSetIS(pc, PETSC_NULLPTR, is_Flux);
1039 CHKERR PCFieldSplitSetIS(pc, PETSC_NULLPTR, is_u);
1045 auto pre_proc_ptr = boost::make_shared<FEMethod>();
1046 auto post_proc_rhs_ptr = boost::make_shared<FEMethod>();
1047 auto post_proc_lhs_ptr = boost::make_shared<FEMethod>();
1048 auto time_scale = boost::make_shared<TimeScale>();
1050 auto get_bc_hook_rhs = [
this, pre_proc_ptr, time_scale]() {
1052 {time_scale},
false);
1056 auto get_post_proc_hook_rhs = [
this, post_proc_rhs_ptr]() {
1059 mField, post_proc_rhs_ptr,
nullptr, Sev::verbose)();
1061 mField, post_proc_rhs_ptr, 1.)();
1064 auto get_post_proc_hook_lhs = [
this, post_proc_lhs_ptr]() {
1066 post_proc_lhs_ptr, 1.);
1069 pre_proc_ptr->preProcessHook = get_bc_hook_rhs();
1070 post_proc_rhs_ptr->postProcessHook = get_post_proc_hook_rhs;
1071 post_proc_lhs_ptr->postProcessHook = get_post_proc_hook_lhs();
1074 ts_ctx_ptr->getPreProcessIFunction().push_front(pre_proc_ptr);
1075 ts_ctx_ptr->getPreProcessIJacobian().push_front(pre_proc_ptr);
1076 ts_ctx_ptr->getPostProcessIFunction().push_back(post_proc_rhs_ptr);
1077 ts_ctx_ptr->getPostProcessIJacobian().push_back(post_proc_lhs_ptr);
1080 CHKERR TSSetIJacobian(solver,
B,
B, PETSC_NULLPTR, PETSC_NULLPTR);
1082 CHKERR TSSetSolution(solver,
D);
1083 CHKERR TSSetFromOptions(solver);
1085 CHKERR set_section_monitor(solver);
1086 CHKERR set_fieldsplit_preconditioner(solver);
1087 CHKERR set_time_monitor(dm, solver);
1090 CHKERR TSSolve(solver, NULL);
1101 const char param_file[] =
"param_file.petsc";
1105 auto core_log = logging::core::get();
1118 DMType dm_name =
"DMMOFEM";
1123 moab::Core mb_instance;
1124 moab::Interface &moab = mb_instance;
static auto filter_true_skin(MoFEM::Interface &m_field, Range &&skin)
#define MOFEM_LOG_SEVERITY_SYNC(comm, severity)
Synchronise "SYNC" on curtain severity level.
#define MOFEM_TAG_AND_LOG(channel, severity, tag)
Tag and log in channel.
void simple(double P1[], double P2[], double P3[], double c[], const int N)
DomainEle::UserDataOperator DomainEleOp
Finire element operator type.
ElementsAndOps< SPACE_DIM >::BoundaryEle BoundaryEle
ElementsAndOps< SPACE_DIM >::DomainEle DomainEle
[Define dimension]
Kronecker Delta class symmetric.
#define CATCH_ERRORS
Catch errors.
FieldApproximationBase
approximation base
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base nme:nme847.
#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()
@ L2
field with C-1 continuity
@ HCURL
field with continuous tangents
@ HDIV
field with continuous normal traction
#define MYPCOMM_INDEX
default communicator number PCOMM
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
@ MOFEM_DATA_INCONSISTENCY
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
FormsIntegrators< DomainEleOp >::Assembly< A >::BiLinearForm< I >::OpMixScalarTimesDiv< SPACE_DIM, COORD_TYPE > OpMixScalarTimesDiv
PetscErrorCode DMRegister_MoFEM(const char sname[])
Register MoFEM problem.
PetscErrorCode DMoFEMLoopFiniteElements(DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
Executes FEMethod for finite elements in DM.
auto createDMVector(DM dm)
Get smart vector from DM.
auto createDMMatrix(DM dm)
Get smart matrix from DM.
SmartPetscObj< TS > createTSIM(SmartPetscObj< DM > dm=nullptr)
Create TS (time) implicit solver.
static LoggerType & setLog(const std::string channel)
Set ans resset chanel logger.
#define MOFEM_LOG(channel, severity)
Log.
SeverityLevel
Severity levels.
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
MoFEMErrorCode getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
get cubit meshset
FTensor::Index< 'i', SPACE_DIM > i
const double c
speed of light (cm/ns)
const double n
refractive index of diffusive medium
FTensor::Index< 'l', 3 > l
FTensor::Index< 'j', 3 > j
FTensor::Index< 'k', 3 > k
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
implementation of Data Operators for Forces and Sources
PetscErrorCode DMMoFEMTSSetMonitor(DM dm, TS ts, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
Set Monitor To TS solver.
auto getDMTsCtx(DM dm)
Get TS context data structure used by DM.
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
MoFEMErrorCode MoFEMSNESMonitorFields(SNES snes, PetscInt its, PetscReal fgnorm, SnesCtx *ctx)
Sens monitor printing residual field by field.
PetscErrorCode PetscOptionsGetScalar(PetscOptions *, const char pre[], const char name[], PetscScalar *dval, PetscBool *set)
PetscErrorCode PetscOptionsGetRealArray(PetscOptions *, const char pre[], const char name[], PetscReal dval[], PetscInt *nmax, PetscBool *set)
static FTensor::Ddg< FTensor::PackPtr< T *, 1 >, Tensor_Dim01, Tensor_Dim23 > getFTensor4DdgFromMat(ublas::matrix< T, L, A > &data)
Get symmetric tensor rank 4 on first two and last indices from form data matrix.
auto get_temp_meshset_ptr(moab::Interface &moab)
Create smart pointer to temporary meshset.
OpCalculateScalarFieldValuesFromPetscVecImpl< PetscData::CTX_SET_X_T > OpCalculateScalarFieldValuesDot
auto getDMSnesCtx(DM dm)
Get SNES context data structure used by DM.
MoFEMErrorCode addMatBlockOps(MoFEM::Interface &m_field, std::string block_name, Pip &pip, boost::shared_ptr< MatrixDouble > mat_D_Ptr, boost::shared_ptr< CommonData::BlockParams > mat_params_ptr, double scale_value, Sev sev)
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
double young_modulus
Young modulus.
double poisson_ratio
Poisson ratio.
static constexpr int approx_order
OpBaseImpl< PETSC, EdgeEleOp > OpBase
double default_conductivity
OpBaseDotH OpBaseDivFlux
Integrate Rhs base of temperature times divergent of flux (T)
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpGradTimesSymTensor< 1, SPACE_DIM, SPACE_DIM > OpInternalForceCauchy
static char help[]
[Solve]
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpBaseTimesScalarField< 1 > OpBaseDotH
Integrate Rhs base of temperature time heat capacity times heat rate (T)
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpGradSymTensorGrad< 1, SPACE_DIM, SPACE_DIM, 0 > OpKCauchy
[Only used with Hooke equation (linear material model)]
#define EXECUTABLE_DIMENSION
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMixScalarTimesDiv< SPACE_DIM > OpBaseDivU
[Essential boundary conditions]
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpBaseTimesVector< 3, 3, 1 > OpHdivFlux
Integrating Rhs flux base (1/k) flux (FLUX)
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMass< 3, 3 > OpHdivHdiv
Integrate Lhs base of flux (1/k) base of flux (FLUX x FLUX)
double scale
[Essential boundary conditions (Least square approach)]
double default_young_modulus
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMixDivTimesScalar< SPACE_DIM > OpHdivQ
Integrate Lhs div of base of flux time base of temperature (FLUX x T) and transpose of it,...
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpGradTensorGrad< 1, SPACE_DIM, SPACE_DIM, 1 > OpKPiola
[Only used for dynamics]
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpMixDivTimesU< 3, 1, 2 > OpHDivH
Integrate Rhs div flux base times temperature (T)
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpGradTimesTensor< 1, SPACE_DIM, SPACE_DIM > OpInternalForcePiola
double default_poisson_ratio
FTensor::Index< 'm', 3 > m
Add operators pushing bases from local to physical configuration.
Simple interface for fast problem set-up.
virtual moab::Interface & get_moab()=0
virtual MPI_Comm & get_comm() const =0
virtual int get_comm_rank() const =0
static MoFEMErrorCode Initialize(int *argc, char ***args, const char file[], const char help[])
Initializes the MoFEM database PETSc, MOAB and MPI.
static MoFEMErrorCode Finalize()
Checks for options to be called at the conclusion of the program.
Deprecated interface functions.
Definition of the displacement bc data structure.
Data on single entity (This is passed as argument to DataOperator::doWork)
Essential boundary conditions.
Class (Function) to enforce essential constrains on the left hand side diagonal.
Class (Function) to enforce essential constrains on the right hand side diagonal.
Class (Function) to calculate residual side diagonal.
Class (Function) to enforce essential constrains.
structure for User Loop Methods on finite elements
Field evaluator interface.
Definition of the heat flux bc data structure.
Section manager is used to create indexes and sections.
static boost::shared_ptr< SinkType > createSink(boost::shared_ptr< std::ostream > stream_ptr, std::string comm_filter)
Create a sink object.
static boost::shared_ptr< std::ostream > getStrmWorld()
Get the strm world object.
static boost::shared_ptr< std::ostream > getStrmSync()
Get the strm sync object.
Interface for managing meshsets containing materials and boundary conditions.
Get vector field for H-div approximation.
Calculate divergence of vector field.
Get value at integration points for scalar field.
Calculates the trace of an input matrix.
Get field gradients time derivative at integration pts for scalar field rank 0, i....
Get field gradients at integration pts for scalar field rank 0, i.e. vector field.
Get values at integration pts for tensor field rank 1, i.e. vector field.
Enforce essential constrains on lhs.
Enforce essential constrains on rhs.
Post post-proc data at points from hash maps.
Set indices on entities on finite element.
PipelineManager interface.
Problem manager is used to build and partition problems.
Simple interface for fast problem set-up.
MoFEMErrorCode addDomainField(const std::string name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_of_coefficients, const TagType tag_type=MB_TAG_SPARSE, const enum MoFEMTypes bh=MF_ZERO, int verb=-1)
Add field on domain.
MoFEMErrorCode getOptions()
get options
intrusive_ptr for managing petsc objects
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
auto getConductivityPtr()
Seepage(MoFEM::Interface &m_field)
MoFEMErrorCode setupProblem()
[Run problem]
std::array< double, SPACE_DIM > fieldEvalCoords
MoFEMErrorCode createCommonData()
[Set up problem]
MoFEMErrorCode bC()
[Create common data]
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uZScatter
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uXScatter
MoFEMErrorCode runProblem()
[Run problem]
MoFEMErrorCode OPs()
[Boundary condition]
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uYScatter
MoFEM::Interface & mField
MoFEMErrorCode addMatBlockOps(boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, std::string block_elastic_name, std::string block_thermal_name, boost::shared_ptr< BlockedParameters > blockedParamsPtr, Sev sev)
MoFEMErrorCode tsSolve()
[Push operators to pipeline]