#ifndef EXECUTABLE_DIMENSION
#define EXECUTABLE_DIMENSION 3
#endif
};
};
? AssemblyType::SCHUR
: AssemblyType::PETSC;
IntegrationType::GAUSS;
GAUSS>::OpGradSymTensorGrad<1, SPACE_DIM, SPACE_DIM, 0>;
GAUSS>::OpGradTensorGrad<1, SPACE_DIM, SPACE_DIM, 1>;
DomainNaturalBC::OpFlux<NaturalMeshsetType<BLOCKSET>, 1,
SPACE_DIM>;
BoundaryNaturalBC::OpFlux<NaturalMeshsetType<BLOCKSET>, 1,
SPACE_DIM>;
return std::exp(
std::max(static_cast<double>(std::numeric_limits<float>::min_exponent10),
}
}
constexpr double eps = 1e-12;
return std::max(
r(tau),
eps *
r(0));
}
}
private:
};
};
};
}
true);
auto get_ents_by_dim = [&](
const auto dim) {
return domain_ents;
} else {
else
return ents;
}
};
auto get_base = [&]() {
auto domain_ents = get_ents_by_dim(
SPACE_DIM);
if (domain_ents.empty())
switch (type) {
case MBQUAD:
case MBHEX:
case MBTRI:
case MBTET:
default:
}
};
const auto base = get_base();
auto ents = get_ents_by_dim(0);
ents.merge(get_ents_by_dim(1));
auto project_ho_geometry = [&]() {
};
}
auto get_command_line_parameters = [&]() {
PETSC_NULL);
PETSC_NULL);
PETSC_NULL);
PETSC_NULL);
MOFEM_LOG(
"EXAMPLE", Sev::inform) <<
"Hardening " <<
H;
MOFEM_LOG(
"EXAMPLE", Sev::inform) <<
"Viscous hardening " <<
visH;
MOFEM_LOG(
"EXAMPLE", Sev::inform) <<
"Saturation yield stress " <<
Qinf;
PetscBool is_scale = PETSC_TRUE;
PETSC_NULL);
if (is_scale) {
MOFEM_LOG(
"EXAMPLE", Sev::inform) <<
"Scaled Hardening " <<
H;
MOFEM_LOG(
"EXAMPLE", Sev::inform) <<
"Scaled Viscous hardening " <<
visH;
<<
"Scaled Saturation yield stress " <<
Qinf;
}
};
auto set_matrial_stiffness = [&]() {
: 1;
auto t_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(
auto t_D_axiator = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(
auto t_D_deviator = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(
constexpr double third = boost::math::constants::third<double>();
t_D_axiator(
i,
j,
k,
l) =
A *
t_D_deviator(
i,
j,
k,
l) =
t_D(
i,
j,
k,
l) = t_D_axiator(
i,
j,
k,
l) + t_D_deviator(
i,
j,
k,
l);
};
auto make_d_mat = []() {
};
CHKERR get_command_line_parameters();
CHKERR set_matrial_stiffness();
}
}
CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
"REMOVE_X",
"U", 0, 0);
CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
"REMOVE_Y",
"U", 1, 1);
CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
"REMOVE_Z",
"U", 2, 2);
CHKERR bc_mng->removeBlockDOFsOnEntities(
simple->getProblemName(),
"REMOVE_ALL", "U", 0, 3);
simple->getProblemName(),
"U");
auto &bc_map = bc_mng->getBcMapByBlockName();
boundaryMarker = bc_mng->getMergedBlocksMarker(vector<string>{
"FIX_"});
CHKERR bc_mng->pushMarkDOFsOnEntities(
simple->getProblemName(),
"REACTION",
"U", 0, 3);
for (auto bc : bc_map)
MOFEM_LOG(
"EXAMPLE", Sev::verbose) <<
"Marker " << bc.first;
std::string reaction_block_set;
for (auto bc : bc_map) {
if (bc_mng->checkBlock(bc, "REACTION")) {
reaction_block_set = bc.first;
break;
}
}
if (auto bc = bc_mng->popMarkDOFsOnEntities(reaction_block_set)) {
ProblemsManager::MarkOP::AND, nodes,
} else {
MOFEM_LOG(
"EXAMPLE", Sev::warning) <<
"REACTION blockset does not exist";
}
MOFEM_LOG(
"EXAMPLE", Sev::warning) <<
"REACTION blockset does not exist";
}
}
auto add_domain_base_ops = [&](auto &pipeline) {
"GEOMETRY");
};
auto add_domain_stress_ops = [&](auto &pipeline, auto m_D_ptr) {
"Wrong pointer for grad");
pipeline.push_back(
pipeline.push_back(
pipeline.push_back(
pipeline.push_back(
} else {
pipeline.push_back(
pipeline.push_back(
}
pipeline.push_back(
}
};
auto add_domain_ops_lhs_mechanical = [&](auto &pipeline, auto m_D_ptr) {
pipeline.push_back(
pipeline.push_back(
} else {
pipeline.push_back(
new OpKCauchy(
"U",
"U", m_D_ptr));
}
};
auto add_domain_ops_rhs_mechanical = [&](auto &pipeline) {
CHKERR DomainNaturalBC::AddFluxToPipeline<OpBodyForce>::add(
pipeline,
mField,
"U", {boost::make_shared<PlasticityTimeScale>()},
"BODY_FORCE", Sev::inform);
} else {
pipeline.push_back(
}
};
auto add_domain_ops_lhs_constrain = [&](auto &pipeline, auto m_D_ptr) {
} else {
}
pipeline.push_back(
};
auto add_domain_ops_rhs_constrain = [&](auto &pipeline, auto m_D_ptr) {
pipeline.push_back(
pipeline.push_back(
};
auto add_boundary_ops_lhs_mechanical = [&](auto &pipeline) {
};
auto add_boundary_ops_rhs_mechanical = [&](auto &pipeline) {
CHKERR BoundaryNaturalBC::AddFluxToPipeline<OpForce>::add(
pipeline,
mField,
"U", {boost::make_shared<PlasticityTimeScale>()},
"FORCE", Sev::inform);
auto u_mat_ptr = boost::make_shared<MatrixDouble>();
pipeline.push_back(
{boost::make_shared<TimeScale>()});
};
CHKERR add_domain_base_ops(pip->getOpDomainLhsPipeline());
CHKERR add_domain_stress_ops(pip->getOpDomainLhsPipeline(),
CHKERR add_domain_ops_lhs_mechanical(pip->getOpDomainLhsPipeline(),
CHKERR add_domain_ops_lhs_constrain(pip->getOpDomainLhsPipeline(),
add_boundary_ops_lhs_mechanical(pip->getOpBoundaryLhsPipeline());
CHKERR add_domain_base_ops(pip->getOpDomainRhsPipeline());
CHKERR add_domain_stress_ops(pip->getOpDomainRhsPipeline(),
CHKERR add_domain_ops_rhs_mechanical(pip->getOpDomainRhsPipeline());
CHKERR add_domain_ops_rhs_constrain(pip->getOpDomainRhsPipeline(),
add_boundary_ops_rhs_mechanical(pip->getOpBoundaryRhsPipeline());
auto integration_rule_bc = [](
int,
int,
int ao) {
return 2 * ao; };
CHKERR pip->setDomainRhsIntegrationRule(vol_rule);
CHKERR pip->setDomainLhsIntegrationRule(vol_rule);
CHKERR pip->setBoundaryLhsIntegrationRule(integration_rule_bc);
CHKERR pip->setBoundaryRhsIntegrationRule(integration_rule_bc);
auto create_reaction_pipeline = [&](auto &pipeline) {
"GEOMETRY");
pipeline.push_back(
"Wrong pointer for grad");
pipeline.push_back(
pipeline.push_back(
pipeline.push_back(
pipeline.push_back(
} else {
}
} else {
pipeline.push_back(
}
}
};
}
);
protected:
};
auto set_section_monitor = [&](auto solver) {
SNES snes;
CHKERR TSGetSNES(solver, &snes);
void *))MoFEMSNESMonitorFields,
(void *)(snes_ctx_ptr.get()), nullptr);
};
auto create_post_process_element = [&]() {
auto pp_fe = boost::make_shared<PostProcEle>(
mField);
pp_fe->getOpPtrVector(), {H1}, "GEOMETRY");
auto x_ptr = boost::make_shared<MatrixDouble>();
pp_fe->getOpPtrVector().push_back(
auto u_ptr = boost::make_shared<MatrixDouble>();
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getPostProcMesh(), pp_fe->getMapGaussPts(),
{},
{{"U", u_ptr}, {"GEOMETRY", x_ptr}},
{}
)
);
} else {
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getPostProcMesh(), pp_fe->getMapGaussPts(),
{},
{{"U", u_ptr}, {"GEOMETRY", x_ptr}},
{},
)
);
}
pp_fe->getOpPtrVector().push_back(
pp_fe->getOpPtrVector().push_back(
pp_fe->getPostProcMesh(), pp_fe->getMapGaussPts(),
{{"PLASTIC_SURFACE", commonPlasticDataPtr->getPlasticSurfacePtr()},
{"PLASTIC_MULTIPLIER", commonPlasticDataPtr->getPlasticTauPtr()}},
{},
{},
{{"PLASTIC_STRAIN", commonPlasticDataPtr->getPlasticStrainPtr()},
{"PLASTIC_FLOW", commonPlasticDataPtr->getPlasticFlowPtr()}}
)
);
return pp_fe;
};
auto scatter_create = [&](
auto D,
auto coeff) {
CHKERR is_manager->isCreateProblemFieldAndRank(
simple->getProblemName(),
ROW,
"U", coeff, coeff, is);
int loc_size;
CHKERR ISGetLocalSize(is, &loc_size);
CHKERR VecCreateMPI(mField.get_comm(), loc_size, PETSC_DETERMINE, &
v);
VecScatter scatter;
CHKERR VecScatterCreate(
D, is,
v, PETSC_NULL, &scatter);
};
auto set_time_monitor = [&](auto dm, auto solver) {
boost::shared_ptr<Monitor> monitor_ptr(
new Monitor(dm, create_post_process_element(), reactionFe, uXScatter,
uYScatter, uZScatter));
boost::shared_ptr<ForcesAndSourcesCore> null;
monitor_ptr, null, null);
};
auto set_fieldsplit_preconditioner = [&](auto solver,
boost::shared_ptr<SetUpSchur>
&schur_ptr) {
SNES snes;
CHKERR TSGetSNES(solver, &snes);
KSP ksp;
CHKERR SNESGetKSP(snes, &ksp);
PC pc;
PetscBool is_pcfs = PETSC_FALSE;
PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
if (is_pcfs == PETSC_TRUE) {
auto name_prb =
simple->getProblemName();
for (auto f : {"U", "EP", "TAU"}) {
}
CHKERR bc_mng->removeBlockDOFsOnEntities(
"SUB_BC",
"FIX_X",
"U", 0, 0);
CHKERR bc_mng->removeBlockDOFsOnEntities(
"SUB_BC",
"FIX_Y",
"U", 1, 1);
CHKERR bc_mng->removeBlockDOFsOnEntities(
"SUB_BC",
"FIX_Z",
"U", 2, 2);
CHKERR bc_mng->removeBlockDOFsOnEntities(
"SUB_BC",
"FIX_ALL",
"U", 0,
2);
if (auto sub_data = prb_ptr->getSubData()) {
is_sub = sub_data->getSmartRowIs();
ao_sub = sub_data->getSmartRowMap();
int is_sub_size;
CHKERR ISGetSize(is_sub, &is_sub_size);
<< "Field split second block size " << is_sub_size;
} else {
}
};
for (auto f : {"U"}) {
}
if (auto sub_data = prb_ptr->getSubData()) {
is_sub = sub_data->getSmartRowIs();
ao_sub = sub_data->getSmartRowMap();
int is_sub_size;
CHKERR ISGetSize(is_sub, &is_sub_size);
<< "Field split second block size " << is_sub_size;
} else {
}
};
is_all_bc = bc_mng->getBlockIS(name_prb, "FIX_X", "U", 0, 0);
is_all_bc = bc_mng->getBlockIS(name_prb, "FIX_Y", "U", 1, 1, is_all_bc);
is_all_bc = bc_mng->getBlockIS(name_prb, "FIX_Z", "U", 2, 2, is_all_bc);
is_all_bc =
bc_mng->getBlockIS(name_prb, "FIX_ALL", "U", 0, 2, is_all_bc);
int is_all_bc_size;
CHKERR ISGetSize(is_all_bc, &is_all_bc_size);
<< "Field split first block size " << is_all_bc_size;
};
CHKERR create_all_bc_is(is_all_bc);
CHKERR create_sub_bc_dm(
simple->getDM(), dm_bc_sub, is_bc_sub, ao_bc_sub);
CHKERR PCFieldSplitSetIS(pc, PETSC_NULL,
is_all_bc);
CHKERR PCFieldSplitSetIS(pc, PETSC_NULL, is_bc_sub);
if constexpr (
A == AssemblyType::SCHUR) {
IS is_union_raw;
CHKERR ISExpand(is_epp, is_tau, &is_union_raw);
CHKERR create_sub_u_dm(dm_bc_sub, dm_u_sub, is_u_sub, ao_u_sub);
auto is_up = is_u_sub;
CHKERR AOPetscToApplicationIS(ao_bc_sub, is_up);
schur_ptr =
KSP *ksps;
CHKERR PCFieldSplitGetSubKSP(pc, &
n, &ksps);
CHKERR schur_ptr->setUp(ksps[1]);
}
}
};
uXScatter = scatter_create(
D, 0);
uYScatter = scatter_create(
D, 1);
uZScatter = scatter_create(
D, 2);
auto solver = pip->createTSIM();
auto active_pre_lhs = [&]() {
std::fill(commonPlasticDataPtr->activityData.begin(),
commonPlasticDataPtr->activityData.end(), 0);
};
auto active_post_lhs = [&]() {
auto get_iter = [&]() {
SNES snes;
int iter;
"Can not get iter");
return iter;
};
auto iter = get_iter();
if (iter >= 0) {
std::array<int, 5> activity_data;
std::fill(activity_data.begin(), activity_data.end(), 0);
MPI_Allreduce(commonPlasticDataPtr->activityData.data(),
activity_data.data(), activity_data.size(), MPI_INT,
MPI_SUM, mField.get_comm());
int &active_points = activity_data[0];
int &avtive_full_elems = activity_data[1];
int &avtive_elems = activity_data[2];
int &nb_points = activity_data[3];
int &nb_elements = activity_data[4];
if (nb_points) {
double proc_nb_points =
100 * static_cast<double>(active_points) / nb_points;
double proc_nb_active =
100 * static_cast<double>(avtive_elems) / nb_elements;
double proc_nb_full_active = 100;
if (avtive_elems)
proc_nb_full_active =
100 * static_cast<double>(avtive_full_elems) / avtive_elems;
"EXAMPLE", Sev::inform,
"Iter %d nb pts %d nb avtive pts %d (%3.3f\%) nb active elements %d "
"(%3.3f\%) nb full active elems %d (%3.3f\%)",
iter, nb_points, active_points, proc_nb_points, avtive_elems,
proc_nb_active, avtive_full_elems, proc_nb_full_active, iter);
}
}
};
CHKERR set_section_monitor(solver);
CHKERR set_time_monitor(dm, solver);
CHKERR TSSetFromOptions(solver);
boost::shared_ptr<SetUpSchur> schur_ptr;
CHKERR set_fieldsplit_preconditioner(solver, schur_ptr);
[&]() {
if (schur_ptr)
};
mField.getInterface<
PipelineManager>()->getDomainLhsFE()->postProcessHook =
[&]() {
};
mField.getInterface<
PipelineManager>()->getBoundaryLhsFE()->postProcessHook =
[&]() {
if (schur_ptr)
};
BOOST_LOG_SCOPED_THREAD_ATTR("Timeline", attrs::timer());
MOFEM_LOG(
"TIMER", Sev::verbose) <<
"TSSetUp";
MOFEM_LOG(
"TIMER", Sev::verbose) <<
"TSSetUp <= done";
MOFEM_LOG(
"TIMER", Sev::verbose) <<
"TSSolve";
MOFEM_LOG(
"TIMER", Sev::verbose) <<
"TSSolve <= done";
CHKERR VecGhostUpdateBegin(
D, INSERT_VALUES, SCATTER_FORWARD);
CHKERR VecGhostUpdateEnd(
D, INSERT_VALUES, SCATTER_FORWARD);
}
static char help[] =
"...\n\n";
int main(
int argc,
char *argv[]) {
auto core_log = logging::core::get();
core_log->add_sink(
LogManager::createSink(LogManager::getStrmWorld(), "EXAMPLE"));
core_log->add_sink(
LogManager::createSink(LogManager::getStrmWorld(), "TIMER"));
LogManager::setLog("EXAMPLE");
try {
DMType dm_name = "DMMOFEM";
moab::Core mb_instance;
moab::Interface &moab = mb_instance;
}
}
"Is expected that schur matrix is not allocated. This is "
"possible only is PC is set up twice");
}
}
private:
};
PC pc;
CHKERR KSPSetFromOptions(solver);
PetscBool is_pcfs = PETSC_FALSE;
PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
if (is_pcfs) {
"Is expected that schur matrix is not allocated. This is "
"possible only is PC is set up twice");
}
} else {
pip->getOpBoundaryLhsPipeline().push_back(
pip->getOpDomainLhsPipeline().push_back(
}
}
));
));
}
CHKERR PCFieldSplitSetSchurPre(pc, PC_FIELDSPLIT_SCHUR_PRE_USER,
S);
}
}
MOFEM_LOG(
"TIMER", Sev::verbose) <<
"Lhs Assemble Begin";
}
MOFEM_LOG(
"TIMER", Sev::verbose) <<
"Lhs Assemble End";
CHKERR MatAssemblyBegin(
S, MAT_FINAL_ASSEMBLY);
CHKERR MatAssemblyEnd(
S, MAT_FINAL_ASSEMBLY);
}
}
boost::shared_ptr<SetUpSchur>
return boost::shared_ptr<SetUpSchur>(
}
#define MOFEM_LOG_C(channel, severity, format,...)
void simple(double P1[], double P2[], double P3[], double c[], const int N)
ElementsAndOps< SPACE_DIM >::DomainEle DomainEle
ElementsAndOps< SPACE_DIM >::BoundaryEle BoundaryEle
Kronecker Delta class symmetric.
#define CATCH_ERRORS
Catch errors.
#define MAX_DOFS_ON_ENTITY
Maximal number of DOFs on entity.
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base .
#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
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
@ MOFEM_DATA_INCONSISTENCY
static const char *const ApproximationBaseNames[]
#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 ...
constexpr double shear_modulus_G
constexpr double bulk_modulus_K
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMass< 1, SPACE_DIM > OpMass
FTensor::Index< 'n', SPACE_DIM > n
auto smartCreateDMMatrix(DM dm)
Get smart matrix from DM.
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 DMoFEMMeshToLocalVector(DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode)
set local (or ghosted) vector values on mesh for partition only
PetscErrorCode DMMoFEMAddSubFieldRow(DM dm, const char field_name[])
PetscErrorCode DMRegister_MoFEM(const char sname[])
Register MoFEM problem.
PetscErrorCode DMMoFEMAddSubFieldCol(DM dm, const char field_name[])
auto smartCreateDMVector(DM dm)
Get smart vector from DM.
boost::ptr_deque< UserDataOperator > & getOpBoundaryLhsPipeline()
Get the Op Boundary Lhs Pipeline object.
#define MOFEM_LOG(channel, severity)
Log.
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
#define MOFEM_LOG_CHANNEL(channel)
Set and reset 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)
FTensor::Index< 'k', 3 > k
FormsIntegrators< DomainEleOp >::Assembly< USER_ASSEMBLE >::LinearForm< GAUSS >::OpBaseTimesVector< 1, 3, 1 > OpInertiaForce
FormsIntegrators< DomainEleOp >::Assembly< USER_ASSEMBLE >::LinearForm< GAUSS >::OpSource< 1, 3 > OpBodyForce
const FTensor::Tensor2< T, Dim, Dim > Vec
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
implementation of Data Operators for Forces and Sources
auto type_from_handle(const EntityHandle h)
get type from entity handle
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 PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
auto createSmartDM(MPI_Comm comm, const std::string dm_type_name)
Creates smart DM object.
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)
auto createAOMappingIS(IS isapp, IS ispetsc)
Creates an application mapping using two index sets.
auto getProblemPtr(DM dm)
get problem pointer from DM
auto smartGetDMSnesCtx(DM dm)
Get SNES context data structure used by DM.
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
double hardening_dtau2(double tau)
constexpr size_t activ_history_sise
#define EXECUTABLE_DIMENSION
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< G >::OpGradTimesTensor< 1, SPACE_DIM, SPACE_DIM > OpInternalForcePiola
FormsIntegrators< DomainEleOp >::Assembly< A >::BiLinearForm< GAUSS >::OpGradSymTensorGrad< 1, SPACE_DIM, SPACE_DIM, 0 > OpKCauchy
[Only used with Hooke equation (linear material model)]
FormsIntegrators< BoundaryEleOp >::Assembly< PETSC >::BiLinearForm< G >::OpMass< 1, SPACE_DIM > OpBoundaryMass
[Only used with Hencky/nonlinear material]
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< G >::OpGradTimesSymTensor< 1, SPACE_DIM, SPACE_DIM > OpInternalForceCauchy
BoundaryNaturalBC::OpFlux< NaturalMeshsetType< BLOCKSET >, 1, SPACE_DIM > OpForce
FormsIntegrators< BoundaryEleOp >::Assembly< PETSC >::LinearForm< G >::OpBaseTimesVector< 1, SPACE_DIM, 0 > OpBoundaryVec
NaturalBC< DomainEleOp >::Assembly< A >::LinearForm< G > DomainNaturalBC
EssentialBC< BoundaryEleOp >::Assembly< A >::BiLinearForm< GAUSS >::OpEssentialLhs< DisplacementCubitBcData, 1, SPACE_DIM > OpEssentialLhs
double hardening(double tau)
NaturalBC< BoundaryEleOp >::Assembly< A >::LinearForm< G > BoundaryNaturalBC
EssentialBC< BoundaryEleOp >::Assembly< A >::LinearForm< GAUSS >::OpEssentialRhs< DisplacementCubitBcData, 1, SPACE_DIM > OpEssentialRhs
PetscBool is_large_strains
int geom_order
Order if fixed.
FormsIntegrators< DomainEleOp >::Assembly< A >::BiLinearForm< GAUSS >::OpGradTensorGrad< 1, SPACE_DIM, SPACE_DIM, 1 > OpKPiola
[Only used for dynamics]
double hardening_dtau(double tau)
constexpr IntegrationType G
double hardening_exp(double tau)
FormsIntegrators< BoundaryEleOp >::Assembly< PETSC >::LinearForm< G >::OpBaseTimesVector< 1, SPACE_DIM, 1 > OpBoundaryInternal
OpBaseImpl< PETSC, EdgeEleOp > OpBase
FTensor::Index< 'l', 3 > l
FTensor::Index< 'j', 3 > j
FTensor::Index< 'i', 3 > i
double getScale(const double time)
Get scaling at a given time.
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uZScatter
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uXScatter
FieldApproximationBase base
MoFEMErrorCode createCommonData()
[Set up problem]
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uYScatter
MoFEMErrorCode OPs()
[Boundary condition]
MoFEMErrorCode runProblem()
[Run problem]
MoFEM::Interface & mField
boost::shared_ptr< std::vector< unsigned char > > boundaryMarker
MoFEMErrorCode setupProblem()
[Run problem]
MoFEMErrorCode bC()
[Create common data]
boost::shared_ptr< std::vector< unsigned char > > reactionMarker
boost::shared_ptr< DomainEle > reactionFe
boost::shared_ptr< PlasticOps::CommonData > commonPlasticDataPtr
boost::shared_ptr< HenckyOps::CommonData > commonHenckyDataPtr
Add operators pushing bases from local to physical configuration.
Simple interface for fast problem set-up.
virtual moab::Interface & get_moab()=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.
default operator for TRI element
Section manager is used to create indexes and sections.
Get rate of scalar field at integration points.
Get value at integration points for scalar field.
Calculate symmetric tensor field rates ant integratio pts.
Calculate symmetric tensor field values at integration pts.
Get values at integration pts for tensor filed rank 1, i.e. vector field.
Post post-proc data at points from hash maps.
Scale base functions by inverses of measure of element.
Clear Schur complement internal data.
Assemble Schur complement.
Set indices on entities on finite element.
PipelineManager interface.
Problem manager is used to build and partition problems.
Projection of edge entities with one mid-node on hierarchical basis.
Simple interface for fast problem set-up.
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)
TimeScale constructor.
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce to pointer of interface.
Volume finite element base.
[Push operators to pipeline]
virtual MoFEMErrorCode setUp(KSP solver)=0
virtual MoFEMErrorCode postProc()=0
virtual MoFEMErrorCode preProc()=0
static boost::shared_ptr< SetUpSchur > createSetUpSchur(MoFEM::Interface &m_field, SmartPetscObj< DM >, SmartPetscObj< IS >, SmartPetscObj< AO >)
SmartPetscObj< PC > smartPC
SmartPetscObj< DM > subDM
MoFEMErrorCode setUp(KSP solver)
SmartPetscObj< AO > subAO
virtual ~SetUpSchurImpl()
MoFEMErrorCode postProc()
MoFEMErrorCode setPC(PC pc)
SmartPetscObj< IS > subIS
MoFEMErrorCode setOperator()
MoFEM::Interface & mField