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)
	~Simple ()
	Destructor. More...
MoFEMErrorCode	getOptions ()
	get options More...
MoFEMErrorCode	loadFile (const std::string options="PARALLEL=READ_PART;" "PARALLEL_RESOLVE_SHARED_ENTS;" "PARTITION=PARALLEL_PARTITION;")
	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	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	buildProblem ()
	Build problem. More...
MoFEMErrorCode	setUp (const PetscBool is_partitioned=PETSC_TRUE)
	Setup problem. More...
MoFEMErrorCode	getDM (DM *dm)
	Get DM. More...
SmartPetscObj< DM >	getDM ()
	Return smart DM object. More...
int	getDim () const
const std::string	getDomainFEName () const
const std::string	getBoundaryFEName () const
const std::string	getSkeletonFEName () const
const std::string	getProblemName () const
std::string &	getDomainFEName ()
std::string &	getBoundaryFEName ()
std::string &	getSkeletonFEName ()
std::string &	getProblemName ()
std::vector< std::string > &	getOtherFiniteElements ()
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 ()
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

Public Attributes
MoFEM::Core &	cOre

Private Attributes
const BitRefLevel	bitLevel
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::map< 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

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

field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hello_world.cpp, loop_entities.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 36 of file Simple.hpp.

Constructor & Destructor Documentation

Simple()

MoFEM::Simple::Simple

(

const MoFEM::Core &

core

)

Definition at line 34 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()

MoFEM::Simple::~Simple

(

)

Destructor.

Definition at line 46 of file Simple.cpp.

{}

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

hello_world.cpp, mesh_smoothing.cpp, and simple_interface.cpp.

Definition at line 116 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);
  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

