v0.14.0
Classes | Typedefs | Functions | Variables
scalar_check_approximation.cpp File Reference
#include <MoFEM.hpp>

Go to the source code of this file.

Classes

struct  ApproxFunctionsImpl< DIM >
 
struct  ElementsAndOps< DIM >
 
struct  ApproxFunctionsImpl< 2 >
 
struct  ApproxFunctionsImpl< 3 >
 
struct  OpValsDiffVals
 
struct  OpCheckValsDiffVals
 

Typedefs

using DomainEle = PipelineManager::ElementsAndOpsByDim< SPACE_DIM >::DomainEle
 
using BoundaryEle = PipelineManager::ElementsAndOpsByDim< SPACE_DIM >::BoundaryEle
 
using EleOnSide = PipelineManager::ElementsAndOpsByDim< SPACE_DIM >::FaceSideEle
 
using EntData = EntitiesFieldData::EntData
 
using DomainEleOp = DomainEle::UserDataOperator
 
using ApproxFunctions = ApproxFunctionsImpl< SPACE_DIM >
 

Functions

int main (int argc, char *argv[])
 

Variables

static char help [] = "...\n\n"
 
static int approx_order = 4
 
constexpr int SPACE_DIM
 

Typedef Documentation

◆ ApproxFunctions

using ApproxFunctions = ApproxFunctionsImpl<SPACE_DIM>

Definition at line 96 of file scalar_check_approximation.cpp.

◆ BoundaryEle

using BoundaryEle = PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::BoundaryEle

Definition at line 26 of file scalar_check_approximation.cpp.

◆ DomainEle

using DomainEle = PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::DomainEle

Definition at line 24 of file scalar_check_approximation.cpp.

◆ DomainEleOp

using DomainEleOp = DomainEle::UserDataOperator

Definition at line 30 of file scalar_check_approximation.cpp.

◆ EleOnSide

using EleOnSide = PipelineManager::ElementsAndOpsByDim<SPACE_DIM>::FaceSideEle

Definition at line 27 of file scalar_check_approximation.cpp.

◆ EntData

using EntData = EntitiesFieldData::EntData
Examples
scalar_check_approximation.cpp.

Definition at line 29 of file scalar_check_approximation.cpp.

Function Documentation

◆ main()

int main ( int  argc,
char *  argv[] 
)
Examples
scalar_check_approximation.cpp.

Definition at line 284 of file scalar_check_approximation.cpp.

