MoFEM::Simple Struct Reference

Simple interface for fast problem set-up. More...

#include <src/interfaces/Simple.hpp>

Inheritance diagram for MoFEM::Simple:

Collaboration diagram for MoFEM::Simple:

Public Member Functions
MoFEMErrorCode	query_interface (const MOFEMuuid &uuid, UnknownInterface **iface) const
	Simple (const MoFEM::Core &core)
virtual	~Simple ()=default
MoFEMErrorCode	getOptions ()
	get options More...
MoFEMErrorCode	loadFile (const std::string options="PARALLEL=READ_PART;" "PARALLEL_RESOLVE_SHARED_ENTS;" "PARTITION=PARALLEL_PARTITION;", const std::string mesh_file_name="")
	Load mesh file. More...
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. More...
MoFEMErrorCode	addBoundaryField (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 boundary. More...
MoFEMErrorCode	addSkeletonField (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 skeleton. More...
MoFEMErrorCode	addDataField (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. More...
MoFEMErrorCode	removeDomainField (const std::string &name)
	Remove field form domain. More...
MoFEMErrorCode	removeBoundaryField (const std::string &name)
	Remove field form boundary. More...
MoFEMErrorCode	removeSkeletonField (const std::string &name)
	Remove field form skeleton. More...
MoFEMErrorCode	defineFiniteElements ()
	Define finite elements. More...
MoFEMErrorCode	defineProblem (const PetscBool is_partitioned=PETSC_TRUE)
	define problem More...
MoFEMErrorCode	setFieldOrder (const std::string field_name, const int order, const Range *ents=NULL)
	Set field order. More...
MoFEMErrorCode	buildFields ()
	Build fields. More...
MoFEMErrorCode	buildFiniteElements ()
	Build finite elements. More...
MoFEMErrorCode	setSkeletonAdjacency (int dim=-1)
	Set the skeleton adjacency object. More...
MoFEMErrorCode	buildProblem ()
	Build problem. More...
MoFEMErrorCode	setUp (const PetscBool is_partitioned=PETSC_TRUE)
	Setup problem. More...
MoFEMErrorCode	reSetUp ()
	Rebuild internal MoFEM data structures. More...
MoFEMErrorCode	getDM (DM *dm)
	Get DM. More...
SmartPetscObj< DM >	getDM ()
	Return smart DM object. More...
int	getDim () const
	Get the problem dimensio. More...
const std::string	getDomainFEName () const
	Get the Domain FE Name. More...
const std::string	getBoundaryFEName () const
	Get the Boundary FE Name. More...
const std::string	getSkeletonFEName () const
	Get the Skeleton FE Name. More...
const std::string	getProblemName () const
	Get the Problem Name. More...
std::string &	getDomainFEName ()
	Get the Domain FE Name. More...
std::string &	getBoundaryFEName ()
	Get the Boundary FE Name. More...
std::string &	getSkeletonFEName ()
	Get the Skeleton FE Name. More...
std::string &	getProblemName ()
	Get the Problem Name. More...
std::vector< std::string > &	getOtherFiniteElements ()
	Get the Other Finite Elements. More...
Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (const MOFEMuuid &uuid, bool error_if_registration_failed=true)
	Register interface. More...
template<class IFACE , bool VERIFY = false>
MoFEMErrorCode	getInterface (const MOFEMuuid &uuid, IFACE *&iface) const
	Get interface by uuid and return reference to pointer of interface. More...
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface refernce to pointer of interface. More...
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface. More...
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface. More...
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface. More...
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface. More...
virtual	~UnknownInterface ()=default
virtual MoFEMErrorCode	getLibVersion (Version &version) const
	Get library version. More...
virtual const MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version) const
	Get database major version. More...
virtual MoFEMErrorCode	getInterfaceVersion (Version &version) const
	Get database major version. More...
template<>
MoFEMErrorCode	getInterface (const MOFEMuuid &uuid, UnknownInterface *&iface) const

Private Member Functions
template<int DIM = -1>
MoFEMErrorCode	setSkeletonAdjacency ()
template<>
MoFEMErrorCode	setSkeletonAdjacency ()
template<>
MoFEMErrorCode	setSkeletonAdjacency ()
template<>
MoFEMErrorCode	setSkeletonAdjacency ()

Private Attributes
MoFEM::Core &	cOre
const BitRefLevel	bitLevel
	BitRefLevel of the probelm. More...
PetscLogEvent	MOFEM_EVENT_SimpleLoadMesh
PetscLogEvent	MOFEM_EVENT_SimpleBuildFields
PetscLogEvent	MOFEM_EVENT_SimpleBuildFiniteElements
PetscLogEvent	MOFEM_EVENT_SimpleBuildProblem
PetscLogEvent	MOFEM_EVENT_SimpleKSPSolve
EntityHandle	meshSet
	domain meshset More...
EntityHandle	boundaryMeshset
	meshset with boundary More...
std::vector< std::string >	domainFields
	domain fields More...
std::vector< std::string >	boundaryFields
	boundary fields More...
std::vector< std::string >	skeletonFields
	fields on the skeleton More...
std::vector< std::string >	dataFields
	Data fields. More...
std::vector< std::string >	noFieldFields
	NOFIELD field name. More...
std::vector< std::string >	noFieldDataFields
	NOFIELD field name. More...
std::multimap< std::string, std::pair< int, Range > >	fieldsOrder
	fields order More...
std::string	nameOfProblem
	problem name More...
std::string	domainFE
	domain finite element More...
std::string	boundaryFE
	boundary finite element More...
std::string	skeletonFE
	skeleton finite element More...
std::vector< std::string >	otherFEs
	Other finite elements. More...
char	meshFileName [255]
	mesh file name More...
int	dIm
	dimension of problem More...
SmartPetscObj< DM >	dM
	Discrete manager (interface to PETSc/MoFEM functions) More...

Additional Inherited Members
Protected Member Functions inherited from MoFEM::UnknownInterface
boost::typeindex::type_index	getClassIdx (const MOFEMuuid &uid) const
	Get type name for interface Id. More...
MOFEMuuid	getUId (const boost::typeindex::type_index &class_idx) const
	Get interface Id for class name. More...

Detailed Description

Simple interface for fast problem set-up.

Examples

basic_approx.cpp, basic_elastic.cpp, basic_helmholtz.cpp, basic_plastic.cpp, basic_poisson.cpp, basic_radiation.cpp, boundary_marker.cpp, continuity_check_on_skeleton_with_simple_2d.cpp, field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hdiv_divergence_operator.cpp, hello_world.cpp, loop_entities.cpp, mesh_smoothing.cpp, reaction_diffusion_equation.cpp, scalar_check_approximation_2d.cpp, second_moment_of_inertia.cpp, simple_elasticity.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 36 of file Simple.hpp.

Constructor & Destructor Documentation

Simple()

MoFEM::Simple::Simple

(

const MoFEM::Core &

core

)

Definition at line 187 of file Simple.cpp.

    : cOre(const_cast<Core &>(core)), bitLevel(BitRefLevel().set(0)),
      meshSet(0), boundaryMeshset(0), nameOfProblem("SimpleProblem"),
      domainFE("dFE"), boundaryFE("bFE"), skeletonFE("sFE"), dIm(-1) {
  PetscLogEventRegister("LoadMesh", 0, &MOFEM_EVENT_SimpleLoadMesh);
  PetscLogEventRegister("buildFields", 0, &MOFEM_EVENT_SimpleBuildFields);
  PetscLogEventRegister("buildFiniteElements", 0,
                        &MOFEM_EVENT_SimpleBuildFiniteElements);
  PetscLogEventRegister("SimpleSetUp", 0, &MOFEM_EVENT_SimpleBuildProblem);
  PetscLogEventRegister("SimpleKSPSolve", 0, &MOFEM_EVENT_SimpleKSPSolve);
  strcpy(meshFileName, "mesh.h5m");
}

~Simple()

virtual MoFEM::Simple::~Simple ( )

virtualdefault

Member Function Documentation

addBoundaryField()

MoFEMErrorCode MoFEM::Simple::addBoundaryField	(	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 boundary.

Parameters

name	name of the filed
space	space (L2,H1,Hdiv,Hcurl)
base	approximation base, see FieldApproximationBase
nb_of_coefficients	number of field coefficients
tag_type	type of the tag MB_TAG_DENSE or MB_TAG_SPARSE (DENSE is faster and uses less memory, SPARSE is more flexible if you define field on subdomains)
bh	if MF_EXCL throws error if field exits, MF_ZERO no error if field exist
verb	verbosity level

Returns

error code

Examples

hcurl_curl_operator.cpp, hdiv_divergence_operator.cpp, mesh_smoothing.cpp, and simple_interface.cpp.

Definition at line 276 of file Simple.cpp.

                                   {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  CHKERR m_field.add_field(name, space, base, nb_of_cooficients, tag_type, bh,
                           verb);
  boundaryFields.push_back(name);
  if (space == NOFIELD)
    SETERRQ(
        PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
        "NOFIELD space for boundary filed not implemented in Simple interface");
  MoFEMFunctionReturn(0);
}

addDataField()

MoFEMErrorCode MoFEM::Simple::addDataField	(	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.

Parameters

name	name of the filed
space	space (L2,H1,Hdiv,Hcurl)
base	approximation base, see FieldApproximationBase
nb_of_coefficients	number of field coefficients
tag_type	type of the tag MB_TAG_DENSE or MB_TAG_SPARSE (DENSE is faster and uses less memory, SPARSE is more flexible if you define field on subdomains)
bh	if MF_EXCL throws error if field exits, MF_ZERO no error if field exist
verb	verbosity level

Returns

error code

Examples

hcurl_curl_operator.cpp, and hdiv_divergence_operator.cpp.

Definition at line 313 of file Simple.cpp.

                               {

  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  CHKERR m_field.add_field(name, space, base, nb_of_cooficients, tag_type, bh,
                           verb);
  if (space == NOFIELD)
    noFieldDataFields.push_back(name);
  else
    dataFields.push_back(name);
  MoFEMFunctionReturn(0);
}

addDomainField()

MoFEMErrorCode MoFEM::Simple::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.

Parameters

name	name of the filed
space	space (L2,H1,Hdiv,Hcurl)
base	approximation base, see FieldApproximationBase
nb_of_coefficients	number of field coefficients
tag_type	type of the tag MB_TAG_DENSE or MB_TAG_SPARSE (DENSE is faster and uses less memory, SPARSE is more flexible if you define field on subdomains)
bh	if MF_EXCL throws error if field exits, MF_ZERO no error if field exist
verb	verbosity level

Returns

error code

Examples

continuity_check_on_skeleton_with_simple_2d.cpp, field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hdiv_divergence_operator.cpp, loop_entities.cpp, mesh_smoothing.cpp, reaction_diffusion_equation.cpp, scalar_check_approximation_2d.cpp, simple_elasticity.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 258 of file Simple.cpp.

                                 {

  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  CHKERR m_field.add_field(name, space, base, nb_of_cooficients, tag_type, bh,
                           verb);
  if (space == NOFIELD)
    noFieldFields.push_back(name);
  else
    domainFields.push_back(name);
  MoFEMFunctionReturn(0);
}

addSkeletonField()

MoFEMErrorCode MoFEM::Simple::addSkeletonField	(	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 skeleton.

Parameters

name	name of the filed
space	space (L2,H1,Hdiv,Hcurl)
base	approximation base, see FieldApproximationBase
nb_of_coefficients	number of field coefficients
tag_type	type of the tag MB_TAG_DENSE or MB_TAG_SPARSE (DENSE is faster and uses less memory, SPARSE is more flexible if you define field on subdomains)
bh	if MF_EXCL throws error if field exits, MF_ZERO no error if field exist
verb	verbosity level

Returns

error code

Examples

continuity_check_on_skeleton_with_simple_2d.cpp.

Definition at line 294 of file Simple.cpp.

                                   {

  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  CHKERR m_field.add_field(name, space, base, nb_of_cooficients, tag_type, bh,
                           verb);
  skeletonFields.push_back(name);
  if (space == NOFIELD)
    SETERRQ(
        PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
        "NOFIELD space for boundary filed not implemented in Simple interface");
  MoFEMFunctionReturn(0);
}

buildFields()

MoFEMErrorCode MoFEM::Simple::buildFields

(

)

Build fields.

Returns

error code

Examples

field_blas_set_vertex_dofs.cpp, mesh_smoothing.cpp, and simple_elasticity.cpp.

Definition at line 480 of file Simple.cpp.

                                   {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  PetscLogEventBegin(MOFEM_EVENT_SimpleBuildFields, 0, 0, 0, 0);

  auto get_skin = [&](auto meshset) {
    Range domain_ents;
    CHKERR m_field.get_moab().get_entities_by_dimension(meshset, dIm,
                                                        domain_ents, true);
    Skinner skin(&m_field.get_moab());
    Range domain_skin;
    CHKERR skin.find_skin(0, domain_ents, false, domain_skin);
    // filter not owned entities, those are not on boundary
    ParallelComm *pcomm =
        ParallelComm::get_pcomm(&m_field.get_moab(), MYPCOMM_INDEX);
    Range proc_domain_skin;
    CHKERR pcomm->filter_pstatus(domain_skin,
                                 PSTATUS_SHARED | PSTATUS_MULTISHARED,
                                 PSTATUS_NOT, -1, &proc_domain_skin);
    return proc_domain_skin;
  };

  auto create_boundary_meshset = [&](auto &&proc_domain_skin) {
    MoFEMFunctionBeginHot;
    // create boundary meshset
    if (boundaryMeshset != 0) {
      CHKERR m_field.get_moab().delete_entities(&boundaryMeshset, 1);
    }
    CHKERR m_field.get_moab().create_meshset(MESHSET_SET, boundaryMeshset);
    CHKERR m_field.get_moab().add_entities(boundaryMeshset, proc_domain_skin);
    for (int dd = 0; dd != dIm - 1; dd++) {
      Range adj;
      CHKERR m_field.get_moab().get_adjacencies(proc_domain_skin, dd, false,
                                                adj, moab::Interface::UNION);
      CHKERR m_field.get_moab().add_entities(boundaryMeshset, adj);
    }
    MoFEMFunctionReturnHot(0);
  };

  CHKERR create_boundary_meshset(get_skin(meshSet));

  auto comm_interface_ptr = m_field.getInterface<CommInterface>();
  auto bit_ref_ptr = m_field.getInterface<BitRefManager>();

  // Add entities to the fields
  auto add_ents_to_field = [&](auto meshset, auto dim, auto &fields) {
    MoFEMFunctionBeginHot;
    for (auto &field : fields) {
      CHKERR m_field.add_ents_to_field_by_dim(meshset, dim, field);
      CHKERR comm_interface_ptr->synchroniseFieldEntities(field, 0);
    }
    MoFEMFunctionReturnHot(0);
  };

  auto make_no_field_ents = [&](auto &fields) {
    MoFEMFunctionBeginHot;
    for (auto &field : fields) {
      std::array<double, 6> coords = {0, 0, 0, 0, 0, 0};
      CHKERR m_field.create_vertices_and_add_to_field(field, coords.data(), 2);
      CHKERR comm_interface_ptr->makeFieldEntitiesMultishared(field, 0);
      CHKERR bit_ref_ptr->setFieldEntitiesBitRefLevel(field, bitLevel);
    }
    MoFEMFunctionReturnHot(0);
  };

  CHKERR add_ents_to_field(meshSet, dIm, domainFields);
  CHKERR add_ents_to_field(meshSet, dIm, dataFields);
  CHKERR add_ents_to_field(boundaryMeshset, dIm - 1, boundaryFields);
  CHKERR add_ents_to_field(meshSet, dIm - 1, skeletonFields);
  CHKERR make_no_field_ents(noFieldFields);
  CHKERR make_no_field_ents(noFieldDataFields);

  // Set order
  auto set_order = [&](auto meshset, auto dim, auto &fields) {
    MoFEMFunctionBeginHot;
    for (auto &field : fields) {
      if (fieldsOrder.find(field) == fieldsOrder.end()) {
        SETERRQ1(PETSC_COMM_WORLD, MOFEM_INVALID_DATA,
                 "Order for field not set %s", field.c_str());
      }
      int dds = 0;
      const Field *field_ptr = m_field.get_field_structure(field);
      switch (field_ptr->getSpace()) {
      case L2:
        dds = dim;
        break;
      case HDIV:
        dds = 2;
        break;
      case HCURL:
        dds = 1;
        break;
      case H1:
        dds = 1;
        break;
      default:
        SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY,
                "Glasgow we have a problem");
      }

      auto set_order = [&](auto field, auto &ents) {
        MoFEMFunctionBegin;

        auto range = fieldsOrder.equal_range(field);
        for (auto o = range.first; o != range.second; ++o) {
          if (!o->second.second.empty())
            ents = intersect(ents, o->second.second);
          CHKERR m_field.set_field_order(ents, field, o->second.first);
        }

        MoFEMFunctionReturn(0);
      };

      if (field_ptr->getSpace() == H1) {
        if (field_ptr->getApproxBase() == AINSWORTH_BERNSTEIN_BEZIER_BASE) {
          Range ents;
          CHKERR m_field.get_field_entities_by_dimension(field, 0, ents);
          CHKERR set_order(field, ents);
        } else {
          CHKERR m_field.set_field_order(meshSet, MBVERTEX, field, 1);
        }
      }
      for (int dd = dds; dd <= dim; dd++) {
        Range ents;
        CHKERR m_field.get_field_entities_by_dimension(field, dd, ents);
        CHKERR set_order(field, ents);
      }
    }
    MoFEMFunctionReturnHot(0);
  };

  CHKERR set_order(meshSet, dIm, domainFields);
  CHKERR set_order(meshSet, dIm, dataFields);
  CHKERR set_order(meshSet, dIm - 1, boundaryFields);
  CHKERR set_order(meshSet, dIm - 1, skeletonFields);

  // Build fields
  CHKERR m_field.build_fields();
  PetscLogEventEnd(MOFEM_EVENT_SimpleBuildFields, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

buildFiniteElements()

MoFEMErrorCode MoFEM::Simple::buildFiniteElements

(

)

Build finite elements.

Returns

error code

Examples

mesh_smoothing.cpp, and simple_elasticity.cpp.

Definition at line 622 of file Simple.cpp.

                                           {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  PetscLogEventBegin(MOFEM_EVENT_SimpleBuildFiniteElements, 0, 0, 0, 0);
  // Add finite elements
  CHKERR m_field.add_ents_to_finite_element_by_dim(meshSet, dIm, domainFE,
                                                   true);
  CHKERR m_field.build_finite_elements(domainFE);
  if (!boundaryFields.empty()) {
    CHKERR m_field.add_ents_to_finite_element_by_dim(boundaryMeshset, dIm - 1,
                                                     boundaryFE, true);
    CHKERR m_field.build_finite_elements(boundaryFE);
  }
  if (!skeletonFields.empty()) {
    CHKERR m_field.add_ents_to_finite_element_by_dim(meshSet, dIm - 1,
                                                     skeletonFE, true);
    CHKERR m_field.build_finite_elements(skeletonFE);
  }
  for (std::vector<std::string>::iterator fit = otherFEs.begin();
       fit != otherFEs.end(); ++fit) {
    CHKERR m_field.build_finite_elements(*fit);
  }
  PetscLogEventEnd(MOFEM_EVENT_SimpleBuildFiniteElements, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

buildProblem()

MoFEMErrorCode MoFEM::Simple::buildProblem

(

)

Build problem.

Returns

error code

Examples

mesh_smoothing.cpp, and simple_elasticity.cpp.

Definition at line 648 of file Simple.cpp.

                                    {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  PetscLogEventBegin(MOFEM_EVENT_SimpleBuildProblem, 0, 0, 0, 0);
  CHKERR m_field.build_adjacencies(bitLevel);
  // Set problem by the DOFs on the fields rather that by adding DOFs on the
  // elements
  m_field.getInterface<ProblemsManager>()->buildProblemFromFields = PETSC_TRUE;
  CHKERR DMSetUp(dM);
  m_field.getInterface<ProblemsManager>()->buildProblemFromFields = PETSC_FALSE;
  PetscLogEventEnd(MOFEM_EVENT_SimpleBuildProblem, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

defineFiniteElements()

MoFEMErrorCode MoFEM::Simple::defineFiniteElements

(

)

Define finite elements.

Returns

Error code

Examples

mesh_smoothing.cpp, and simple_elasticity.cpp.

Definition at line 376 of file Simple.cpp.

                                            {
  Interface &m_field = cOre;
  MoFEMFunctionBeginHot;

  auto clear_rows_and_cols = [&](auto &fe_name) {
    MoFEMFunctionBeginHot;
    const FiniteElement_multiIndex *fe_ptr;
    CHKERR m_field.get_finite_elements(&fe_ptr);
    auto &fe_by_name = const_cast<FiniteElement_multiIndex *>(fe_ptr)
                           ->get<FiniteElement_name_mi_tag>();
    auto it_fe = fe_by_name.find(fe_name);
    if (it_fe != fe_by_name.end()) {

      if(!fe_by_name.modify(it_fe, FiniteElement_row_change_bit_reset()))
        SETERRQ(m_field.get_comm(), MOFEM_OPERATION_UNSUCCESSFUL,
                "modification unsuccessful");

      if(!fe_by_name.modify(it_fe, FiniteElement_col_change_bit_reset()))
        SETERRQ(m_field.get_comm(), MOFEM_OPERATION_UNSUCCESSFUL,
                "modification unsuccessful");
    }
    MoFEMFunctionReturnHot(0);
  };
  CHKERR clear_rows_and_cols(domainFE);
  CHKERR clear_rows_and_cols(boundaryFE);
  CHKERR clear_rows_and_cols(skeletonFE);

  // Define finite elements
  CHKERR m_field.add_finite_element(domainFE, MF_ZERO);

  auto add_fields = [&](auto &fe_name, auto &fields) {
    MoFEMFunctionBeginHot;
    for (auto &field : fields) {
      CHKERR m_field.modify_finite_element_add_field_row(fe_name, field);
      CHKERR m_field.modify_finite_element_add_field_col(fe_name, field);
      CHKERR m_field.modify_finite_element_add_field_data(fe_name, field);
    }
    MoFEMFunctionReturnHot(0);
  };

  auto add_data_fields = [&](auto &fe_name, auto &fields) {
    MoFEMFunctionBeginHot;
    for (auto &field : fields)
      CHKERR m_field.modify_finite_element_add_field_data(fe_name, field);
    MoFEMFunctionReturnHot(0);
  };

  CHKERR add_fields(domainFE, domainFields);
  CHKERR add_data_fields(domainFE, dataFields);
  CHKERR add_fields(domainFE, noFieldFields);
  CHKERR add_data_fields(domainFE, noFieldDataFields);

  if (!boundaryFields.empty()) {
    CHKERR m_field.add_finite_element(boundaryFE, MF_ZERO);
    CHKERR add_fields(boundaryFE, domainFields);
    CHKERR add_fields(boundaryFE, boundaryFields);
    CHKERR add_fields(boundaryFE, skeletonFields);
    CHKERR add_data_fields(boundaryFE, dataFields);
    CHKERR add_data_fields(boundaryFE, noFieldDataFields);
    CHKERR add_fields(boundaryFE, noFieldFields);
  }
  if (!skeletonFields.empty()) {
    CHKERR m_field.add_finite_element(skeletonFE, MF_ZERO);
    CHKERR add_fields(skeletonFE, domainFields);
    CHKERR add_fields(skeletonFE, boundaryFields);
    CHKERR add_fields(skeletonFE, skeletonFields);
    CHKERR add_data_fields(skeletonFE, dataFields);
    CHKERR add_data_fields(skeletonFE, noFieldDataFields);
    CHKERR add_fields(skeletonFE, noFieldFields);
  }
  MoFEMFunctionReturnHot(0);
}

defineProblem()

MoFEMErrorCode MoFEM::Simple::defineProblem

(

const PetscBool

is_partitioned = PETSC_TRUE

)

define problem

Returns

error code

Examples

mesh_smoothing.cpp, and simple_elasticity.cpp.

Definition at line 449 of file Simple.cpp.

                                                                   {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  // Create dm instance
  dM = createSmartDM(m_field.get_comm(), "DMMOFEM");
  // set dm data structure which created mofem data structures
  CHKERR DMMoFEMCreateMoFEM(dM, &m_field, nameOfProblem.c_str(), bitLevel);
  CHKERR DMSetFromOptions(dM);
  CHKERR DMMoFEMAddElement(dM, domainFE.c_str());
  if (!boundaryFields.empty()) {
    CHKERR DMMoFEMAddElement(dM, boundaryFE.c_str());
  }
  if (!skeletonFields.empty()) {
    CHKERR DMMoFEMAddElement(dM, skeletonFE.c_str());
  }
  for (std::vector<std::string>::iterator fit = otherFEs.begin();
       fit != otherFEs.end(); ++fit) {
    CHKERR DMMoFEMAddElement(dM, fit->c_str());
  }
  CHKERR DMMoFEMSetIsPartitioned(dM, is_partitioned);
  MoFEMFunctionReturn(0);
}

getBoundaryFEName() [1/2]

const std::string MoFEM::Simple::getBoundaryFEName

(

)

const

Get the Boundary FE Name.

Returns

const std::string

Examples

mesh_smoothing.cpp, and simple_interface.cpp.

Definition at line 285 of file Simple.hpp.

{ return boundaryFE; }

getBoundaryFEName() [2/2]

std::string& MoFEM::Simple::getBoundaryFEName

(

)

Get the Boundary FE Name.

Returns

std::string&

Definition at line 313 of file Simple.hpp.

{ return boundaryFE; }

getDim()

int MoFEM::Simple::getDim

(

)

const

Get the problem dimensio.

Problem dimension is determined by highest dimension of entities on the mesh.

Returns

int

Definition at line 271 of file Simple.hpp.

{ return dIm; }

getDM() [1/2]

MoFEMErrorCode MoFEM::Simple::getDM

(

DM *

dm

)

Get DM.

Parameters

dm	discrete manager

Returns

error code

Examples

continuity_check_on_skeleton_with_simple_2d.cpp, field_evaluator.cpp, hcurl_check_approx_in_2d.cpp, loop_entities.cpp, mesh_smoothing.cpp, reaction_diffusion_equation.cpp, scalar_check_approximation_2d.cpp, simple_elasticity.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 696 of file Simple.cpp.

                                   {
  MoFEMFunctionBegin;
  CHKERR PetscObjectReference(getPetscObject(dM.get()));
  *dm = dM.get();
  MoFEMFunctionReturn(0);
}

getDM() [2/2]

SmartPetscObj<DM> MoFEM::Simple::getDM

(

)

Return smart DM object.

{
   auto dm  = simple_interface->getDM();

   // ...

   // dm is automatically destroyed when out of the scope
}

Returns

SmartPetscObj<DM>

Definition at line 261 of file Simple.hpp.

{ return dM; }

getDomainFEName() [1/2]

const std::string MoFEM::Simple::getDomainFEName

(

)

const

Get the Domain FE Name.

Returns

const std::string

Examples

field_evaluator.cpp, mesh_smoothing.cpp, reaction_diffusion_equation.cpp, simple_elasticity.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 278 of file Simple.hpp.

{ return domainFE; }

getDomainFEName() [2/2]

std::string& MoFEM::Simple::getDomainFEName

(

)

Get the Domain FE Name.

Returns

std::string&

Definition at line 306 of file Simple.hpp.

{ return domainFE; }

getOptions()

MoFEMErrorCode MoFEM::Simple::getOptions

(

)

get options

Returns

error code

Examples

continuity_check_on_skeleton_with_simple_2d.cpp, field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hdiv_divergence_operator.cpp, loop_entities.cpp, mesh_smoothing.cpp, reaction_diffusion_equation.cpp, scalar_check_approximation_2d.cpp, simple_elasticity.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 200 of file Simple.cpp.

                                  {
  PetscBool flg = PETSC_TRUE;
  MoFEMFunctionBeginHot;
  ierr = PetscOptionsBegin(PETSC_COMM_WORLD, "", "Simple interface options",
                           "none");
  CHKERRG(ierr);
  ierr = PetscOptionsString("-file_name", "file name", "", "mesh.h5m",
                            meshFileName, 255, &flg);
  CHKERRG(ierr);
  ierr = PetscOptionsEnd();
  CHKERRG(ierr);
  MoFEMFunctionReturnHot(0);
}

getOtherFiniteElements()

std::vector<std::string>& MoFEM::Simple::getOtherFiniteElements

(

)

Get the Other Finite Elements.

User can create finite elements using directly core interface and and them to simple problem by this function

Returns

std::vector<std::string>&

Examples

mesh_smoothing.cpp.

Definition at line 337 of file Simple.hpp.

{ return otherFEs; }

getProblemName() [1/2]

const std::string MoFEM::Simple::getProblemName

(

)

const

Get the Problem Name.

Returns

const std::string

Examples

reaction_diffusion_equation.cpp.

Definition at line 299 of file Simple.hpp.

{ return nameOfProblem; }

getProblemName() [2/2]

std::string& MoFEM::Simple::getProblemName

(

)

Get the Problem Name.

Returns

std::string&

Definition at line 327 of file Simple.hpp.

{ return nameOfProblem; }

getSkeletonFEName() [1/2]

const std::string MoFEM::Simple::getSkeletonFEName

(

)

const

Get the Skeleton FE Name.

Returns

const std::string

Examples

continuity_check_on_skeleton_with_simple_2d.cpp.

Definition at line 292 of file Simple.hpp.

{ return skeletonFE; }

getSkeletonFEName() [2/2]

std::string& MoFEM::Simple::getSkeletonFEName

(

)

Get the Skeleton FE Name.

Returns

std::string&

Definition at line 320 of file Simple.hpp.

{ return skeletonFE; }

loadFile()

MoFEMErrorCode MoFEM::Simple::loadFile	(	const std::string	options = "PARALLEL=READ_PART;" "PARALLEL_RESOLVE_SHARED_ENTS;" "PARTITION=PARALLEL_PARTITION;",
		const std::string	mesh_file_name = ""
	)

Load mesh file.

Parameters

options	file load options
mesh_file_name	file name if not set default or set by command line is used.

Returns

error code

Examples

continuity_check_on_skeleton_with_simple_2d.cpp, field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hdiv_divergence_operator.cpp, loop_entities.cpp, mesh_smoothing.cpp, reaction_diffusion_equation.cpp, scalar_check_approximation_2d.cpp, simple_elasticity.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 214 of file Simple.cpp.

                                                                {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  PetscLogEventBegin(MOFEM_EVENT_SimpleLoadMesh, 0, 0, 0, 0);

  if (!mesh_file_name.empty())
    strcpy(meshFileName, mesh_file_name.c_str());

  // This is a case of distributed mesh and algebra. In that case each processor
  // keep only part of the problem.
  CHKERR m_field.get_moab().load_file(meshFileName, 0, options.c_str());
  CHKERR m_field.rebuild_database();
  // determine problem dimension
  if (dIm == -1) {
    int nb_ents_3d;
    CHKERR m_field.get_moab().get_number_entities_by_dimension(
        meshSet, 3, nb_ents_3d, true);
    if (nb_ents_3d > 0) {
      dIm = 3;
    } else {
      int nb_ents_2d;
      CHKERR m_field.get_moab().get_number_entities_by_dimension(
          meshSet, 2, nb_ents_2d, true);
      if (nb_ents_2d > 0) {
        dIm = 2;
      } else {
        dIm = 1;
      }
    }
  }
  Range ents;
  CHKERR m_field.get_moab().get_entities_by_dimension(meshSet, dIm, ents, true);
  CHKERR m_field.getInterface<BitRefManager>()->setBitRefLevel(ents, bitLevel,
                                                               false);
  ParallelComm *pcomm =
      ParallelComm::get_pcomm(&m_field.get_moab(), MYPCOMM_INDEX);
  if (pcomm == NULL)
    pcomm = new ParallelComm(&m_field.get_moab(), m_field.get_comm());
  PetscLogEventEnd(MOFEM_EVENT_SimpleLoadMesh, 0, 0, 0, 0);
  MoFEMFunctionReturn(0);
}

query_interface()

MoFEMErrorCode MoFEM::Simple::query_interface ( const MOFEMuuid &  uuid, UnknownInterface **  iface  ) const

virtual

Implements MoFEM::UnknownInterface.

Definition at line 22 of file Simple.cpp.

                                                                       {
  MoFEMFunctionBeginHot;
  *iface = NULL;
  if (uuid == IDD_MOFEMSimple) {
    *iface = const_cast<Simple *>(this);
    MoFEMFunctionReturnHot(0);
  }
  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "unknown interface");
  MoFEMFunctionReturnHot(0);
}

removeBoundaryField()

MoFEMErrorCode MoFEM::Simple::removeBoundaryField

(

const std::string &

name

)

Remove field form boundary.

Parameters

name

Returns

MoFEMErrorCode

Definition at line 346 of file Simple.cpp.

                                                                {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;

  auto remove_field_from_list = [&](auto &vec) {
    auto it = std::find(vec.begin(), vec.end(), name);
    if (it != vec.end())
      vec.erase(it);
  };

  remove_field_from_list(boundaryFields);

  MoFEMFunctionReturn(0);
}

removeDomainField()

MoFEMErrorCode MoFEM::Simple::removeDomainField

(

const std::string &

name

)

Remove field form domain.

Parameters

name

Returns

MoFEMErrorCode

Definition at line 330 of file Simple.cpp.

                                                              {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;

  auto remove_field_from_list = [&](auto &vec) {
    auto it = std::find(vec.begin(), vec.end(), name);
    if (it != vec.end())
      vec.erase(it);
  };

  remove_field_from_list(noFieldFields);
  remove_field_from_list(domainFields);

  MoFEMFunctionReturn(0);
}

removeSkeletonField()

MoFEMErrorCode MoFEM::Simple::removeSkeletonField

(

const std::string &

name

)

Remove field form skeleton.

Parameters

name

Returns

MoFEMErrorCode

Definition at line 361 of file Simple.cpp.

                                                                {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;

  auto remove_field_from_list = [&](auto &vec) {
    auto it = std::find(vec.begin(), vec.end(), name);
    if (it != vec.end())
      vec.erase(it);
  };

  remove_field_from_list(skeletonFields);

  MoFEMFunctionReturn(0);
}

reSetUp()

MoFEMErrorCode MoFEM::Simple::reSetUp

(

)

Rebuild internal MoFEM data structures.

Call this function after you add field or remove it.

Note

If you add field, or remove it, finite element and problem needs to be rebuild. However DM can remain the same.

Returns

MoFEMErrorCode

Definition at line 674 of file Simple.cpp.

                               {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;

  CHKERR defineFiniteElements();
  if (!skeletonFields.empty())
    CHKERR setSkeletonAdjacency();
  CHKERR buildFields();
  CHKERR buildFiniteElements();

  PetscLogEventBegin(MOFEM_EVENT_SimpleBuildProblem, 0, 0, 0, 0);
  CHKERR m_field.build_adjacencies(bitLevel);
  // Set problem by the DOFs on the fields rather that by adding DOFs on the
  // elements
  m_field.getInterface<ProblemsManager>()->buildProblemFromFields = PETSC_TRUE;
  CHKERR DMSetUp_MoFEM(dM);
  m_field.getInterface<ProblemsManager>()->buildProblemFromFields = PETSC_FALSE;
  PetscLogEventEnd(MOFEM_EVENT_SimpleBuildProblem, 0, 0, 0, 0);

  MoFEMFunctionReturn(0);
}

setFieldOrder()

MoFEMErrorCode MoFEM::Simple::setFieldOrder	(	const std::string	field_name,
		const int	order,
		const Range *	ents = NULL
	)

Set field order.

Parameters

std::field_name	field name
order	order
range	of entities to which order is set (If null it sat to all entities)

Returns

error code

Examples

continuity_check_on_skeleton_with_simple_2d.cpp, field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hdiv_divergence_operator.cpp, loop_entities.cpp, mesh_smoothing.cpp, reaction_diffusion_equation.cpp, scalar_check_approximation_2d.cpp, simple_elasticity.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 472 of file Simple.cpp.

                                                                         {
  MoFEMFunctionBeginHot;
  fieldsOrder.insert(
      {field_name, {order, ents == NULL ? Range() : Range(*ents)}});
  MoFEMFunctionReturnHot(0);
}

setSkeletonAdjacency() [1/5]

template<>

MoFEMErrorCode MoFEM::Simple::setSkeletonAdjacency ( )

private

Definition at line 41 of file Simple.cpp.

                                               {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;

  auto defaultSkeletonEdge = [&](moab::Interface &moab, const Field &field,
                                 const EntFiniteElement &fe,
                                 Range &adjacency) -> MoFEMErrorCode {
    MoFEMFunctionBegin;

    Range base_adj;
    CHKERR DefaultElementAdjacency::defaultEdge(moab, field, fe, adjacency);

    if (std::find(domainFields.begin(), domainFields.end(),
                  field.getName()) != domainFields.end()) {

      const EntityHandle fe_ent = fe.getEnt();
      Range bride_adjacency_edge, bride_adjacency;
      CHKERR moab.get_adjacencies(&fe_ent, 1, 2, false, bride_adjacency_edge);

      switch (field.getSpace()) {
      case H1:
        CHKERR moab.get_connectivity(bride_adjacency_edge, bride_adjacency,
                                     true);
      case L2:
      case HCURL:
      case HDIV:
        CHKERR moab.get_adjacencies(bride_adjacency_edge, 1, false,
                                    bride_adjacency, moab::Interface::UNION);
        bride_adjacency.merge(bride_adjacency_edge);
        break;
      case NOFIELD:
        break;
      default:
        SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                "this field is not implemented for TRI finite element");
      }

      bride_adjacency = subtract(bride_adjacency, adjacency);

      for (auto e : bride_adjacency)
        const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
            .insert(boost::shared_ptr<SideNumber>(new SideNumber(e, -1, 0, 0)));

      adjacency.merge(bride_adjacency);
    }

    MoFEMFunctionReturn(0);
  };

  CHKERR m_field.modify_finite_element_adjacency_table(skeletonFE, MBEDGE,
                                                       defaultSkeletonEdge);

  MoFEMFunctionReturn(0);
}

setSkeletonAdjacency() [2/5]

template<>

MoFEMErrorCode MoFEM::Simple::setSkeletonAdjacency ( )

private

Definition at line 97 of file Simple.cpp.

                                               {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;

  auto defaultSkeletonEdge = [&](moab::Interface &moab, const Field &field,
                                 const EntFiniteElement &fe,
                                 Range &adjacency) -> MoFEMErrorCode {
    MoFEMFunctionBegin;

    Range base_adj;
    CHKERR DefaultElementAdjacency::defaultFace(moab, field, fe, adjacency);

    if (std::find(domainFields.begin(), domainFields.end(),
                  field.getName()) != domainFields.end()) {

      const EntityHandle fe_ent = fe.getEnt();
      Range bride_adjacency_face, bride_adjacency;
      CHKERR moab.get_adjacencies(&fe_ent, 1, 3, false, bride_adjacency_face);

      switch (field.getSpace()) {
      case H1:
        CHKERR moab.get_connectivity(bride_adjacency_face, bride_adjacency,
                                     true);
      case HCURL:
        CHKERR moab.get_adjacencies(bride_adjacency_face, 1, false,
                                    bride_adjacency, moab::Interface::UNION);
      case L2:
      case HDIV:
        CHKERR moab.get_adjacencies(bride_adjacency_face, 2, false,
                                    bride_adjacency, moab::Interface::UNION);
        bride_adjacency.merge(bride_adjacency_face);
        break;
      case NOFIELD:
        break;
      default:
        SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
                "this field is not implemented for TRI finite element");
      }

      bride_adjacency = subtract(bride_adjacency, adjacency);

      for (auto e : bride_adjacency)
        const_cast<SideNumber_multiIndex &>(fe.getSideNumberTable())
            .insert(boost::shared_ptr<SideNumber>(new SideNumber(e, -1, 0, 0)));

      adjacency.merge(bride_adjacency);
    }

    MoFEMFunctionReturn(0);
  };

  CHKERR m_field.modify_finite_element_adjacency_table(skeletonFE, MBTRI,
                                                       defaultSkeletonEdge);
  CHKERR m_field.modify_finite_element_adjacency_table(skeletonFE, MBQUAD,
                                                       defaultSkeletonEdge);

  MoFEMFunctionReturn(0);
}

setSkeletonAdjacency() [3/5]

template<>

MoFEMErrorCode MoFEM::Simple::setSkeletonAdjacency ( )

private

Definition at line 157 of file Simple.cpp.

                                                {
  MoFEMFunctionBegin;
  switch (getDim()) {
  case 1:
    THROW_MESSAGE("Not implemented");
  case 2:
    return setSkeletonAdjacency<2>();
  case 3:
    return setSkeletonAdjacency<3>(); 
  default:
    THROW_MESSAGE("Not implemented");
  }
  MoFEMFunctionReturn(0);
}

setSkeletonAdjacency() [4/5]

MoFEMErrorCode MoFEM::Simple::setSkeletonAdjacency

(

int

dim = -1

)

Set the skeleton adjacency object.

Parameters

dim

Returns

MoFEMErrorCode

Definition at line 172 of file Simple.cpp.

                                                   {
  MoFEMFunctionBegin;
  if(dim == -1)
    dim = getDim();
  switch(dim) {
  case 2:
    return setSkeletonAdjacency<2>();
  case 3:
    return setSkeletonAdjacency<3>();
  default:
    SETERRQ(PETSC_COMM_WORLD, MOFEM_NOT_IMPLEMENTED, "Not implemented");
  }
  MoFEMFunctionReturn(0);
}

setSkeletonAdjacency() [5/5]

template<int DIM>

MoFEMErrorCode MoFEM::Simple::setSkeletonAdjacency ( )

private

Definition at line 35 of file Simple.cpp.

                                            {
  static_assert(DIM == 2 || DIM == 3, "not implemented");
  return MOFEM_NOT_IMPLEMENTED;
}

setUp()

MoFEMErrorCode MoFEM::Simple::setUp

(

const PetscBool

is_partitioned = PETSC_TRUE

)

Setup problem.

Returns

error code

Examples

continuity_check_on_skeleton_with_simple_2d.cpp, field_evaluator.cpp, hcurl_check_approx_in_2d.cpp, hcurl_curl_operator.cpp, hdiv_divergence_operator.cpp, loop_entities.cpp, reaction_diffusion_equation.cpp, scalar_check_approximation_2d.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 662 of file Simple.cpp.

                                                           {
  MoFEMFunctionBegin;
  CHKERR defineFiniteElements();
  if (!skeletonFields.empty())
    CHKERR setSkeletonAdjacency();
  CHKERR defineProblem(is_partitioned);
  CHKERR buildFields();
  CHKERR buildFiniteElements();
  CHKERR buildProblem();
  MoFEMFunctionReturn(0);
}

Member Data Documentation

bitLevel

const BitRefLevel MoFEM::Simple::bitLevel

private

BitRefLevel of the probelm.

Definition at line 342 of file Simple.hpp.

boundaryFE

std::string MoFEM::Simple::boundaryFE

private

boundary finite element

Definition at line 363 of file Simple.hpp.

boundaryFields

std::vector<std::string> MoFEM::Simple::boundaryFields

private

boundary fields

Definition at line 353 of file Simple.hpp.

boundaryMeshset

EntityHandle MoFEM::Simple::boundaryMeshset

private

meshset with boundary

Definition at line 351 of file Simple.hpp.

cOre

MoFEM::Core& MoFEM::Simple::cOre

private

Definition at line 340 of file Simple.hpp.

dataFields

std::vector<std::string> MoFEM::Simple::dataFields

private

Data fields.

Definition at line 355 of file Simple.hpp.

dIm

int MoFEM::Simple::dIm

private

dimension of problem

Definition at line 369 of file Simple.hpp.

dM

SmartPetscObj<DM> MoFEM::Simple::dM

private

Discrete manager (interface to PETSc/MoFEM functions)

Definition at line 372 of file Simple.hpp.

domainFE

std::string MoFEM::Simple::domainFE

private

domain finite element

Definition at line 362 of file Simple.hpp.

domainFields

std::vector<std::string> MoFEM::Simple::domainFields

private

domain fields

Definition at line 352 of file Simple.hpp.

fieldsOrder

std::multimap<std::string, std::pair<int, Range> > MoFEM::Simple::fieldsOrder

private

fields order

Definition at line 359 of file Simple.hpp.

meshFileName

char MoFEM::Simple::meshFileName[255]

private

mesh file name

Definition at line 368 of file Simple.hpp.

meshSet

EntityHandle MoFEM::Simple::meshSet

private

domain meshset

Definition at line 350 of file Simple.hpp.

MOFEM_EVENT_SimpleBuildFields

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleBuildFields

private

Definition at line 345 of file Simple.hpp.

MOFEM_EVENT_SimpleBuildFiniteElements

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleBuildFiniteElements

private

Definition at line 346 of file Simple.hpp.

MOFEM_EVENT_SimpleBuildProblem

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleBuildProblem

private

Definition at line 347 of file Simple.hpp.

MOFEM_EVENT_SimpleKSPSolve

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleKSPSolve

private

Definition at line 348 of file Simple.hpp.

MOFEM_EVENT_SimpleLoadMesh

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleLoadMesh

private

Definition at line 344 of file Simple.hpp.

nameOfProblem

std::string MoFEM::Simple::nameOfProblem

private

problem name

Definition at line 361 of file Simple.hpp.

noFieldDataFields

std::vector<std::string> MoFEM::Simple::noFieldDataFields

private

NOFIELD field name.

Definition at line 357 of file Simple.hpp.

noFieldFields

std::vector<std::string> MoFEM::Simple::noFieldFields

private

NOFIELD field name.

Definition at line 356 of file Simple.hpp.

otherFEs

std::vector<std::string> MoFEM::Simple::otherFEs

private

Other finite elements.

Definition at line 366 of file Simple.hpp.

skeletonFE

std::string MoFEM::Simple::skeletonFE

private

skeleton finite element

Definition at line 364 of file Simple.hpp.

skeletonFields

std::vector<std::string> MoFEM::Simple::skeletonFields

private

fields on the skeleton

Definition at line 354 of file Simple.hpp.

---

The documentation for this struct was generated from the following files:

• src/interfaces/Simple.hpp
• src/interfaces/impl/Simple.cpp