Definition at line 145 of file Simple.cpp.

                               {

  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  CHKERR m_field.add_field(name, space, base, nb_of_cooficients, tag_type, bh,
                           verb);
  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

field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hello_world.cpp, loop_entities.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 101 of file Simple.cpp.

                                 {

  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  CHKERR m_field.add_field(name, space, base, nb_of_cooficients, tag_type, bh,
                           verb);
  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

hello_world.cpp.

Definition at line 130 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);
  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 264 of file Simple.cpp.

                                   {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  PetscLogEventBegin(MOFEM_EVENT_SimpleBuildFields, 0, 0, 0, 0);
  // take skin
  {
    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);
    // 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);
    }
  }
  // Add entities to the fields
  for (unsigned int ff = 0; ff != domainFields.size(); ff++) {
    CHKERR m_field.add_ents_to_field_by_dim(meshSet, dIm, domainFields[ff]);
    CHKERR m_field.synchronise_field_entities(domainFields[ff], 0);
  }
  for (unsigned int ff = 0; ff != dataFields.size(); ff++) {
    CHKERR m_field.add_ents_to_field_by_dim(meshSet, dIm, dataFields[ff]);
    CHKERR m_field.synchronise_field_entities(dataFields[ff], 0);
  }
  for (unsigned int ff = 0; ff != boundaryFields.size(); ff++) {
    CHKERR m_field.add_ents_to_field_by_dim(boundaryMeshset, dIm - 1,
                                            boundaryFields[ff]);
    CHKERR m_field.synchronise_field_entities(boundaryFields[ff], 0);
  }
  for (unsigned int ff = 0; ff != skeletonFields.size(); ff++) {
    CHKERR m_field.add_ents_to_field_by_dim(meshSet, dIm - 1,
                                            skeletonFields[ff]);
    CHKERR m_field.synchronise_field_entities(skeletonFields[ff], 0);
  }
  // Set order
  for (unsigned int ff = 0; ff != domainFields.size(); ff++) {
    if (fieldsOrder.find(domainFields[ff]) == fieldsOrder.end()) {
      SETERRQ1(PETSC_COMM_WORLD, MOFEM_INVALID_DATA,
               "Order for field not set %s", domainFields[ff].c_str());
    }
    int dds = 0;
    const Field *field = m_field.get_field_structure(domainFields[ff]);
    switch (field->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,
              "Huston we have a problem");
    }
    if (field->getSpace() == H1) {
      CHKERR m_field.set_field_order(meshSet, MBVERTEX, domainFields[ff], 1);
    }
    for (int dd = dds; dd <= dIm; dd++) {
      Range ents;
      CHKERR m_field.get_field_entities_by_dimension(domainFields[ff], dd,
                                                     ents);
      if (!fieldsOrder.at(domainFields[ff]).second.empty()) {
        ents = intersect(ents, fieldsOrder.at(domainFields[ff]).second);
      }
      CHKERR m_field.set_field_order(ents, domainFields[ff],
                                     fieldsOrder.at(domainFields[ff]).first);
    }
  }
  // Set order to data fields
  for (unsigned int ff = 0; ff != dataFields.size(); ff++) {
    if (fieldsOrder.find(dataFields[ff]) == fieldsOrder.end()) {
      SETERRQ1(PETSC_COMM_WORLD, MOFEM_INVALID_DATA,
               "Order for field not set %s", dataFields[ff].c_str());
    }
    int dds = 0;
    const Field *field = m_field.get_field_structure(dataFields[ff]);
    switch (field->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,
              "Huston we have a problem");
    }
    if (field->getSpace() == H1) {
      CHKERR m_field.set_field_order(meshSet, MBVERTEX, dataFields[ff], 1);
    }
    for (int dd = dds; dd <= dIm; dd++) {
      Range ents;
      CHKERR m_field.get_field_entities_by_dimension(dataFields[ff], dd, ents);
      CHKERR m_field.set_field_order(ents, dataFields[ff],
                                     fieldsOrder.at(dataFields[ff]).first);
    }
  }
  // Set order to boundary
  for (unsigned int ff = 0; ff != boundaryFields.size(); ff++) {
    if (fieldsOrder.find(boundaryFields[ff]) == fieldsOrder.end()) {
      SETERRQ1(PETSC_COMM_WORLD, MOFEM_INVALID_DATA,
               "Order for field not set %s", boundaryFields[ff].c_str());
    }
    int dds = 0;
    const Field *field = m_field.get_field_structure(boundaryFields[ff]);
    switch (field->getSpace()) {
    case L2:
      dds = dIm - 1;
      break;
    case HDIV:
      dds = 2;
      break;
    case HCURL:
      dds = 1;
      break;
    case H1:
      dds = 1;
      break;
    default:
      SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY,
              "Huston we have a problem");
    }
    if (field->getSpace() == H1) {
      CHKERR m_field.set_field_order(meshSet, MBVERTEX, boundaryFields[ff], 1);
    }
    for (int dd = dds; dd <= dIm - 1; dd++) {
      Range ents;
      CHKERR m_field.get_field_entities_by_dimension(boundaryFields[ff], dd,
                                                     ents);
      CHKERR m_field.set_field_order(ents, boundaryFields[ff],
                                     fieldsOrder.at(boundaryFields[ff]).first);
    }
  }
  // Set order to skeleton
  for (unsigned int ff = 0; ff != skeletonFields.size(); ff++) {
    if (fieldsOrder.find(skeletonFields[ff]) == fieldsOrder.end()) {
      SETERRQ1(PETSC_COMM_WORLD, MOFEM_INVALID_DATA,
               "Order for field not set %s", skeletonFields[ff].c_str());
    }
    int dds = 0;
    const Field *field = m_field.get_field_structure(skeletonFields[ff]);
    switch (field->getSpace()) {
    case L2:
      dds = dIm - 1;
      break;
    case HDIV:
      dds = 2;
      break;
    case HCURL:
      dds = 1;
      break;
    case H1:
      dds = 1;
      break;
    default:
      SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY,
              "Huston we have a problem");
    }
    if (field->getSpace() == H1) {
      CHKERR m_field.set_field_order(meshSet, MBVERTEX, skeletonFields[ff], 1);
    }
    for (int dd = dds; dd <= dIm - 1; dd++) {
      Range ents;
      CHKERR m_field.get_field_entities_by_dimension(skeletonFields[ff], dd,
                                                     ents);
      CHKERR m_field.set_field_order(ents, skeletonFields[ff],
                                     fieldsOrder.at(skeletonFields[ff]).first);
    }
  }
  // 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 467 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 493 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);
  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 159 of file Simple.cpp.

                                            {
  Interface &m_field = cOre;
  MoFEMFunctionBeginHot;
  // Define finite elements
  CHKERR m_field.add_finite_element(domainFE);
  for (unsigned int ff = 0; ff != domainFields.size(); ff++) {
    CHKERR m_field.modify_finite_element_add_field_row(domainFE,
                                                       domainFields[ff]);
    CHKERR m_field.modify_finite_element_add_field_col(domainFE,
                                                       domainFields[ff]);
    CHKERR m_field.modify_finite_element_add_field_data(domainFE,
                                                        domainFields[ff]);
  }
  for (unsigned int ff = 0; ff != dataFields.size(); ff++) {
    CHKERR m_field.modify_finite_element_add_field_data(domainFE,
                                                        dataFields[ff]);
  }
  if (!boundaryFields.empty()) {
    CHKERR m_field.add_finite_element(boundaryFE);
    for (unsigned int ff = 0; ff != domainFields.size(); ff++) {
      CHKERR m_field.modify_finite_element_add_field_row(boundaryFE,
                                                         domainFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_col(boundaryFE,
                                                         domainFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_data(boundaryFE,
                                                          domainFields[ff]);
    }
    for (unsigned int ff = 0; ff != boundaryFields.size(); ff++) {
      CHKERR m_field.modify_finite_element_add_field_row(boundaryFE,
                                                         boundaryFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_col(boundaryFE,
                                                         boundaryFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_data(boundaryFE,
                                                          boundaryFields[ff]);
    }
    for (unsigned int ff = 0; ff != skeletonFields.size(); ff++) {
      CHKERR m_field.modify_finite_element_add_field_row(boundaryFE,
                                                         skeletonFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_col(boundaryFE,
                                                         skeletonFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_data(boundaryFE,
                                                          skeletonFields[ff]);
    }
  }
  if (!skeletonFields.empty()) {
    CHKERR m_field.add_finite_element(skeletonFE);
    for (unsigned int ff = 0; ff != domainFields.size(); ff++) {
      CHKERR m_field.modify_finite_element_add_field_row(skeletonFE,
                                                         domainFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_col(skeletonFE,
                                                         domainFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_data(skeletonFE,
                                                          domainFields[ff]);
    }
    for (unsigned int ff = 0; ff != boundaryFields.size(); ff++) {
      CHKERR m_field.modify_finite_element_add_field_row(skeletonFE,
                                                         boundaryFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_col(skeletonFE,
                                                         boundaryFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_data(skeletonFE,
                                                          boundaryFields[ff]);
    }
    for (unsigned int ff = 0; ff != skeletonFields.size(); ff++) {
      CHKERR m_field.modify_finite_element_add_field_row(skeletonFE,
                                                         skeletonFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_col(skeletonFE,
                                                         skeletonFields[ff]);
      CHKERR m_field.modify_finite_element_add_field_data(skeletonFE,
                                                          skeletonFields[ff]);
    }
  }
  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 233 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

Examples

hello_world.cpp, mesh_smoothing.cpp, and simple_interface.cpp.

Definition at line 222 of file Simple.hpp.

{ return boundaryFE; }

getBoundaryFEName() [2/2]

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

(

)

Definition at line 227 of file Simple.hpp.

{ return boundaryFE; }

getDim()

int MoFEM::Simple::getDim

(

)

const

Definition at line 220 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

field_evaluator.cpp, hello_world.cpp, loop_entities.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 516 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 218 of file Simple.hpp.

{ return dM; }

getDomainFEName() [1/2]

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

(

)

const

Examples

field_evaluator.cpp, hello_world.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 221 of file Simple.hpp.

{ return domainFE; }

getDomainFEName() [2/2]

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

(

)

Definition at line 226 of file Simple.hpp.

{ return domainFE; }

getOptions()

MoFEMErrorCode MoFEM::Simple::getOptions

(

)

get options

Returns

error code

Examples

field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hello_world.cpp, loop_entities.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 48 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

(

)

Examples

mesh_smoothing.cpp.

Definition at line 231 of file Simple.hpp.

{ return otherFEs; }

getProblemName() [1/2]

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

(

)

const

Examples

reaction_diffusion_equation.cpp.

Definition at line 224 of file Simple.hpp.

{ return nameOfProblem; }

getProblemName() [2/2]

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

(

)

Definition at line 229 of file Simple.hpp.

{ return nameOfProblem; }

getSkeletonFEName() [1/2]

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

(

)

const

Examples

hello_world.cpp.

Definition at line 223 of file Simple.hpp.

{ return skeletonFE; }

getSkeletonFEName() [2/2]

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

(

)

Definition at line 228 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;"

)

Load mesh file.

Parameters

field_name

file name

Returns

error code

Examples

field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hello_world.cpp, loop_entities.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 62 of file Simple.cpp.

                                                       {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  PetscLogEventBegin(MOFEM_EVENT_SimpleLoadMesh, 0, 0, 0, 0);
  // 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);
}

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

field_blas_set_vertex_dofs.cpp, field_evaluator.cpp, hello_world.cpp, loop_entities.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 256 of file Simple.cpp.

                                                                         {
  MoFEMFunctionBeginHot;
  fieldsOrder[field_name] =
      std::pair<int, Range>(order, ents == NULL ? Range() : Range(*ents));
  MoFEMFunctionReturnHot(0);
}

setUp()

MoFEMErrorCode MoFEM::Simple::setUp

(

const PetscBool

is_partitioned = PETSC_TRUE

)

Setup problem.

Returns

error code

Examples

field_evaluator.cpp, hello_world.cpp, loop_entities.cpp, reaction_diffusion_equation.cpp, simple_interface.cpp, testing_jacobian_of_hook_element.cpp, and testing_jacobian_of_hook_scaled_with_density_element.cpp.

Definition at line 506 of file Simple.cpp.

                                                           {
  MoFEMFunctionBegin;
  CHKERR defineFiniteElements();
  CHKERR defineProblem(is_partitioned);
  CHKERR buildFields();
  CHKERR buildFiniteElements();
  CHKERR buildProblem();
  MoFEMFunctionReturn(0);
}

Member Data Documentation

bitLevel

const BitRefLevel MoFEM::Simple::bitLevel

private

Definition at line 234 of file Simple.hpp.

boundaryFE

std::string MoFEM::Simple::boundaryFE

private

boundary finite element

Definition at line 253 of file Simple.hpp.

boundaryFields

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

private

boundary fields

Definition at line 245 of file Simple.hpp.

boundaryMeshset

EntityHandle MoFEM::Simple::boundaryMeshset

private

meshset with boundary

Definition at line 243 of file Simple.hpp.

cOre

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

Definition at line 41 of file Simple.hpp.

dataFields

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

private

Data fields.

Definition at line 247 of file Simple.hpp.

dIm

int MoFEM::Simple::dIm

private

dimension of problem

Definition at line 259 of file Simple.hpp.

dM

SmartPetscObj<DM> MoFEM::Simple::dM

private

Definition at line 261 of file Simple.hpp.

domainFE

std::string MoFEM::Simple::domainFE

private

domain finite element

Definition at line 252 of file Simple.hpp.

domainFields

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

private

domain fields

Definition at line 244 of file Simple.hpp.

fieldsOrder

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

private

fields order

Definition at line 249 of file Simple.hpp.

meshFileName

char MoFEM::Simple::meshFileName[255]

private

mesh file name

Definition at line 258 of file Simple.hpp.

meshSet

EntityHandle MoFEM::Simple::meshSet

private

domain meshset

Definition at line 242 of file Simple.hpp.

MOFEM_EVENT_SimpleBuildFields

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleBuildFields

private

Definition at line 237 of file Simple.hpp.

MOFEM_EVENT_SimpleBuildFiniteElements

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleBuildFiniteElements

private

Definition at line 238 of file Simple.hpp.

MOFEM_EVENT_SimpleBuildProblem

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleBuildProblem

private

Definition at line 239 of file Simple.hpp.

MOFEM_EVENT_SimpleKSPSolve

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleKSPSolve

private

Definition at line 240 of file Simple.hpp.

MOFEM_EVENT_SimpleLoadMesh

PetscLogEvent MoFEM::Simple::MOFEM_EVENT_SimpleLoadMesh

private

Definition at line 236 of file Simple.hpp.

nameOfProblem

std::string MoFEM::Simple::nameOfProblem

private

problem name

Definition at line 251 of file Simple.hpp.

otherFEs

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

private

Other finite elements.

Definition at line 256 of file Simple.hpp.

skeletonFE

std::string MoFEM::Simple::skeletonFE

private

skeleton finite element

Definition at line 254 of file Simple.hpp.

skeletonFields

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

private

fields on the skeleton

Definition at line 246 of file Simple.hpp.

---

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

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