284  {
285 
286  MoFEM::Core::Initialize(&argc, &argv, (char *)0, help);
287 
288  try {
289 
290  DMType dm_name = "DMMOFEM";
291  CHKERR DMRegister_MoFEM(dm_name);
292 
293  moab::Core mb_instance;
294  moab::Interface &moab = mb_instance;
295 
296  // Add logging channel for example
297  auto core_log = logging::core::get();
298  core_log->add_sink(
299  LogManager::createSink(LogManager::getStrmWorld(), "AT"));
300  LogManager::setLog("AT");
301  MOFEM_LOG_TAG("AT", "atom_test");
302 
303  // Create MoFEM instance
304  MoFEM::Core core(moab);
305  MoFEM::Interface &m_field = core;
306 
307  Simple *simple = m_field.getInterface<Simple>();
308  PipelineManager *pipeline_mng = m_field.getInterface<PipelineManager>();
309  CHKERR simple->getOptions();
310 
311  simple->getAddBoundaryFE() = true;
312 
313  CHKERR simple->loadFile("", "");
314 
315  // Declare elements
316  enum bases {
317  AINSWORTH,
318  AINSWORTH_LOBATTO,
319  DEMKOWICZ,
320  BERNSTEIN,
321  LASBASETOP
322  };
323  const char *list_bases[] = {"ainsworth", "ainsworth_lobatto", "demkowicz",
324  "bernstein"};
325  PetscBool flg;
326  PetscInt choice_base_value = AINSWORTH;
327  CHKERR PetscOptionsGetEList(PETSC_NULL, NULL, "-base", list_bases,
328  LASBASETOP, &choice_base_value, &flg);
329 
330  if (flg != PETSC_TRUE)
331  SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "base not set");
332  FieldApproximationBase base = AINSWORTH_LEGENDRE_BASE;
333  if (choice_base_value == AINSWORTH)
334  base = AINSWORTH_LEGENDRE_BASE;
335  if (choice_base_value == AINSWORTH_LOBATTO)
336  base = AINSWORTH_LOBATTO_BASE;
337  else if (choice_base_value == DEMKOWICZ)
338  base = DEMKOWICZ_JACOBI_BASE;
339  else if (choice_base_value == BERNSTEIN)
340  base = AINSWORTH_BERNSTEIN_BEZIER_BASE;
341 
342  enum spaces { H1SPACE, L2SPACE, LASBASETSPACE };
343  const char *list_spaces[] = {"h1", "l2"};
344  PetscInt choice_space_value = H1SPACE;
345  CHKERR PetscOptionsGetEList(PETSC_NULL, NULL, "-space", list_spaces,
346  LASBASETSPACE, &choice_space_value, &flg);
347  if (flg != PETSC_TRUE)
348  SETERRQ(PETSC_COMM_SELF, MOFEM_IMPOSSIBLE_CASE, "space not set");
349  FieldSpace space = H1;
350  if (choice_space_value == H1SPACE)
351  space = H1;
352  else if (choice_space_value == L2SPACE)
353  space = L2;
354 
355  CHKERR PetscOptionsGetInt(PETSC_NULL, "", "-order", &approx_order,
356  PETSC_NULL);
357 
358  CHKERR simple->addDomainField("FIELD1", space, base, 1);
359  CHKERR simple->setFieldOrder("FIELD1", approx_order);
360 
361  Range edges, faces;
362  CHKERR moab.get_entities_by_dimension(0, 1, edges);
363  CHKERR moab.get_entities_by_dimension(0, 2, faces);
364 
365  if (choice_base_value != BERNSTEIN) {
366  Range rise_order;
367 
368  int i = 0;
369  for (auto e : edges) {
370  if (!(i % 2)) {
371  rise_order.insert(e);
372  }
373  ++i;
374  }
375 
376  for (auto f : faces) {
377  if (!(i % 3)) {
378  rise_order.insert(f);
379  }
380  ++i;
381  }
382 
383  Range rise_twice;
384  for (auto e : rise_order) {
385  if (!(i % 2)) {
386  rise_twice.insert(e);
387  }
388  ++i;
389  }
390 
391  CHKERR simple->setFieldOrder("FIELD1", approx_order + 1, &rise_order);
392 
393  CHKERR simple->setFieldOrder("FIELD1", approx_order + 2, &rise_twice);
394  }
395 
396  CHKERR simple->defineFiniteElements();
397 
398  auto volume_adj = [](moab::Interface &moab, const Field &field,
399  const EntFiniteElement &fe,
400  std::vector<EntityHandle> &adjacency) {
401  MoFEMFunctionBegin;
402  EntityHandle fe_ent = fe.getEnt();
403  switch (field.getSpace()) {
404  case H1:
405  CHKERR moab.get_connectivity(&fe_ent, 1, adjacency, true);
406  case HCURL:
407  CHKERR moab.get_adjacencies(&fe_ent, 1, 1, false, adjacency,
408  moab::Interface::UNION);
409  case HDIV:
410  case L2:
411  CHKERR moab.get_adjacencies(&fe_ent, 1, 2, false, adjacency,
412  moab::Interface::UNION);
413  adjacency.push_back(fe_ent);
414  // build side table
415  for (auto ent : adjacency)
416  fe.getSideNumberPtr(ent);
417  break;
418  case NOFIELD: {
419  CHKERR moab.get_entities_by_handle(field.getMeshset(), adjacency,
420  false);
421  for (auto ent : adjacency) {
422  const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
423  .insert(
424  boost::shared_ptr<SideNumber>(new SideNumber(ent, -1, 0, 0)));
425  }
426  } break;
427  default:
428  SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
429  "this field is not implemented for TRI finite element");
430  }
431 
432  MoFEMFunctionReturn(0);
433  };
434 
435  CHKERR m_field.modify_finite_element_adjacency_table(
436  simple->getDomainFEName(), MBTET, volume_adj);
437  CHKERR m_field.modify_finite_element_adjacency_table(
438  simple->getDomainFEName(), MBHEX, volume_adj);
439 
440  CHKERR simple->defineProblem(PETSC_TRUE);
441  CHKERR simple->buildFields();
442  CHKERR simple->buildFiniteElements();
443  CHKERR simple->buildProblem();
444 
445  auto dm = simple->getDM();
446 
447  VectorDouble vals;
448  MatrixDouble diff_vals;
449 
450  auto assemble_matrices_and_vectors = [&]() {
451  MoFEMFunctionBegin;
452 
453  using OpSource = FormsIntegrators<DomainEleOp>::Assembly<
454  PETSC>::LinearForm<GAUSS>::OpSource<1, 1>;
455 
456  CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
457  pipeline_mng->getOpDomainLhsPipeline(), {space});
458  CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
459  pipeline_mng->getOpDomainRhsPipeline(), {space});
460 
461  using OpMass = FormsIntegrators<DomainEleOp>::Assembly<
462  SCHUR>::BiLinearForm<GAUSS>::OpMass<1, 1>;
463 
464  pipeline_mng->getOpDomainLhsPipeline().push_back(
465  createOpSchurAssembleBegin());
466  pipeline_mng->getOpDomainLhsPipeline().push_back(new OpMass(
467  "FIELD1", "FIELD1", [](double, double, double) { return 1.; }));
468  pipeline_mng->getOpDomainLhsPipeline().push_back(
469  createOpSchurAssembleEnd({}, {}));
470 
471  pipeline_mng->getOpDomainRhsPipeline().push_back(
472  new OpSource("FIELD1", ApproxFunctions::fUn));
473 
474  auto integration_rule = [](int, int, int p_data) {
475  return 2 * p_data + 1;
476  };
477  CHKERR pipeline_mng->setDomainRhsIntegrationRule(integration_rule);
478  CHKERR pipeline_mng->setDomainLhsIntegrationRule(integration_rule);
479 
480  MoFEMFunctionReturn(0);
481  };
482 
483  auto solve_problem = [&] {
484  MoFEMFunctionBegin;
485  auto solver = pipeline_mng->createKSP();
486  CHKERR KSPSetFromOptions(solver);
487  CHKERR KSPSetUp(solver);
488 
489  auto dm = simple->getDM();
490  auto D = createDMVector(dm);
491  auto F = vectorDuplicate(D);
492 
493  CHKERR KSPSolve(solver, F, D);
494  CHKERR VecGhostUpdateBegin(D, INSERT_VALUES, SCATTER_FORWARD);
495  CHKERR VecGhostUpdateEnd(D, INSERT_VALUES, SCATTER_FORWARD);
496  CHKERR DMoFEMMeshToLocalVector(dm, D, INSERT_VALUES, SCATTER_REVERSE);
497 
498  MoFEMFunctionReturn(0);
499  };
500 
501  auto check_solution = [&] {
502  MoFEMFunctionBegin;
503 
504  auto ptr_values = boost::make_shared<VectorDouble>();
505  auto ptr_diff_vals = boost::make_shared<MatrixDouble>();
506 
507  pipeline_mng->getDomainLhsFE().reset();
508  pipeline_mng->getOpDomainRhsPipeline().clear();
509 
510  CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
511  pipeline_mng->getOpDomainRhsPipeline(), {space});
512 
513  pipeline_mng->getOpDomainRhsPipeline().push_back(
514  new OpValsDiffVals(vals, diff_vals, true));
515  pipeline_mng->getOpDomainRhsPipeline().push_back(
516  new OpCalculateScalarFieldValues("FIELD1", ptr_values));
517  pipeline_mng->getOpDomainRhsPipeline().push_back(
518  new OpCalculateScalarFieldGradient<SPACE_DIM>("FIELD1",
519  ptr_diff_vals));
520  pipeline_mng->getOpDomainRhsPipeline().push_back(new OpCheckValsDiffVals(
521  vals, diff_vals, ptr_values, ptr_diff_vals, true));
522 
523  CHKERR pipeline_mng->loopFiniteElements();
524 
525  MoFEMFunctionReturn(0);
526  };
527 
528  auto post_proc = [&] {
529  MoFEMFunctionBegin;
530 
531  using OpPPMap = OpPostProcMapInMoab<SPACE_DIM, SPACE_DIM>;
532 
533  auto get_domain_post_proc_fe = [&](auto post_proc_mesh_ptr) {
534  auto post_proc_fe =
535  boost::make_shared<PostProcBrokenMeshInMoabBaseCont<DomainEle>>(
536  m_field, post_proc_mesh_ptr);
537 
538  CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
539  post_proc_fe->getOpPtrVector(), {space});
540 
541  auto ptr_values = boost::make_shared<VectorDouble>();
542  auto ptr_diff_vals = boost::make_shared<MatrixDouble>();
543 
544  post_proc_fe->getOpPtrVector().push_back(
545  new OpCalculateScalarFieldValues("FIELD1", ptr_values));
546  post_proc_fe->getOpPtrVector().push_back(
547  new OpCalculateScalarFieldGradient<SPACE_DIM>("FIELD1",
548  ptr_diff_vals));
549 
550  post_proc_fe->getOpPtrVector().push_back(
551 
552  new OpPPMap(
553 
554  post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
555 
556  {{"FIELD1", ptr_values}},
557 
558  {{"FIELD1_GRAD", ptr_diff_vals}},
559 
560  {}, {})
561 
562  );
563  return post_proc_fe;
564  };
565 
566  auto get_bdy_post_proc_fe = [&](auto post_proc_mesh_ptr) {
567  auto bdy_post_proc_fe =
568  boost::make_shared<PostProcBrokenMeshInMoabBaseCont<BoundaryEle>>(
569  m_field, post_proc_mesh_ptr);
570 
571  auto op_loop_side = new OpLoopSide<EleOnSide>(
572  m_field, simple->getDomainFEName(), SPACE_DIM, Sev::noisy,
573  boost::make_shared<
574  ForcesAndSourcesCore::UserDataOperator::AdjCache>());
575 
576  auto ptr_values = boost::make_shared<VectorDouble>();
577  auto ptr_diff_vals = boost::make_shared<MatrixDouble>();
578 
579  // push operators to side element
580  CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
581  op_loop_side->getOpPtrVector(), {space});
582  op_loop_side->getOpPtrVector().push_back(
583  new OpCalculateScalarFieldValues("FIELD1", ptr_values));
584  op_loop_side->getOpPtrVector().push_back(
585  new OpCalculateScalarFieldGradient<SPACE_DIM>("FIELD1",
586  ptr_diff_vals));
587  // push op to boundary element
588  bdy_post_proc_fe->getOpPtrVector().push_back(op_loop_side);
589 
590  bdy_post_proc_fe->getOpPtrVector().push_back(
591 
592  new OpPPMap(
593 
594  bdy_post_proc_fe->getPostProcMesh(),
595  bdy_post_proc_fe->getMapGaussPts(),
596 
597  {{"FIELD1", ptr_values}},
598 
599  {{"FIELD1_GRAD", ptr_diff_vals}},
600 
601  {}, {})
602 
603  );
604 
605  return bdy_post_proc_fe;
606  };
607 
608  auto post_proc_mesh_ptr = boost::make_shared<moab::Core>();
609  auto post_proc_begin =
610  boost::make_shared<PostProcBrokenMeshInMoabBaseBegin>(
611  m_field, post_proc_mesh_ptr);
612  auto post_proc_end =
613  boost::make_shared<PostProcBrokenMeshInMoabBaseEnd>(
614  m_field, post_proc_mesh_ptr);
615  auto domain_post_proc_fe = get_domain_post_proc_fe(post_proc_mesh_ptr);
616  auto bdy_post_proc_fe = get_bdy_post_proc_fe(post_proc_mesh_ptr);
617 
618  CHKERR DMoFEMPreProcessFiniteElements(dm, post_proc_begin->getFEMethod());
619  CHKERR DMoFEMLoopFiniteElements(dm, simple->getDomainFEName(),
620  domain_post_proc_fe);
621  CHKERR DMoFEMLoopFiniteElements(dm, simple->getBoundaryFEName(),
622  bdy_post_proc_fe);
623  CHKERR DMoFEMPostProcessFiniteElements(dm, post_proc_end->getFEMethod());
624  CHKERR post_proc_end->writeFile("out_post_proc.h5m");
625 
626  MoFEMFunctionReturn(0);
627  };
628 
629  CHKERR assemble_matrices_and_vectors();
630  CHKERR solve_problem();
631  CHKERR check_solution();
632  CHKERR post_proc();
633  }
634  CATCH_ERRORS;
635 
636  CHKERR MoFEM::Core::Finalize();
637 }

