16static char help[] =
"...\n\n";
21 ? AssemblyType::BLOCK_MAT
29 IntegrationType::GAUSS;
45 static boost::shared_ptr<SetUpSchur>
56int main(
int argc,
char *argv[]) {
63 DMType dm_name =
"DMMOFEM";
65 DMType dm_name_mg =
"DMMOFEM_MG";
69 moab::Core mb_instance;
70 moab::Interface &moab = mb_instance;
73 auto core_log = logging::core::get();
89 simple->getAddBoundaryFE() =
true;
92 auto add_shared_entities_on_skeleton = [&]() {
94 auto boundary_meshset =
simple->getBoundaryMeshSet();
95 auto skeleton_meshset =
simple->getSkeletonMeshSet();
101 0,
simple->getDim() - 1, skeleton_ents,
true);
102 skeleton_ents = subtract(skeleton_ents, bdy_ents);
104 CHKERR m_field.
get_moab().add_entities(skeleton_meshset, skeleton_ents);
108 CHKERR add_shared_entities_on_skeleton();
118 const char *list_bases[] = {
"ainsworth",
"ainsworth_lobatto",
"demkowicz",
121 PetscInt choice_base_value = AINSWORTH;
123 LASBASETOP, &choice_base_value, &flg);
125 if (flg != PETSC_TRUE)
128 if (choice_base_value == AINSWORTH)
130 if (choice_base_value == AINSWORTH_LOBATTO)
132 else if (choice_base_value == DEMKOWICZ)
134 else if (choice_base_value == BERNSTEIN)
137 enum spaces { hdiv, hcurl, last_space };
138 const char *list_spaces[] = {
"hdiv",
"hcurl"};
139 PetscInt choice_space_value = hdiv;
141 last_space, &choice_space_value, &flg);
142 if (flg != PETSC_TRUE)
145 if (choice_space_value == hdiv)
147 else if (choice_space_value == hcurl)
153 CHKERR simple->addDomainBrokenField(
"BROKEN", space, base, 1);
169 auto assemble_domain_lhs = [&](
auto &pip) {
176 IT>::OpMixDivTimesScalar<SPACE_DIM>;
182 pip.push_back(
new OpHdivHdiv(
"BROKEN",
"BROKEN", beta));
183 auto unity = []()
constexpr {
return 1; };
184 pip.push_back(
new OpHdivU(
"BROKEN",
"U", unity,
true));
192 op_loop_skeleton_side->getOpPtrVector(), {});
196 auto broken_data_ptr =
197 boost::make_shared<std::vector<BrokenBaseSideData>>();
202 op_loop_domain_side->getOpPtrVector(), {HDIV});
203 op_loop_domain_side->getOpPtrVector().push_back(
206 op_loop_skeleton_side->getOpPtrVector().push_back(op_loop_domain_side);
208 IT>::OpBrokenSpaceConstrain<1>;
209 op_loop_skeleton_side->getOpPtrVector().push_back(
210 new OpC(
"HYBRID", broken_data_ptr, 1.,
true,
false));
214 constexpr int partition = 1;
216 op_print->doWorkRhsHook = [&](
DataOperator *base_op_ptr,
int side,
220 if (
auto op_ptr =
dynamic_cast<BdyEleOp *
>(base_op_ptr)) {
221 auto fe_method = op_ptr->getFEMethod();
222 auto num_fe = fe_method->numeredEntFiniteElementPtr;
225 if (num_fe->getPStatus() & PSTATUS_SHARED)
226 MOFEM_LOG(
"SELF", Sev::inform) <<
"Num FE: " << *num_fe;
231 op_loop_skeleton_side->getOpPtrVector().push_back(op_print);
234 pip.push_back(op_loop_skeleton_side);
239 auto assemble_domain_rhs = [&](
auto &pip) {
244 auto source = [&](
const double x,
const double y,
245 const double z)
constexpr {
254 CHKERR assemble_domain_lhs(pip_mng->getOpDomainLhsPipeline());
255 CHKERR assemble_domain_rhs(pip_mng->getOpDomainRhsPipeline());
262 TetPolynomialBase::switchCacheBaseOn<HDIV>(
263 {pip_mng->getDomainLhsFE().get(), pip_mng->getDomainRhsFE().get()});
264 TetPolynomialBase::switchCacheBaseOn<L2>(
265 {pip_mng->getDomainLhsFE().get(), pip_mng->getDomainRhsFE().get()});
271 auto ksp = pip_mng->createKSP();
273 CHKERR KSPSetFromOptions(ksp);
274 BOOST_LOG_SCOPED_THREAD_ATTR(
"Timeline", attrs::timer());
275 MOFEM_LOG(
"TIMER", Sev::inform) <<
"KSPSetUp";
277 MOFEM_LOG(
"TIMER", Sev::inform) <<
"KSPSetUp <= Done";
279 MOFEM_LOG(
"TIMER", Sev::inform) <<
"KSPSolve";
280 CHKERR KSPSolve(ksp, f, x);
281 MOFEM_LOG(
"TIMER", Sev::inform) <<
"KSPSolve <= Done";
283 CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
284 CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
288 auto ksp = pip_mng->createKSP();
290 BOOST_LOG_SCOPED_THREAD_ATTR(
"Timeline", attrs::timer());
291 MOFEM_LOG(
"TIMER", Sev::inform) <<
"KSPSetUp";
292 CHKERR schur_ptr->setUp(ksp);
293 MOFEM_LOG(
"TIMER", Sev::inform) <<
"KSPSetUp <= Done";
295 MOFEM_LOG(
"TIMER", Sev::inform) <<
"KSPSolve";
296 CHKERR KSPSolve(ksp, f, x);
297 MOFEM_LOG(
"TIMER", Sev::inform) <<
"KSPSolve <= Done";
299 CHKERR VecGhostUpdateBegin(x, INSERT_VALUES, SCATTER_FORWARD);
300 CHKERR VecGhostUpdateEnd(x, INSERT_VALUES, SCATTER_FORWARD);
305 auto check_residual = [&](
auto x,
auto f) {
311 auto &domain_rhs = pip_mng->getOpDomainRhsPipeline();
317 auto div_flux_ptr = boost::make_shared<VectorDouble>();
319 "BROKEN", div_flux_ptr));
323 domain_rhs.push_back(
new OpUDivFlux(
"U", div_flux_ptr, beta));
324 auto source = [&](
const double x,
const double y,
325 const double z)
constexpr {
return 1; };
331 IT>::OpMixDivTimesU<3, 1, SPACE_DIM>;
334 auto flux_ptr = boost::make_shared<MatrixDouble>();
335 domain_rhs.push_back(
337 boost::shared_ptr<VectorDouble> u_ptr =
338 boost::make_shared<VectorDouble>();
340 domain_rhs.push_back(
new OpHDivH(
"BROKEN", u_ptr, beta));
341 domain_rhs.push_back(
new OpHdivFlux(
"BROKEN", flux_ptr, beta));
349 op_loop_skeleton_side->getOpPtrVector(), {});
353 auto broken_data_ptr =
354 boost::make_shared<std::vector<BrokenBaseSideData>>();
359 op_loop_domain_side->getOpPtrVector(), {HDIV});
360 op_loop_domain_side->getOpPtrVector().push_back(
362 auto flux_mat_ptr = boost::make_shared<MatrixDouble>();
363 op_loop_domain_side->getOpPtrVector().push_back(
365 op_loop_domain_side->getOpPtrVector().push_back(
369 op_loop_skeleton_side->getOpPtrVector().push_back(op_loop_domain_side);
371 IT>::OpBrokenSpaceConstrainDHybrid<1>;
373 IT>::OpBrokenSpaceConstrainDFlux<1>;
374 op_loop_skeleton_side->getOpPtrVector().push_back(
375 new OpC_dHybrid(
"HYBRID", broken_data_ptr, 1.));
376 auto hybrid_ptr = boost::make_shared<MatrixDouble>();
377 op_loop_skeleton_side->getOpPtrVector().push_back(
379 op_loop_skeleton_side->getOpPtrVector().push_back(
380 new OpC_dBroken(broken_data_ptr, hybrid_ptr, 1.));
383 domain_rhs.push_back(op_loop_skeleton_side);
386 CHKERR VecGhostUpdateBegin(f, INSERT_VALUES, SCATTER_FORWARD);
387 CHKERR VecGhostUpdateEnd(f, INSERT_VALUES, SCATTER_FORWARD);
389 pip_mng->getDomainRhsFE()->f = f;
390 pip_mng->getSkeletonRhsFE()->f = f;
391 pip_mng->getDomainRhsFE()->x = x;
392 pip_mng->getSkeletonRhsFE()->x = x;
395 simple->getDomainFEName(),
396 pip_mng->getDomainRhsFE());
398 CHKERR VecGhostUpdateBegin(f, ADD_VALUES, SCATTER_REVERSE);
399 CHKERR VecGhostUpdateEnd(f, ADD_VALUES, SCATTER_REVERSE);
400 CHKERR VecAssemblyBegin(f);
404 CHKERR VecNorm(f, NORM_2, &fnrm);
405 MOFEM_LOG_C(
"AT", Sev::inform,
"Residual %3.4e", fnrm);
407 constexpr double eps = 1e-8;
410 "Residual norm larger than accepted");
415 auto calculate_error = [&]() {
419 auto &domain_rhs = pip_mng->getOpDomainRhsPipeline();
425 auto u_grad_ptr = boost::make_shared<MatrixDouble>();
426 auto flux_val_ptr = boost::make_shared<MatrixDouble>();
427 auto div_val_ptr = boost::make_shared<VectorDouble>();
428 auto source_ptr = boost::make_shared<VectorDouble>();
430 domain_rhs.push_back(
432 domain_rhs.push_back(
435 "BROKEN", div_val_ptr));
436 auto source = [&](
const double x,
const double y,
437 const double z)
constexpr {
return -1; };
440 enum { DIV, GRAD, LAST };
443 domain_rhs.push_back(
446 u_grad_ptr, mpi_vec, GRAD, flux_val_ptr));
449 simple->getDomainFEName(),
450 pip_mng->getDomainRhsFE());
451 CHKERR VecAssemblyBegin(mpi_vec);
452 CHKERR VecAssemblyEnd(mpi_vec);
455 const double *error_ind;
456 CHKERR VecGetArrayRead(mpi_vec, &error_ind);
458 <<
"Approximation error ||div flux - source||: "
459 << std::sqrt(error_ind[DIV]);
460 MOFEM_LOG(
"AT", Sev::inform) <<
"Approximation error ||grad-flux||: "
461 << std::sqrt(error_ind[GRAD]);
462 CHKERR VecRestoreArrayRead(mpi_vec, &error_ind);
468 auto get_post_proc_fe = [&]() {
471 auto post_proc_fe = boost::make_shared<PostProcEle>(m_field);
476 ForcesAndSourcesCore::UserDataOperator::AdjCache>());
477 post_proc_fe->getOpPtrVector().push_back(op_loop_side);
480 op_loop_side->getOpPtrVector(), {HDIV});
481 auto u_vec_ptr = boost::make_shared<VectorDouble>();
482 auto flux_mat_ptr = boost::make_shared<MatrixDouble>();
483 op_loop_side->getOpPtrVector().push_back(
485 op_loop_side->getOpPtrVector().push_back(
487 op_loop_side->getOpPtrVector().push_back(
491 post_proc_fe->getPostProcMesh(),
493 post_proc_fe->getMapGaussPts(),
497 {{
"BROKEN", flux_mat_ptr}},
506 auto post_proc_fe = get_post_proc_fe();
508 simple->getBoundaryFEName(), post_proc_fe);
509 CHKERR post_proc_fe->writeFile(
"out_result.h5m");
512 CHKERR check_residual(x, f);
537 CHKERR KSPSetFromOptions(ksp);
539 CHKERR KSPGetPC(ksp, &pc);
541 PetscBool is_pcfs = PETSC_FALSE;
542 PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
545 MOFEM_LOG(
"AT", Sev::inform) <<
"Setup Schur pc";
547 auto create_sub_dm = [&]() {
550 auto create_dm = [&](
552 std::string problem_name,
553 std::vector<std::string> fe_names,
554 std::vector<std::string> fields,
560 auto create_dm_imp = [&]() {
564 for (
auto fe : fe_names) {
568 for (
auto field : fields) {
577 "Error in creating schurDM. It is possible that schurDM is "
582 auto schur_dm = create_dm(
586 {
simple->getDomainFEName(),
simple->getSkeletonFEName()},
592 auto block_dm = create_dm(
596 {
simple->getDomainFEName(),
simple->getSkeletonFEName()},
602 return std::make_tuple(schur_dm, block_dm);
605 auto get_nested_mat_data = [&](
auto schur_dm,
auto block_dm) {
613 simple->getDomainFEName(),
617 {
"BROKEN",
"BROKEN"},
628 simple->getSkeletonFEName(),
632 {
"BROKEN",
"HYBRID"}, {
"HYBRID",
"BROKEN"}
644 {schur_dm, block_dm}, block_mat_data,
646 {
"BROKEN",
"U"}, {
nullptr,
nullptr}, true
651 auto set_ops = [&](
auto schur_dm) {
656 boost::shared_ptr<BlockStructure> block_data;
660 pip_mng->getOpDomainLhsPipeline().push_front(
662 pip_mng->getOpDomainLhsPipeline().push_back(
670 auto pre_proc_schur_lhs_ptr = boost::make_shared<FEMethod>();
671 auto post_proc_schur_lhs_ptr = boost::make_shared<FEMethod>();
673 pre_proc_schur_lhs_ptr->preProcessHook = [
this]() {
676 MOFEM_LOG(
"AT", Sev::verbose) <<
"Lhs Assemble Begin";
680 post_proc_schur_lhs_ptr->postProcessHook = [
this, ao_up,
681 post_proc_schur_lhs_ptr]() {
683 MOFEM_LOG(
"AT", Sev::verbose) <<
"Lhs Assemble End";
686 CHKERR MatAssemblyBegin(S, MAT_FINAL_ASSEMBLY);
687 CHKERR MatAssemblyEnd(S, MAT_FINAL_ASSEMBLY);
689 auto S_from_block =
matDuplicate(S, MAT_SHARE_NONZERO_PATTERN);
692 S_from_block, {
"BROKEN",
"U"},
693 {nullptr, nullptr}, ao_up);
694 CHKERR MatAssemblyBegin(S_from_block, MAT_FINAL_ASSEMBLY);
695 CHKERR MatAssemblyEnd(S_from_block, MAT_FINAL_ASSEMBLY);
696 CHKERR MatAYPX(S_from_block, -1, S, DIFFERENT_NONZERO_PATTERN);
698 CHKERR MatNorm(S_from_block, NORM_FROBENIUS, &norm);
699 MOFEM_LOG(
"AT", Sev::inform) <<
"Norm of difference: " << norm;
703 "Norm of difference between Schur and block matrix is larger "
708 {
"BROKEN",
"U"}, {nullptr, nullptr}, ao_up);
709 CHKERR MatAssemblyBegin(S, MAT_FINAL_ASSEMBLY);
710 CHKERR MatAssemblyEnd(S, MAT_FINAL_ASSEMBLY);
713 MOFEM_LOG(
"AT", Sev::verbose) <<
"Lhs Assemble Finish";
718 ksp_ctx_ptr->getPreProcSetOperators().push_front(pre_proc_schur_lhs_ptr);
719 ksp_ctx_ptr->getPostProcSetOperators().push_back(post_proc_schur_lhs_ptr);
724 auto set_pc = [&](
auto pc,
auto block_dm) {
726 auto block_is =
getDMSubData(block_dm)->getSmartRowIs();
727 CHKERR PCFieldSplitSetIS(pc, NULL, block_is);
728 CHKERR PCFieldSplitSetSchurPre(pc, PC_FIELDSPLIT_SCHUR_PRE_USER, S);
734 auto [schur_dm, block_dm] = create_sub_dm();
736 auto nested_mat_data = get_nested_mat_data(schur_dm, block_dm);
740 CHKERR MatSetDM(S, PETSC_NULLPTR);
744 CHKERR MatSetBlockSize(S, bs);
747 CHKERR set_pc(pc, block_dm);
749 CHKERR KSPGetDM(ksp, &solver_dm);
751 CHKERR DMSetMatType(solver_dm, MATSHELL);
753 auto get_pc = [](
auto ksp) {
755 CHKERR KSPGetPC(ksp, &pc_raw);
759 auto set_diagonal_pc = [&](
auto pc) {
765 CHKERR PCSetOperators(pc, A, P);
769 CHKERR PCFieldSplitSchurGetSubKSP(pc, PETSC_NULLPTR, &subksp);
776 auto set_mg_for_schur_complement = [&](
auto pc,
auto schur_dm,
auto S) {
780 CHKERR PCFieldSplitSchurGetSubKSP(pc, PETSC_NULLPTR, &subksp);
781 auto subpc = get_pc(subksp[1]);
783 auto set_pc_p_mg = [](
auto dm,
auto pc,
auto S) {
786 PetscBool same = PETSC_FALSE;
787 PetscObjectTypeCompare((PetscObject)pc, PCMG, &same);
789 MOFEM_LOG(
"TIMER", Sev::inform) <<
"Set up MG";
792 CHKERR PCSetFromOptions(pc);
797 PetscBool same = PETSC_FALSE;
798 PetscObjectTypeCompare((PetscObject)subpc, PCKSP, &same);
800 CHKERR PCSetFromOptions(subpc);
802 CHKERR PCKSPGetKSP(subpc, &inner_ksp);
803 CHKERR KSPSetFromOptions(inner_ksp);
805 CHKERR KSPGetPC(inner_ksp, &inner_pc);
806 CHKERR PCSetFromOptions(inner_pc);
807 CHKERR set_pc_p_mg(schur_dm, inner_pc, S);
816 CHKERR set_diagonal_pc(pc);
817 CHKERR set_mg_for_schur_complement(pc, schur_dm, S);
822 "PC is not set to PCFIELDSPLIT");
827boost::shared_ptr<SetUpSchur>
829 return boost::shared_ptr<SetUpSchur>(
new SetUpSchurImpl(m_field));
#define MOFEM_LOG_C(channel, severity, format,...)
void simple(double P1[], double P2[], double P3[], double c[], const int N)
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpSource< 1, FIELD_DIM > OpDomainSource
ElementsAndOps< SPACE_DIM >::BoundaryEle BoundaryEle
ElementsAndOps< SPACE_DIM >::DomainEle DomainEle
[Define dimension]
#define CATCH_ERRORS
Catch errors.
FieldApproximationBase
approximation base
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base nme:nme847.
@ AINSWORTH_BERNSTEIN_BEZIER_BASE
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
FieldSpace
approximation spaces
@ L2
field with C-1 continuity
@ HCURL
field with continuous tangents
@ HDIV
field with continuous normal traction
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
@ MOFEM_ATOM_TEST_INVALID
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
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.
MoFEMErrorCode DMRegister_MGViaApproxOrders(const char sname[])
Register DM for Multi-Grid via approximation orders.
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.
PetscErrorCode DMMoFEMAddSubFieldCol(DM dm, const char field_name[])
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.
#define NBFACETRI_L2(P)
Number of base functions on triangle for L2 space.
#define NBEDGE_L2(P)
Number of base functions on edge from L2 space.
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMixDivTimesScalar< 2 > OpHdivU
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
implementation of Data Operators for Forces and Sources
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 DMMoFEMGetBlocMatData(DM dm, boost::shared_ptr< BlockStructure > &)
Get data for block mat.
MoFEMErrorCode setSchurA00MatSolvePC(SmartPetscObj< PC > pc)
Set PC for A00 block.
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 createVectorMPI(MPI_Comm comm, PetscInt n, PetscInt N)
Create MPI Vector.
auto getDMKspCtx(DM dm)
Get KSP context data structure used by DM.
auto createDMHybridisedL2Matrix(DM dm)
Get smart hybridised L2 matrix from DM.
auto getDMSubData(DM dm)
Get sub problem data structure.
MoFEMErrorCode PCMGSetUpViaApproxOrders(PC pc, boost::shared_ptr< PCMGSetUpViaApproxOrdersCtx > ctx, int verb)
Function build MG structure.
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)
SmartPetscObj< Mat > matDuplicate(Mat mat, MatDuplicateOption op)
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.
MoFEMErrorCode assembleBlockMatSchur(MoFEM::Interface &m_field, Mat B, Mat S, std::vector< std::string > fields_name, std::vector< boost::shared_ptr< Range > > field_ents, SmartPetscObj< AO > ao)
Assemble Schur matrix.
OpSchurAssembleBase * createOpSchurAssembleBegin()
auto createDMBlockMat(DM dm)
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
#define EXECUTABLE_DIMENSION
PipelineManager::ElementsAndOpsByDim< SPACE_DIM >::FaceSideEle EleOnSide
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)
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpMixDivTimesU< 3, 1, 2 > OpHDivH
Integrate Rhs div flux base times temperature (T)
Add operators pushing bases from local to physical configuration.
Simple interface for fast problem set-up.
MoFEMErrorCode removeSideDOFs(const std::string problem_name, const std::string block_name, const std::string field_name, int bridge_dim, int lo, int hi, bool is_distributed_mesh=true)
Remove side DOFs.
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.
base operator to do operations at Gauss Pt. level
Deprecated interface functions.
Data on single entity (This is passed as argument to DataOperator::doWork)
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.
Operator for broken loop side.
Get norm of input VectorDouble for Tensor0.
Get norm of input MatrixDouble for Tensor1.
Calculate tenor field using vectorial base, i.e. Hdiv/Hcurl.
Get vector field for H-div approximation.
Calculate divergence of vector field.
Get field gradients at integration pts for scalar field rank 0, i.e. vector field.
Get value at integration points for scalar field.
Get values at integration pts for tensor field rank 1, i.e. vector field.
Get values from scalar function at integration points and save them to VectorDouble for Tensor0.
Element used to execute operators on side of the element.
Post post-proc data at points from hash maps.
PipelineManager interface.
Simple interface for fast problem set-up.
MoFEMErrorCode getOptions()
get options
intrusive_ptr for managing petsc objects
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
virtual ~SetUpSchurImpl()=default
SetUpSchurImpl(MoFEM::Interface &m_field)
MoFEMErrorCode setUp(SmartPetscObj< KSP >)
MoFEM::Interface & mField
[Push operators to pipeline]
virtual MoFEMErrorCode setUp(SmartPetscObj< KSP >)=0
virtual ~SetUpSchur()=default
static boost::shared_ptr< SetUpSchur > createSetUpSchur(MoFEM::Interface &m_field)
constexpr AssemblyType AT
constexpr IntegrationType IT
constexpr AssemblyType BlockAssemblyType
BoundaryEle::UserDataOperator BdyEleOp