13#ifndef EXECUTABLE_DIMENSION
14 #define EXECUTABLE_DIMENSION 3
18 #define SCHUR_ASSEMBLE 0
26#ifdef ENABLE_PYTHON_BINDING
27 #include <boost/python.hpp>
28 #include <boost/python/def.hpp>
29 #include <boost/python/numpy.hpp>
30namespace bp = boost::python;
31namespace np = boost::python::numpy;
38 IntegrationType::GAUSS;
73 IT>::OpBaseTimesVector<1, SPACE_DIM, 1>;
144#ifdef ENABLE_PYTHON_BINDING
145 boost::shared_ptr<SDFPython> sdfPythonPtr;
189 enum bases { AINSWORTH, DEMKOWICZ, LASBASETOPT };
190 const char *list_bases[LASBASETOPT] = {
"ainsworth",
"demkowicz"};
191 PetscInt choice_base_value = AINSWORTH;
193 LASBASETOPT, &choice_base_value, PETSC_NULLPTR);
196 switch (choice_base_value) {
200 <<
"Set AINSWORTH_LEGENDRE_BASE for displacements";
205 <<
"Set DEMKOWICZ_JACOBI_BASE for displacements";
225 auto get_skin = [&]() {
230 CHKERR skin.find_skin(0, body_ents,
false, skin_ents);
234 auto filter_blocks = [&](
auto skin) {
235 bool is_contact_block =
false;
240 (boost::format(
"%s(.*)") %
"CONTACT").str()
249 <<
"Find contact block set: " <<
m->getName();
250 auto meshset =
m->getMeshset();
251 Range contact_meshset_range;
253 meshset,
SPACE_DIM - 1, contact_meshset_range,
true);
256 contact_meshset_range);
257 contact_range.merge(contact_meshset_range);
259 if (is_contact_block) {
261 <<
"Nb entities in contact surface: " << contact_range.size();
263 skin = intersect(skin, contact_range);
270 ParallelComm *pcomm =
272 CHKERR pcomm->filter_pstatus(skin, PSTATUS_SHARED | PSTATUS_MULTISHARED,
273 PSTATUS_NOT, -1, &boundary_ents);
274 return boundary_ents;
285 moab::Interface::UNION);
294 auto project_ho_geometry = [&]() {
299 PetscBool project_geometry = PETSC_TRUE;
301 &project_geometry, PETSC_NULLPTR);
302 if (project_geometry) {
303 CHKERR project_ho_geometry();
315 PetscBool use_mfront = PETSC_FALSE;
342 <<
"Selected material model: Hooke (small strain)";
345 <<
"Selected material model: Hencky (finite strain)";
350 MOFEM_LOG(
"CONTACT", Sev::inform) <<
"Using MFront for material model";
361 PetscBool use_scale = PETSC_FALSE;
375#ifdef ENABLE_PYTHON_BINDING
376 auto file_exists = [](std::string myfile) {
377 std::ifstream file(myfile.c_str());
383 char sdf_file_name[255] =
"sdf.py";
385 sdf_file_name, 255, PETSC_NULLPTR);
387 if (file_exists(sdf_file_name)) {
388 MOFEM_LOG(
"CONTACT", Sev::inform) << sdf_file_name <<
" file found";
389 sdfPythonPtr = boost::make_shared<SDFPython>();
390 CHKERR sdfPythonPtr->sdfInit(sdf_file_name);
391 sdfPythonWeakPtr = sdfPythonPtr;
393 MOFEM_LOG(
"CONTACT", Sev::warning) << sdf_file_name <<
" file NOT found";
400 "Use executable contact_2d with axisymmetric model");
404 "Axisymmetric model is only available with MFront (set "
407 MOFEM_LOG(
"CONTACT", Sev::inform) <<
"Using axisymmetric model";
412 MOFEM_LOG(
"CONTACT", Sev::inform) <<
"Using plane strain model";
448 for (
auto f : {
"U",
"SIGMA"}) {
449 CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
450 "REMOVE_X",
f, 0, 0);
451 CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
452 "REMOVE_Y",
f, 1, 1);
453 CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
454 "REMOVE_Z",
f, 2, 2);
455 CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
456 "REMOVE_ALL",
f, 0, 3);
459 CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
"FIX_X",
460 "SIGMA", 0, 0,
false,
true);
461 CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
"FIX_Y",
462 "SIGMA", 1, 1,
false,
true);
463 CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
"FIX_Z",
464 "SIGMA", 2, 2,
false,
true);
465 CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
"FIX_ALL",
466 "SIGMA", 0, 3,
false,
true);
467 CHKERR bc_mng->removeBlockDOFsOnEntities(
468 simple->getProblemName(),
"NO_CONTACT",
"SIGMA", 0, 3,
false,
true);
473 simple->getProblemName(),
"U");
484 auto time_scale = boost::make_shared<ScaledTimeScale>();
485 auto body_force_time_scale =
486 boost::make_shared<ScaledTimeScale>(
"body_force_hist.txt");
488 auto integration_rule_vol = [](int, int,
int approx_order) {
491 auto integration_rule_boundary = [](int, int,
int approx_order) {
495 auto add_domain_base_ops = [&](
auto &pip) {
502 auto add_domain_ops_lhs = [&](
auto &pip) {
512 auto fe_domain_lhs = pip_mng->getDomainLhsFE();
514 auto get_inertia_and_mass_damping =
516 return (
rho *
scale) * fe_domain_lhs->ts_aa +
519 pip.push_back(
new OpMass(
"U",
"U", get_inertia_and_mass_damping));
523 auto fe_domain_lhs = pip_mng->getDomainLhsFE();
525 auto get_inertia_and_mass_damping =
529 pip.push_back(
new OpMass(
"U",
"U", get_inertia_and_mass_damping));
534 CHKERR HookeOps::opFactoryDomainLhs<SPACE_DIM, AT, IT, DomainEleOp>(
535 mField, pip,
"U",
"MAT_ELASTIC", Sev::verbose,
scale);
537 CHKERR HenckyOps::opFactoryDomainLhs<SPACE_DIM, AT, IT, DomainEleOp>(
538 mField, pip,
"U",
"MAT_ELASTIC", Sev::verbose,
scale);
547 auto add_domain_ops_rhs = [&](
auto &pip) {
551 pip,
mField,
"U", {body_force_time_scale}, Sev::inform);
560 auto mat_acceleration = boost::make_shared<MatrixDouble>();
562 "U", mat_acceleration));
564 new OpInertiaForce(
"U", mat_acceleration, [](
double,
double,
double) {
571 auto mat_velocity = boost::make_shared<MatrixDouble>();
575 new OpInertiaForce(
"U", mat_velocity, [](
double,
double,
double) {
582 CHKERR HookeOps::opFactoryDomainRhs<SPACE_DIM, AT, IT, DomainEleOp>(
583 mField, pip,
"U",
"MAT_ELASTIC", Sev::inform, 1,
scale);
585 CHKERR HenckyOps::opFactoryDomainRhs<SPACE_DIM, AT, IT, DomainEleOp>(
586 mField, pip,
"U",
"MAT_ELASTIC", Sev::inform,
scale);
592 CHKERR ContactOps::opFactoryDomainRhs<SPACE_DIM, AT, IT, DomainEleOp>(
598 auto add_boundary_base_ops = [&](
auto &pip) {
608 auto add_boundary_ops_lhs = [&](
auto &pip) {
618 pip,
mField,
"U", Sev::inform);
623 auto fe_boundary_lhs = pip_mng->getBoundaryLhsFE();
628 [
this, fe_boundary_lhs](
double,
double,
double) {
637 ContactOps::opFactoryBoundaryLhs<SPACE_DIM, AT, GAUSS, BoundaryEleOp>(
641 mField, pip,
simple->getDomainFEName(),
"SIGMA",
"U",
"GEOMETRY",
647 auto add_boundary_ops_rhs = [&](
auto &pip) {
657 pip,
mField,
"U", {time_scale}, Sev::inform);
660 auto u_disp = boost::make_shared<MatrixDouble>();
661 auto dot_u_disp = boost::make_shared<MatrixDouble>();
666 new OpSpringRhs(
"U", u_disp, [
this](
double,
double,
double) {
670 new OpSpringRhs(
"U", dot_u_disp, [
this](
double,
double,
double) {
676 ContactOps::opFactoryBoundaryRhs<SPACE_DIM, AT, GAUSS, BoundaryEleOp>(
682 CHKERR add_domain_base_ops(pip_mng->getOpDomainLhsPipeline());
683 CHKERR add_domain_base_ops(pip_mng->getOpDomainRhsPipeline());
684 CHKERR add_domain_ops_lhs(pip_mng->getOpDomainLhsPipeline());
685 CHKERR add_domain_ops_rhs(pip_mng->getOpDomainRhsPipeline());
687 CHKERR add_boundary_base_ops(pip_mng->getOpBoundaryLhsPipeline());
688 CHKERR add_boundary_base_ops(pip_mng->getOpBoundaryRhsPipeline());
689 CHKERR add_boundary_ops_lhs(pip_mng->getOpBoundaryLhsPipeline());
690 CHKERR add_boundary_ops_rhs(pip_mng->getOpBoundaryRhsPipeline());
694 integration_rule_vol,
"U");
696 integration_rule_vol,
simple->getDomainFEName(),
"U",
order);
699 CHKERR pip_mng->setDomainRhsIntegrationRule(integration_rule_vol);
700 CHKERR pip_mng->setDomainLhsIntegrationRule(integration_rule_vol);
701 CHKERR pip_mng->setBoundaryRhsIntegrationRule(integration_rule_boundary);
702 CHKERR pip_mng->setBoundaryLhsIntegrationRule(integration_rule_boundary);
710 static boost::shared_ptr<SetUpSchur>
725 auto set_section_monitor = [&](
auto solver) {
728 CHKERR TSGetSNES(solver, &snes);
729 PetscViewerAndFormat *vf;
730 CHKERR PetscViewerAndFormatCreate(PETSC_VIEWER_STDOUT_WORLD,
731 PETSC_VIEWER_DEFAULT, &vf);
735 void *))SNESMonitorFields,
740 auto scatter_create = [&](
auto D,
auto coeff) {
742 CHKERR is_manager->isCreateProblemFieldAndRank(
simple->getProblemName(),
743 ROW,
"U", coeff, coeff, is);
745 CHKERR ISGetLocalSize(is, &loc_size);
749 CHKERR VecScatterCreate(
D, is,
v, PETSC_NULLPTR, &scatter);
754 auto set_time_monitor = [&](
auto dm,
auto solver) {
757 boost::shared_ptr<ForcesAndSourcesCore> null;
763 auto set_essential_bc = [&]() {
767 auto pre_proc_ptr = boost::make_shared<FEMethod>();
768 auto post_proc_rhs_ptr = boost::make_shared<FEMethod>();
769 auto post_proc_lhs_ptr = boost::make_shared<FEMethod>();
772 auto time_scale = boost::make_shared<TimeScale>();
774 auto get_bc_hook_rhs = [&]() {
776 {time_scale},
false);
779 pre_proc_ptr->preProcessHook = get_bc_hook_rhs();
781 auto get_post_proc_hook_rhs = [&]() {
783 mField, post_proc_rhs_ptr, 1.);
785 auto get_post_proc_hook_lhs = [&]() {
787 mField, post_proc_lhs_ptr, 1.);
789 post_proc_rhs_ptr->postProcessHook = get_post_proc_hook_rhs();
791 ts_ctx_ptr->getPreProcessIFunction().push_front(pre_proc_ptr);
792 ts_ctx_ptr->getPreProcessIJacobian().push_front(pre_proc_ptr);
793 ts_ctx_ptr->getPostProcessIFunction().push_back(post_proc_rhs_ptr);
794 post_proc_lhs_ptr->postProcessHook = get_post_proc_hook_lhs();
795 ts_ctx_ptr->getPostProcessIJacobian().push_back(post_proc_lhs_ptr);
800 auto set_schur_pc = [&](
auto solver) {
801 boost::shared_ptr<SetUpSchur> schur_ptr;
802 if (
AT == AssemblyType::BLOCK_SCHUR) {
810 auto dm =
simple->getDM();
822 CHKERR set_essential_bc();
825 auto solver = pip_mng->createTSIM();
826 CHKERR TSSetFromOptions(solver);
829 CHKERR TSSetIJacobian(solver,
B,
B, PETSC_NULLPTR, PETSC_NULLPTR);
830 auto schur_pc_ptr = set_schur_pc(solver);
833 CHKERR set_section_monitor(solver);
834 CHKERR set_time_monitor(dm, solver);
835 CHKERR TSSetSolution(solver,
D);
837 CHKERR TSSolve(solver, NULL);
839 auto solver = pip_mng->createTSIM2();
840 CHKERR TSSetFromOptions(solver);
843 CHKERR TSSetI2Jacobian(solver,
B,
B, PETSC_NULLPTR, PETSC_NULLPTR);
844 auto schur_pc_ptr = set_schur_pc(solver);
848 CHKERR set_section_monitor(solver);
849 CHKERR set_time_monitor(dm, solver);
850 CHKERR TS2SetSolution(solver,
D, DD);
852 CHKERR TSSolve(solver, NULL);
867 double analytical_active_area = 1.0;
869 double tol_force = 1e-3;
870 double tol_norm = 7.5;
871 double tol_area = 3e-2;
872 double fem_active_area = t_ptr[3];
877 fem_force = t_ptr[1];
882 fem_force = t_ptr[1];
889 fem_force = t_ptr[2];
890 analytical_active_area = M_PI / 4;
900 hertz_force = 15.873;
902 fem_force = t_ptr[1];
904 analytical_active_area = M_PI;
909 fem_force = t_ptr[1];
913 hertz_force = 0.5289;
914 fem_force = t_ptr[2];
919 "atom test %d does not exist",
atom_test);
921 if (fabs(fem_force - hertz_force) / hertz_force > tol_force) {
923 "atom test %d failed: Wrong FORCE output: %3.4e != %3.4e",
926 if (norm > tol_norm) {
928 "atom test %d failed: Wrong NORM output: %3.4e > %3.4e",
931 if (fabs(fem_active_area - analytical_active_area) > tol_area) {
933 "atom test %d failed: AREA computed %3.4e but should be %3.4e",
934 atom_test, fem_active_area, analytical_active_area);
947int main(
int argc,
char *argv[]) {
949#ifdef ENABLE_PYTHON_BINDING
955 const char param_file[] =
"param_file.petsc";
959 auto core_log = logging::core::get();
968 DMType dm_name =
"DMMOFEM";
970 DMType dm_name_mg =
"DMMOFEM_MG";
975 moab::Core mb_instance;
976 moab::Interface &moab = mb_instance;
999#ifdef ENABLE_PYTHON_BINDING
1000 if (Py_FinalizeEx() < 0) {
1035 CHKERR TSGetSNES(solver, &snes);
1037 CHKERR SNESGetKSP(snes, &ksp);
1038 CHKERR KSPSetFromOptions(ksp);
1041 CHKERR KSPGetPC(ksp, &pc);
1043 PetscBool is_pcfs = PETSC_FALSE;
1044 PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
1047 MOFEM_LOG(
"CONTACT", Sev::inform) <<
"Setup Schur pc";
1052 "It is expected that Schur matrix is not allocated. This is "
1053 "possible only if PC is set up twice");
1065 CHKERR TSGetDM(solver, &solver_dm);
1066 CHKERR DMSetMatType(solver_dm, MATSHELL);
1073 auto swap_assemble = [](TS ts, PetscReal
t, Vec u, Vec u_t, PetscReal
a,
1074 Mat
A, Mat
B,
void *ctx) {
1077 CHKERR TSSetIJacobian(solver,
A, P, swap_assemble, ts_ctx_ptr.get());
1079 auto swap_assemble = [](TS ts, PetscReal
t, Vec u, Vec u_t, Vec utt,
1080 PetscReal
a, PetscReal aa, Mat
A, Mat
B,
1084 CHKERR TSSetI2Jacobian(solver,
A, P, swap_assemble, ts_ctx_ptr.get());
1086 CHKERR KSPSetOperators(ksp,
A, P);
1095 MOFEM_LOG(
"CONTACT", Sev::inform) <<
"No Schur PC";
1108 auto create_dm = [&](
const char *name,
const char *
field_name,
auto dm_type) {
1110 auto create_dm_imp = [&]() {
1122 "Error in creating schurDM. It is possible that schurDM is "
1130 schurDM = create_dm(
"SCHUR",
"U",
"DMMOFEM_MG");
1131 blockDM = create_dm(
"BLOCK",
"SIGMA",
"DMMOFEM");
1133 if constexpr (
AT == AssemblyType::BLOCK_SCHUR) {
1135 auto get_nested_mat_data = [&](
auto schur_dm,
auto block_dm) {
1141 simple->getDomainFEName(),
1145 {
"U",
"U"}, {
"SIGMA",
"U"}, {
"U",
"SIGMA"}, {
"SIGMA",
"SIGMA"}
1153 {schur_dm, block_dm}, block_mat_data,
1155 {
"SIGMA"}, {
nullptr}, true
1165 "Only BLOCK_SCHUR is implemented");
1174 double eps_stab = 1e-4;
1180 using OpMassStab = B::OpMass<3, SPACE_DIM * SPACE_DIM>;
1190 pip->getOpBoundaryLhsPipeline().push_back(
1191 new OpMassStab(
"SIGMA",
"SIGMA",
1192 [eps_stab](
double,
double,
double) {
return eps_stab; }));
1193 pip->getOpBoundaryLhsPipeline().push_back(
1201 pip->getOpDomainLhsPipeline().push_back(
1207 auto pre_proc_schur_lhs_ptr = boost::make_shared<FEMethod>();
1208 auto post_proc_schur_lhs_ptr = boost::make_shared<FEMethod>();
1210 pre_proc_schur_lhs_ptr->preProcessHook = [
this]() {
1213 MOFEM_LOG(
"CONTACT", Sev::verbose) <<
"Lhs Assemble Begin";
1217 post_proc_schur_lhs_ptr->postProcessHook = [
this, ao_up,
1218 post_proc_schur_lhs_ptr]() {
1220 MOFEM_LOG(
"CONTACT", Sev::verbose) <<
"Lhs Assemble End";
1221 auto print_mat_norm = [
this](
auto a, std::string prefix) {
1224 CHKERR MatNorm(
a, NORM_FROBENIUS, &nrm);
1225 MOFEM_LOG(
"CONTACT", Sev::noisy) << prefix <<
" norm = " << nrm;
1228 CHKERR MatAssemblyBegin(
S, MAT_FINAL_ASSEMBLY);
1229 CHKERR MatAssemblyEnd(
S, MAT_FINAL_ASSEMBLY);
1231 mField, post_proc_schur_lhs_ptr, 1,
S, ao_up)();
1233 CHKERR print_mat_norm(
S,
"S");
1235 MOFEM_LOG(
"CONTACT", Sev::verbose) <<
"Lhs Assemble Finish";
1240 ts_ctx_ptr->getPreProcessIJacobian().push_front(pre_proc_schur_lhs_ptr);
1241 ts_ctx_ptr->getPostProcessIJacobian().push_back(post_proc_schur_lhs_ptr);
1249 CHKERR PCFieldSplitSetIS(pc, NULL, block_is);
1250 CHKERR PCFieldSplitSetSchurPre(pc, PC_FIELDSPLIT_SCHUR_PRE_USER,
S);
1257 CHKERR PCFieldSplitSchurGetSubKSP(pc, PETSC_NULLPTR, &subksp);
1258 auto get_pc = [](
auto ksp) {
1260 CHKERR KSPGetPC(ksp, &pc_raw);
1265 auto set_pc_p_mg = [](
auto dm,
auto pc,
auto S) {
1268 PetscBool same = PETSC_FALSE;
1269 PetscObjectTypeCompare((PetscObject)pc, PCMG, &same);
1273 CHKERR PCSetFromOptions(pc);
1278 auto set_pc_ksp = [&](
auto dm,
auto pc,
auto S) {
1280 PetscBool same = PETSC_FALSE;
1281 PetscObjectTypeCompare((PetscObject)pc, PCKSP, &same);
1283 CHKERR PCSetFromOptions(pc);
1285 CHKERR PCKSPGetKSP(pc, &inner_ksp);
1286 CHKERR KSPSetFromOptions(inner_ksp);
1288 CHKERR KSPGetPC(inner_ksp, &inner_pc);
1289 CHKERR PCSetFromOptions(inner_pc);
1290 CHKERR set_pc_p_mg(dm, inner_pc,
S);
1298 CHKERR PetscFree(subksp);
1302boost::shared_ptr<SetUpSchur>
1304 return boost::shared_ptr<SetUpSchur>(
new SetUpSchurImpl(m_field));
static auto filter_true_skin(MoFEM::Interface &m_field, Range &&skin)
Implementation of Hookes operator Hookes for linear elastic problems in MoFEM.
#define MOFEM_LOG_SYNCHRONISE(comm)
Synchronise "SYNC" channel.
void simple(double P1[], double P2[], double P3[], double c[], const int N)
ElementsAndOps< SPACE_DIM >::DomainEle DomainEle
ElementsAndOps< SPACE_DIM >::BoundaryEle BoundaryEle
#define CATCH_ERRORS
Catch errors.
FieldApproximationBase
approximation base
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base .
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
FieldSpace
approximation spaces
@ 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 ...
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
@ MOFEM_ATOM_TEST_INVALID
@ MOFEM_DATA_INCONSISTENCY
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpBaseTimesVector< 1, SPACE_DIM, 1 > OpInertiaForce
PetscErrorCode DMMoFEMCreateSubDM(DM subdm, DM dm, const char problem_name[])
Must be called by user to set Sub DM MoFEM data structures.
PetscErrorCode DMMoFEMAddElement(DM dm, std::string fe_name)
add element to dm
PetscErrorCode DMMoFEMSetSquareProblem(DM dm, PetscBool square_problem)
set squared problem
PetscErrorCode DMMoFEMAddSubFieldRow(DM dm, const char field_name[])
PetscErrorCode DMRegister_MoFEM(const char sname[])
Register MoFEM problem.
MoFEMErrorCode DMRegister_MGViaApproxOrders(const char sname[])
Register DM for Multi-Grid via approximation orders.
auto createDMVector(DM dm)
Get smart vector from DM.
PetscErrorCode DMMoFEMAddSubFieldCol(DM dm, const char field_name[])
auto createDMMatrix(DM dm)
Get smart matrix from DM.
static LoggerType & setLog(const std::string channel)
Set ans resset chanel logger.
#define MOFEM_LOG(channel, severity)
Log.
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
virtual MoFEMErrorCode loop_dofs(const Problem *problem_ptr, const std::string &field_name, RowColData rc, DofMethod &method, int lower_rank, int upper_rank, int verb=DEFAULT_VERBOSITY)=0
Make a loop over dofs.
const double v
phase velocity of light in medium (cm/ns)
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.
PetscErrorCode TsSetIJacobian(TS ts, PetscReal t, Vec u, Vec u_t, PetscReal a, Mat A, Mat B, void *ctx)
Set function evaluating jacobian in TS solver.
auto getDMTsCtx(DM dm)
Get TS context data structure used by DM.
OpSchurAssembleBase * createOpSchurAssembleEnd(std::vector< std::string > fields_name, std::vector< boost::shared_ptr< Range > > field_ents, SmartPetscObj< AO > ao, SmartPetscObj< Mat > schur, bool sym_schur, bool symm_op)
Construct a new Op Schur Assemble End object.
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
MoFEMErrorCode setSchurA00MatSolvePC(SmartPetscObj< PC > pc)
Set PC for A00 block.
PetscErrorCode PetscOptionsGetBool(PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
PetscErrorCode PetscOptionsGetScalar(PetscOptions *, const char pre[], const char name[], PetscScalar *dval, PetscBool *set)
SmartPetscObj< Vec > vectorDuplicate(Vec vec)
Create duplicate vector of smart vector.
boost::shared_ptr< PCMGSetUpViaApproxOrdersCtx > createPCMGSetUpViaApproxOrdersCtx(DM dm, Mat A, bool use_shell_mat)
createPCMGSetUpViaApproxOrdersCtx
auto getDMSubData(DM dm)
Get sub problem data structure.
boost::shared_ptr< MFrontInterface > createMFrontInterface(MoFEM::Interface &m_field, ModelHypothesis mh, AssemblyType at=AssemblyType::PETSC)
create mfront interface
PetscErrorCode TsSetI2Jacobian(TS ts, PetscReal t, Vec u, Vec u_t, Vec u_tt, PetscReal a, PetscReal aa, Mat A, Mat B, void *ctx)
Calculation Jacobian for second order PDE in time.
MoFEMErrorCode PCMGSetUpViaApproxOrders(PC pc, boost::shared_ptr< PCMGSetUpViaApproxOrdersCtx > ctx, int verb)
Function build MG structure.
@ AXISYMMETRICAL
Axisymmetrical model hypothesis.
@ PLANESTRAIN
Plane strain model hypothesis.
@ TRIDIMENSIONAL
3D model hypothesis.
boost::shared_ptr< BlockStructure > createBlockMatStructure(DM dm, SchurFEOpsFEandFields schur_fe_op_vec)
Create a Mat Diag Blocks object.
boost::shared_ptr< NestSchurData > createSchurNestedMatrixStruture(std::pair< SmartPetscObj< DM >, SmartPetscObj< DM > > dms, boost::shared_ptr< BlockStructure > block_mat_data_ptr, std::vector< std::string > fields_names, std::vector< boost::shared_ptr< Range > > field_ents, bool add_preconditioner_block)
Get the Schur Nest Mat Array object.
auto createAOMappingIS(IS isapp, IS ispetsc)
Creates an application mapping using two index sets.
PetscErrorCode PetscOptionsGetEList(PetscOptions *, const char pre[], const char name[], const char *const *list, PetscInt next, PetscInt *value, PetscBool *set)
PetscErrorCode PetscOptionsGetString(PetscOptions *, const char pre[], const char name[], char str[], size_t size, PetscBool *set)
MoFEMErrorCode DMMoFEMSetNestSchurData(DM dm, boost::shared_ptr< NestSchurData >)
auto createDMNestSchurMat(DM dm)
auto createDM(MPI_Comm comm, const std::string dm_type_name)
Creates smart DM object.
OpSchurAssembleBase * createOpSchurAssembleBegin()
auto createDMBlockMat(DM dm)
PetscBool is_quasi_static
ElementsAndOps< SPACE_DIM >::SideEle SideEle
constexpr FieldSpace CONTACT_SPACE
constexpr double t
plate stiffness
constexpr auto field_name
static constexpr int approx_order
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMass< 1, SPACE_DIM > OpMass
[Only used with Hooke equation (linear material model)]
FTensor::Index< 'm', 3 > m
Add operators pushing bases from local to physical configuration.
Boundary condition manager for finite element problem setup.
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)
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 enforce essential constrains.
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.
Interface for managing meshsets containing materials and boundary conditions.
Approximate field values for given petsc vector.
Specialization for double precision vector field values calculation.
Template struct for dimension-specific finite element types.
PipelineManager interface.
Projection of edge entities with one mid-node on hierarchical basis.
Simple interface for fast problem set-up.
MoFEMErrorCode getOptions()
get options
MoFEMErrorCode getDM(DM *dm)
Get DM.
intrusive_ptr for managing petsc objects
Force scale operator for reading two columns.
double getScale(const double time)
Get scaling at a given time.
TimeScale(std::string file_name="", bool error_if_file_not_given=false, ScalingFun def_scaling_fun=[](double time) { return time;})
TimeScale constructor.
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
MoFEMErrorCode createSubDM()
MoFEMErrorCode setDiagonalPC(PC pc)
SetUpSchurImpl(MoFEM::Interface &m_field)
SmartPetscObj< DM > schurDM
MoFEMErrorCode setUp(SmartPetscObj< KSP >)
SmartPetscObj< DM > blockDM
virtual ~SetUpSchurImpl()
MoFEMErrorCode setPC(PC pc)
MoFEMErrorCode setOperator()
MoFEM::Interface & mField
[Push operators to pipeline]
static boost::shared_ptr< SetUpSchur > createSetUpSchur(MoFEM::Interface &m_field)
virtual MoFEMErrorCode setUp(SmartPetscObj< TS > solver)=0
static boost::shared_ptr< SetUpSchur > createSetUpSchur(MoFEM::Interface &m_field)
constexpr AssemblyType AT