Variable Documentation

◆ approx_order

int approx_order = 4
static

Definition at line 15 of file scalar_check_approximation.cpp.

◆ help

char help[] = "...\n\n"
static
Examples
scalar_check_approximation.cpp.

Definition at line 13 of file scalar_check_approximation.cpp.

◆ SPACE_DIM

constexpr int SPACE_DIM
constexpr
Initial value:
=
EXECUTABLE_DIMENSION
Examples
scalar_check_approximation.cpp.

Definition at line 21 of file scalar_check_approximation.cpp.

MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition: UnknownInterface.hpp:93
MoFEM::CoreInterface::modify_finite_element_adjacency_table
virtual MoFEMErrorCode modify_finite_element_adjacency_table(const std::string &fe_name, const EntityType type, ElementAdjacencyFunct function)=0
modify finite element table, only for advanced user
help
static char help[]
Definition: scalar_check_approximation.cpp:13
MoFEM::ForcesAndSourcesCore::UserDataOperator::AdjCache
std::map< EntityHandle, std::vector< boost::weak_ptr< NumeredEntFiniteElement > >> AdjCache
Definition: ForcesAndSourcesCore.hpp:904
EXECUTABLE_DIMENSION
#define EXECUTABLE_DIMENSION
Definition: plastic.cpp:13
MoFEM::CoreTmp< 0 >
Core (interface) class.
Definition: Core.hpp:82
H1
@ H1
continuous field
Definition: definitions.h:85
EntityHandle
SPACE_DIM
constexpr int SPACE_DIM
Definition: scalar_check_approximation.cpp:21
OpValsDiffVals
Definition: scalar_check_approximation.cpp:98
L2
@ L2
field with C-1 continuity
Definition: definitions.h:88
MoFEM::Types::MatrixDouble
UBlasMatrix< double > MatrixDouble
Definition: Types.hpp:77
MoFEM::PETSC
@ PETSC
Definition: FormsIntegrators.hpp:105
MoFEM::PipelineManager
PipelineManager interface.
Definition: PipelineManager.hpp:24
MoFEM::DMoFEMMeshToLocalVector
PetscErrorCode DMoFEMMeshToLocalVector(DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode)
set local (or ghosted) vector values on mesh for partition only
Definition: DMMoFEM.cpp:523
MoFEM::CoreTmp< 0 >::Finalize
static MoFEMErrorCode Finalize()
Checks for options to be called at the conclusion of the program.
Definition: Core.cpp:112
MoFEM::EntFiniteElement
Finite element data for entity.
Definition: FEMultiIndices.hpp:501
ApproxFunctions::fUn
static FTensor::Tensor1< double, BASE_DIM > fUn(const double x, const double y, double z)
Definition: hcurl_check_approx_in_2d.cpp:46
MoFEM::Simple
Simple interface for fast problem set-up.
Definition: Simple.hpp:27
MOFEM_IMPOSSIBLE_CASE
@ MOFEM_IMPOSSIBLE_CASE
Definition: definitions.h:35
MoFEM::Field
Provide data structure for (tensor) field approximation.
Definition: FieldMultiIndices.hpp:51
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
MoFEM::OpCalculateScalarFieldGradient
Get field gradients at integration pts for scalar filed rank 0, i.e. vector field.
Definition: UserDataOperators.hpp:1293
MoFEM::Interface
DeprecatedCoreInterface Interface
Definition: Interface.hpp:2010
FieldSpace
FieldSpace
approximation spaces
Definition: definitions.h:82
MoFEM::createOpSchurAssembleEnd
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.
Definition: Schur.cpp:2186
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:548
MoFEM::createDMVector
auto createDMVector(DM dm)
Get smart vector from DM.
Definition: DMMoFEM.hpp:1099
OpMass
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMass< 1, SPACE_DIM > OpMass
[Only used with Hooke equation (linear material model)]
Definition: seepage.cpp:57
simple
void simple(double P1[], double P2[], double P3[], double c[], const int N)
Definition: acoustic.cpp:69
approx_order
static int approx_order
Definition: scalar_check_approximation.cpp:15
MoFEM::FormsIntegrators::Assembly
Assembly methods.
Definition: FormsIntegrators.hpp:317
SideNumber_multiIndex
multi_index_container< boost::shared_ptr< SideNumber >, indexed_by< ordered_unique< member< SideNumber, EntityHandle, &SideNumber::ent > >, ordered_non_unique< composite_key< SideNumber, const_mem_fun< SideNumber, EntityType, &SideNumber::getEntType >, member< SideNumber, signed char, &SideNumber::side_number > > > > > SideNumber_multiIndex
SideNumber_multiIndex for SideNumber.
Definition: RefEntsMultiIndices.hpp:101
OpPPMap
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
Definition: photon_diffusion.cpp:29
MoFEM::OpCalculateScalarFieldValues
Get value at integration points for scalar field.
Definition: UserDataOperators.hpp:82
MoFEM::DMRegister_MoFEM
PetscErrorCode DMRegister_MoFEM(const char sname[])
Register MoFEM problem.
Definition: DMMoFEM.cpp:43
MoFEM::createOpSchurAssembleBegin
OpSchurAssembleBase * createOpSchurAssembleBegin()
Definition: Schur.cpp:2181
AINSWORTH_LOBATTO_BASE
@ AINSWORTH_LOBATTO_BASE
Definition: definitions.h:62
MoFEM::DMoFEMPreProcessFiniteElements
PetscErrorCode DMoFEMPreProcessFiniteElements(DM dm, MoFEM::FEMethod *method)
execute finite element method for each element in dm (problem)
Definition: DMMoFEM.cpp:546
MoFEM::DMoFEMPostProcessFiniteElements
PetscErrorCode DMoFEMPostProcessFiniteElements(DM dm, MoFEM::FEMethod *method)
execute finite element method for each element in dm (problem)
Definition: DMMoFEM.cpp:556
MOFEM_LOG_TAG
#define MOFEM_LOG_TAG(channel, tag)
Tag channel.
Definition: LogManager.hpp:339
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
BiLinearForm
AINSWORTH_BERNSTEIN_BEZIER_BASE
@ AINSWORTH_BERNSTEIN_BEZIER_BASE
Definition: definitions.h:64
MoFEM::AddHOOps
Add operators pushing bases from local to physical configuration.
Definition: HODataOperators.hpp:413
integration_rule
auto integration_rule
Definition: free_surface.cpp:185
Range
MoFEM::SideNumber
keeps information about side number for the finite element
Definition: RefEntsMultiIndices.hpp:57
MoFEM::CoreTmp< 0 >::Initialize
static MoFEMErrorCode Initialize(int *argc, char ***args, const char file[], const char help[])
Initializes the MoFEM database PETSc, MOAB and MPI.
Definition: Core.cpp:72
MoFEM::vectorDuplicate
SmartPetscObj< Vec > vectorDuplicate(Vec vec)
Create duplicate vector of smart vector.
Definition: PetscSmartObj.hpp:221
CATCH_ERRORS
#define CATCH_ERRORS
Catch errors.
Definition: definitions.h:385
DEMKOWICZ_JACOBI_BASE
@ DEMKOWICZ_JACOBI_BASE
Definition: definitions.h:66
MoFEM::Core
CoreTmp< 0 > Core
Definition: Core.hpp:1148
HenckyOps::f
auto f
Definition: HenckyOps.hpp:15
AINSWORTH_LEGENDRE_BASE
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base .
Definition: definitions.h:60
HCURL
@ HCURL
field with continuous tangents
Definition: definitions.h:86
MoFEM::PetscOptionsGetEList
PetscErrorCode PetscOptionsGetEList(PetscOptions *, const char pre[], const char name[], const char *const *list, PetscInt next, PetscInt *value, PetscBool *set)
Definition: DeprecatedPetsc.hpp:203
FieldApproximationBase
FieldApproximationBase
approximation base
Definition: definitions.h:58
MoFEM::Types::VectorDouble
UBlasVector< double > VectorDouble
Definition: Types.hpp:68
ReactionDiffusionEquation::D
const double D
diffusivity
Definition: reaction_diffusion.cpp:20
OpCheckValsDiffVals
Definition: hcurl_check_approx_in_2d.cpp:161
MoFEM::DMoFEMLoopFiniteElements
PetscErrorCode DMoFEMLoopFiniteElements(DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
Executes FEMethod for finite elements in DM.
Definition: DMMoFEM.cpp:586
convert.int
int
Definition: convert.py:64
MoFEM::PetscOptionsGetInt
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
Definition: DeprecatedPetsc.hpp:142
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:429
HDIV
@ HDIV
field with continuous normal traction
Definition: definitions.h:87
MOFEM_NOT_IMPLEMENTED
@ MOFEM_NOT_IMPLEMENTED
Definition: definitions.h:32
MoFEM::SCHUR
@ SCHUR
Definition: FormsIntegrators.hpp:106
MoFEM::OpLoopSide
Element used to execute operators on side of the element.
Definition: ForcesAndSourcesCore.hpp:1290
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359
F
@ F
Definition: free_surface.cpp:394
NOFIELD
@ NOFIELD
scalar or vector of scalars describe (no true field)
Definition: definitions.h:84
MoFEM::OpPostProcMapInMoab
Post post-proc data at points from hash maps.
Definition: PostProcBrokenMeshInMoabBase.hpp:698
Generated by Doxygen 1.8.17 and hosted at University of Glasgow