MoFEM::Field Struct Reference

Field data structure for finite element approximation. More...

#include "src/multi_indices/FieldMultiIndices.hpp"

Collaboration diagram for MoFEM::Field:

Public Types
using	SequenceDofContainer = multi_index_container< boost::weak_ptr< std::vector< DofEntity > >, indexed_by< sequenced<> > >
	Container for bulk DOF allocation.
using	DofsOrderMap = std::array< std::array< int, MAX_DOFS_ON_ENTITY >, MBMAXTYPE >
	Array mapping entity types to DOF order arrays.

Public Member Functions
	Field (moab::Interface &moab, const EntityHandle meshset)
	Constructor for MOAB field.
virtual	~Field ()=default
	Virtual destructor.
FieldOrderTable &	getFieldOrderTable ()
	Get field order table.
EntityHandle	getMeshset () const
	Get field meshset handle.
const BitFieldId &	getId () const
	Get unique field identifier.
boost::string_ref	getNameRef () const
	Get field name as string reference.
std::string	getName () const
	Get field name as string.
FieldSpace	getSpace () const
	Get field approximation space.
auto	getSpaceName () const
	Get field approximation space name.
FieldContinuity	getContinuity () const
	Get field continuity type.
auto	getContinuityName () const
	Get field continuity name.
FieldApproximationBase	getApproxBase () const
	Get approximation basis type.
auto	getApproxBaseName () const
	Get approximation basis name.
FieldCoefficientsNumber	getNbOfCoeffs () const
	Get number of field coefficients per DOF.
FieldBitNumber	getBitNumber () const
	Get bit number for this field's ID.
FieldBitNumber	getBitNumberCalculate () const
	Calculate bit number for this field's ID.
SequenceDofContainer &	getDofSequenceContainer () const
	Get sequence container for bulk DOF allocation.
const std::array< ApproximationOrder, MAX_DOFS_ON_ENTITY > &	getDofOrderMap (const EntityType type) const
	Get DOF order mapping for specific entity type.
const DofsOrderMap &	getDofOrderMap () const
	Get complete DOF order mapping for all entity types.
std::map< int, BaseFunction::DofsSideMap > &	getDofSideMap () const
	Get DOF side mapping for broken spaces.
MoFEMErrorCode	rebuildDofsOrderMap ()
	Rebuild DOF order mapping arrays.
const Field *	getFieldRawPtr () const
	Get raw pointer to this field.

Static Public Member Functions
static FieldBitNumber	getBitNumberCalculate (const BitFieldId &id)
	Calculate bit number from field ID bitset.

Public Attributes
moab::Interface &	moab
	MOAB interface reference.
EntityHandle	meshSet
	Meshset containing field entities.
TagType	tagFieldDataVertsType
	Tag type for vertex data storage.
Tag	th_FieldDataVerts
	Tag for field values on vertices.
Tag	th_FieldData
	Tag for field values on entities.
Tag	th_AppOrder
	Tag for approximation order on entities.
Tag	th_FieldRank
	Tag for field rank (vector dimension)
BitFieldId *	tagId
	Field unique identifier.
FieldSpace *	tagSpaceData
	Field approximation space.
FieldContinuity *	tagFieldContinuityData
	Field continuity type.
FieldApproximationBase *	tagBaseData
	Field basis functions.
FieldCoefficientsNumber *	tagNbCoeffData
	Field rank (e.g. Temperature=1, displacement in 3D=3)
const void *	tagName
	Field name.
int	tagNameSize
	Field name size in bytes.
const void *	tagNamePrefixData
	Field name prefix.
int	tagNamePrefixSize
	Field name prefix size in bytes.
FieldOrderTable	forderTable
	DOF count functions for each entity type.
unsigned int	bitNumber
	Bit number corresponding to this field's unique ID.

Static Public Attributes
static constexpr int	maxBrokenDofsOrder = 10
	Maximum order for broken space DOFs.

Private Attributes
SequenceDofContainer	sequenceDofContainer
DofsOrderMap	dofOrderMap
std::map< int, BaseFunction::DofsSideMap >	dofSideMap

Friends
std::ostream &	operator<< (std::ostream &os, const Field &e)
	Output stream operator for field information.

Detailed Description

Field data structure for finite element approximation.

Stores field information including approximation space, basis functions, coordinate systems, and DOF management. Each field has a unique ID and name. Data is shared between mesh entities and their associated DOFs.

Examples

mofem/atom_tests/forces_and_sources_testing_users_base.cpp, mofem/atom_tests/scalar_check_approximation.cpp, and mofem/users_modules/eshelbian_plasticity/src/impl/EshelbianPlasticity.cpp.

Definition at line 36 of file FieldMultiIndices.hpp.

Member Typedef Documentation

DofsOrderMap

using MoFEM::Field::DofsOrderMap = std::array<std::array<int, MAX_DOFS_ON_ENTITY>, MBMAXTYPE>

Array mapping entity types to DOF order arrays.

Definition at line 54 of file FieldMultiIndices.hpp.

SequenceDofContainer

using MoFEM::Field::SequenceDofContainer = multi_index_container< boost::weak_ptr<std::vector<DofEntity> >, indexed_by<sequenced<> >>

Container for bulk DOF allocation.

Definition at line 49 of file FieldMultiIndices.hpp.

Constructor & Destructor Documentation

Field()

MoFEM::Field::Field	(	moab::Interface &	moab,
		const EntityHandle	meshset
	)

Constructor for MOAB field.

Parameters

moab	MOAB interface reference
meshset	EntityHandle containing field entities

Definition at line 17 of file FieldMultiIndices.cpp.

    : moab(moab), meshSet(meshset), tagId(NULL), tagSpaceData(NULL),
      tagFieldContinuityData(NULL), tagNbCoeffData(NULL), tagName(NULL),
      tagNameSize(0) {
 
  auto get_tag_data_ptr = [&](const auto name, auto &tag_data) {
    MoFEMFunctionBegin;
    Tag th;
    CHKERR moab.tag_get_handle(name, th);
    CHKERR moab.tag_get_by_ptr(th, &meshset, 1, (const void **)&tag_data);
    MoFEMFunctionReturn(0);
  };
 
  // id
  ierr = get_tag_data_ptr("_FieldId", tagId);
  CHKERRABORT(PETSC_COMM_SELF, ierr);
  // space
  ierr = get_tag_data_ptr("_FieldSpace", tagSpaceData);
  CHKERRABORT(PETSC_COMM_SELF, ierr);
  // continuity
  ierr = get_tag_data_ptr("_FieldContinuity", tagFieldContinuityData);
  CHKERRABORT(PETSC_COMM_SELF, ierr);
 
  // approx. base
  ierr = get_tag_data_ptr("_FieldBase", tagBaseData);
  CHKERRABORT(PETSC_COMM_SELF, ierr);
 
  // name
  Tag th_field_name;
  CHKERR moab.tag_get_handle("_FieldName", th_field_name);
  CHKERR moab.tag_get_by_ptr(th_field_name, &meshSet, 1,
                             (const void **)&tagName, &tagNameSize);
  // name prefix
  Tag th_field_name_data_name_prefix;
  CHKERR moab.tag_get_handle("_FieldName_DataNamePrefix",
                             th_field_name_data_name_prefix);
  CHKERR moab.tag_get_by_ptr(th_field_name_data_name_prefix, &meshSet, 1,
                             (const void **)&tagNamePrefixData,
                             &tagNamePrefixSize);
  std::string name_data_prefix((char *)tagNamePrefixData, tagNamePrefixSize);
 
  // rank
  std::string Tag_rank_name = "_Field_Rank_" + getName();
  CHKERR moab.tag_get_handle(Tag_rank_name.c_str(), th_FieldRank);
  CHKERR moab.tag_get_by_ptr(th_FieldRank, &meshSet, 1,
                             (const void **)&tagNbCoeffData);
 
  auto get_all_tags = [&]() {
    MoFEMFunctionBegin;
    // order
    ApproximationOrder def_approx_order = -1;
    std::string tag_approximation_order_name = "_App_Order_" + getName();
    rval = moab.tag_get_handle(tag_approximation_order_name.c_str(), 1,
                               MB_TYPE_INTEGER, th_AppOrder,
                               MB_TAG_CREAT | MB_TAG_SPARSE, &def_approx_order);
    if (rval == MB_ALREADY_ALLOCATED)
      rval = MB_SUCCESS;
    MOAB_THROW(rval);
 
    // data
    std::string tag_data_name = name_data_prefix + getName();
    const int def_len = 0;
    rval = moab.tag_get_handle(
        tag_data_name.c_str(), def_len, MB_TYPE_DOUBLE, th_FieldData,
        MB_TAG_CREAT | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
    if (rval == MB_ALREADY_ALLOCATED)
      rval = MB_SUCCESS;
    MOAB_THROW(rval);
 
    std::string tag_data_name_verts = name_data_prefix + getName() + "_V";
    rval = moab.tag_get_handle(tag_data_name_verts.c_str(), th_FieldDataVerts);
    if (rval == MB_SUCCESS)
      CHKERR moab.tag_get_type(th_FieldDataVerts, tagFieldDataVertsType);
    else {
      // Since vertex tag is not it mesh that tag is not dense, it is sparse,
      // sinc it is set to all vertices on the mesh. Is unlikely that mesh has
      // no vertices, then above assumption does not hold.
      tagFieldDataVertsType = MB_TAG_SPARSE;
      VectorDouble def_vert_data(*tagNbCoeffData);
      def_vert_data.clear();
      rval = moab.tag_get_handle(tag_data_name_verts.c_str(), *tagNbCoeffData,
                                 MB_TYPE_DOUBLE, th_FieldDataVerts,
                                 MB_TAG_CREAT | tagFieldDataVertsType,
                                 &*def_vert_data.begin());
      if (rval == MB_ALREADY_ALLOCATED)
        rval = MB_SUCCESS;
      MOAB_THROW(rval);
    }
 
    MoFEMFunctionReturn(0);
  };
 
  auto get_all_tags_deprecated = [&]() {
    MoFEMFunctionBegin;
    // order
    ApproximationOrder def_approx_order = -1;
    std::string tag_approximation_order_name = "_App_Order_" + getName();
    rval = moab.tag_get_handle(tag_approximation_order_name.c_str(), 1,
                               MB_TYPE_INTEGER, th_AppOrder,
                               MB_TAG_CREAT | MB_TAG_SPARSE, &def_approx_order);
    if (rval == MB_ALREADY_ALLOCATED)
      rval = MB_SUCCESS;
    MOAB_THROW(rval);
 
    // data
    std::string tag_data_name = name_data_prefix + getName();
    const int def_len = 0;
    rval = moab.tag_get_handle(
        tag_data_name.c_str(), def_len, MB_TYPE_DOUBLE, th_FieldData,
        MB_TAG_CREAT | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
    if (rval == MB_ALREADY_ALLOCATED)
      rval = MB_SUCCESS;
    MOAB_THROW(rval);
 
    std::string tag_data_name_verts = name_data_prefix + getName() + "V";
    rval = moab.tag_get_handle(tag_data_name_verts.c_str(), th_FieldDataVerts);
    if (rval == MB_SUCCESS)
      CHKERR moab.tag_get_type(th_FieldDataVerts, tagFieldDataVertsType);
    else {
      // Since vertex tag is not it mesh that tag is not dense, it is sparse,
      // sinc it is set to all vertices on the mesh. Is unlikely that mesh has
      // no vertices, then above assumption does not hold.
      tagFieldDataVertsType = MB_TAG_SPARSE;
      VectorDouble def_vert_data(*tagNbCoeffData);
      def_vert_data.clear();
      rval = moab.tag_get_handle(tag_data_name_verts.c_str(), *tagNbCoeffData,
                                 MB_TYPE_DOUBLE, th_FieldDataVerts,
                                 MB_TAG_CREAT | tagFieldDataVertsType,
                                 &*def_vert_data.begin());
      if (rval == MB_ALREADY_ALLOCATED)
        rval = MB_SUCCESS;
      MOAB_THROW(rval);
    }
 
    MoFEMFunctionReturn(0);
  };
 
  Version file_ver;
  ierr = UnknownInterface::getFileVersion(moab, file_ver);
  CHK_THROW_MESSAGE(ierr, "Not known file version");
  if (file_ver.majorVersion >= 0 && file_ver.minorVersion >= 12 &&
      file_ver.buildVersion >= 1) {
    ierr = get_all_tags();
    CHKERRABORT(PETSC_COMM_SELF, ierr);
  } else {
    ierr = get_all_tags_deprecated();
    CHKERRABORT(PETSC_COMM_SELF, ierr);
  }
 
  bitNumber = getBitNumberCalculate();
 
  auto reset_entity_order_table = [&]() {
    for (int tt = 0; tt != MBMAXTYPE; ++tt)
      forderTable[tt] = NULL;
  };
 
  auto set_continuous_entity_order_table = [&]() {
    switch (*tagBaseData) {
    case AINSWORTH_LEGENDRE_BASE:
    case AINSWORTH_LOBATTO_BASE:
      switch (*tagSpaceData) {
      case H1:
        forderTable[MBVERTEX] = [](int P) -> int { return (P > 0) ? 1 : 0; };
        forderTable[MBEDGE] = [](int P) -> int { return NBEDGE_H1(P); };
        forderTable[MBTRI] = [](int P) -> int { return NBFACETRI_H1(P); };
        forderTable[MBQUAD] = [](int P) -> int { return NBFACEQUAD_H1(P); };
        forderTable[MBTET] = [](int P) -> int { return NBVOLUMETET_H1(P); };
        forderTable[MBHEX] = [](int P) -> int { return NBVOLUMEHEX_H1(P); };
        forderTable[MBPRISM] = [](int P) -> int { return NBVOLUMEPRISM_H1(P); };
        break;
      case HCURL:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBEDGE] = [](int P) -> int {
          return NBEDGE_AINSWORTH_HCURL(P);
        };
        forderTable[MBTRI] = [](int P) -> int {
          return NBFACETRI_AINSWORTH_HCURL(P);
        };
        forderTable[MBTET] = [](int P) -> int {
          return NBVOLUMETET_AINSWORTH_HCURL(P);
        };
        break;
      case HDIV:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBEDGE] = [](int P) -> int {
          (void)P;
          return NBEDGE_HDIV(P);
        };
        forderTable[MBTRI] = [](int P) -> int {
          return 3 * NBFACETRI_AINSWORTH_EDGE_HDIV(
                         AinsworthOrderHooks::broken_nbfacetri_edge_hdiv(P)) +
                 NBFACETRI_AINSWORTH_FACE_HDIV(
                     AinsworthOrderHooks::broken_nbfacetri_face_hdiv(P));
        };
        forderTable[MBTET] = [](int P) -> int {
          return 6 * NBVOLUMETET_AINSWORTH_EDGE_HDIV(
                         AinsworthOrderHooks::broken_nbvolumetet_edge_hdiv(P)) +
                 4 * NBVOLUMETET_AINSWORTH_FACE_HDIV(
                         AinsworthOrderHooks::broken_nbvolumetet_face_hdiv(P)) +
                 NBVOLUMETET_AINSWORTH_VOLUME_HDIV(
                     AinsworthOrderHooks::broken_nbvolumetet_volume_hdiv(P));
        };
        break;
      case L2:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 1;
        };
        forderTable[MBEDGE] = [](int P) -> int { return NBEDGE_L2(P); };
        forderTable[MBTRI] = [](int P) -> int { return NBFACETRI_L2(P); };
        forderTable[MBQUAD] = [](int P) -> int { return NBFACEQUAD_L2(P); };
        forderTable[MBTET] = [](int P) -> int { return NBVOLUMETET_L2(P); };
        forderTable[MBHEX] = [](int P) -> int { return NBVOLUMEHEX_L2(P); };
        break;
      default:
        THROW_MESSAGE("unknown approximation space");
      }
      break;
    case AINSWORTH_BERNSTEIN_BEZIER_BASE:
      switch (*tagSpaceData) {
      case H1:
        forderTable[MBVERTEX] = [](int P) -> int { return (P > 0) ? 1 : 0; };
        forderTable[MBEDGE] = [](int P) -> int { return NBEDGE_H1(P); };
        forderTable[MBTRI] = [](int P) -> int { return NBFACETRI_H1(P); };
        forderTable[MBQUAD] = [](int P) -> int { return NBFACEQUAD_H1(P); };
        forderTable[MBTET] = [](int P) -> int { return NBVOLUMETET_H1(P); };
        forderTable[MBPRISM] = [](int P) -> int { return NBVOLUMEPRISM_H1(P); };
        break;
      case L2:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 1;
        };
        forderTable[MBEDGE] = [](int P) -> int { return NBEDGE_L2(P); };
        forderTable[MBTRI] = [](int P) -> int { return NBFACETRI_L2(P); };
        forderTable[MBQUAD] = [](int P) -> int { return NBFACEQUAD_L2(P); };
        forderTable[MBTET] = [](int P) -> int { return NBVOLUMETET_L2(P); };
        forderTable[MBHEX] = [](int P) -> int { return NBVOLUMEHEX_L2(P); };
        break;
      default:
        THROW_MESSAGE("unknown approximation space or not yet implemented");
      }
      break;
    case DEMKOWICZ_JACOBI_BASE:
      switch (*tagSpaceData) {
      case H1:
        forderTable[MBVERTEX] = [](int P) -> int { return (P > 0) ? 1 : 0; };
        forderTable[MBEDGE] = [](int P) -> int { return NBEDGE_H1(P); };
        forderTable[MBTRI] = [](int P) -> int { return NBFACETRI_H1(P); };
        forderTable[MBQUAD] = [](int P) -> int { return NBFACEQUAD_H1(P); };
        forderTable[MBTET] = [](int P) -> int { return NBVOLUMETET_H1(P); };
        forderTable[MBHEX] = [](int P) -> int { return NBVOLUMEHEX_H1(P); };
        forderTable[MBPRISM] = [](int P) -> int { return NBVOLUMEPRISM_H1(P); };
        break;
      case HCURL:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBEDGE] = [](int P) -> int {
          return NBEDGE_DEMKOWICZ_HCURL(P);
        };
        forderTable[MBTRI] = [](int P) -> int {
          return NBFACETRI_DEMKOWICZ_HCURL(P);
        };
        forderTable[MBQUAD] = [](int P) -> int {
          return NBFACEQUAD_DEMKOWICZ_HCURL(P);
        };
        forderTable[MBTET] = [](int P) -> int {
          return NBVOLUMETET_DEMKOWICZ_HCURL(P);
        };
        forderTable[MBHEX] = [](int P) -> int {
          return NBVOLUMEHEX_DEMKOWICZ_HCURL(P);
        };
        break;
      case HDIV:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBEDGE] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBTRI] = [](int P) -> int {
          return NBFACETRI_DEMKOWICZ_HDIV(P);
        };
        forderTable[MBQUAD] = [](int P) -> int {
          return NBFACEQUAD_DEMKOWICZ_HDIV(P);
        };
        forderTable[MBTET] = [](int P) -> int {
          return NBVOLUMETET_DEMKOWICZ_HDIV(P);
        };
        forderTable[MBHEX] = [](int P) -> int {
          return NBVOLUMEHEX_DEMKOWICZ_HDIV(P);
        };
        break;
      case L2:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 1;
        };
        forderTable[MBEDGE] = [](int P) -> int { return NBEDGE_L2(P); };
        forderTable[MBTRI] = [](int P) -> int { return NBFACETRI_L2(P); };
        forderTable[MBQUAD] = [](int P) -> int { return NBFACEQUAD_L2(P); };
        forderTable[MBTET] = [](int P) -> int { return NBVOLUMETET_L2(P); };
        forderTable[MBHEX] = [](int P) -> int { return NBVOLUMEHEX_L2(P); };
        break;
      default:
        THROW_MESSAGE("unknown approximation space or not yet implemented");
      }
      break;
    case USER_BASE:
      for (int ee = 0; ee < MBMAXTYPE; ee++) {
        forderTable[ee] = [](int P) -> int {
          (void)P;
          return 0;
        };
      }
      break;
    default:
      if (*tagSpaceData != NOFIELD) {
        THROW_MESSAGE("unknown approximation base");
      } else {
        for (EntityType t = MBVERTEX; t < MBMAXTYPE; t++)
          forderTable[t] = [](int P) -> int {
            (void)P;
            return 1;
          };
      }
    }
  };
 
  auto set_discontinuous_entity_order_table = [&]() {
    switch (*tagBaseData) {
    case AINSWORTH_LEGENDRE_BASE:
    case AINSWORTH_LOBATTO_BASE:
      switch (*tagSpaceData) {
      case HCURL:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBEDGE] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBTRI] = [](int P) -> int {
          return 3 * NBEDGE_AINSWORTH_HCURL(P) + NBFACETRI_AINSWORTH_HCURL(P);
        };
        forderTable[MBTET] = [](int P) -> int {
          return 6 * NBEDGE_AINSWORTH_HCURL(P) +
                 4 * NBFACETRI_AINSWORTH_HCURL(P) +
                 NBVOLUMETET_AINSWORTH_HCURL(P);
        };
        break;
      case HDIV:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBEDGE] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBTRI] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBTET] = [](int P) -> int {
          return
 
              4 * (
 
                      3 * NBFACETRI_AINSWORTH_EDGE_HDIV(
                              AinsworthOrderHooks::broken_nbfacetri_edge_hdiv(P)) +
                      NBFACETRI_AINSWORTH_FACE_HDIV(
                          AinsworthOrderHooks::broken_nbfacetri_face_hdiv(P))
 
                          ) +
 
              6 * NBVOLUMETET_AINSWORTH_EDGE_HDIV(
                      AinsworthOrderHooks::broken_nbvolumetet_edge_hdiv(P)) +
              4 * NBVOLUMETET_AINSWORTH_FACE_HDIV(
                      AinsworthOrderHooks::broken_nbvolumetet_face_hdiv(P)) +
              NBVOLUMETET_AINSWORTH_VOLUME_HDIV(
                  AinsworthOrderHooks::broken_nbvolumetet_volume_hdiv(P));
        };
        break;
      default:
        THROW_MESSAGE("unknown approximation space or not implemented");
      }
      break;
    case AINSWORTH_BERNSTEIN_BEZIER_BASE:
      THROW_MESSAGE("unknown approximation space or not yet implemented");
      break;
    case DEMKOWICZ_JACOBI_BASE:
      switch (*tagSpaceData) {
      case HCURL:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBEDGE] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBTRI] = [](int P) -> int {
          return 3 * NBEDGE_DEMKOWICZ_HCURL(P) + NBFACETRI_DEMKOWICZ_HCURL(P);
        };
        forderTable[MBQUAD] = [](int P) -> int {
          return 4 * NBEDGE_DEMKOWICZ_HCURL(P) + NBFACEQUAD_DEMKOWICZ_HCURL(P);
        };
        forderTable[MBTET] = [](int P) -> int {
          return 6 * NBEDGE_DEMKOWICZ_HCURL(P) +
                 4 * NBFACETRI_DEMKOWICZ_HCURL(P) +
                 NBVOLUMETET_DEMKOWICZ_HCURL(P);
        };
        forderTable[MBHEX] = [](int P) -> int {
          return 12 * NBEDGE_DEMKOWICZ_HCURL(P) +
                 6 * NBFACEQUAD_DEMKOWICZ_HCURL(P) +
                 NBVOLUMEHEX_DEMKOWICZ_HCURL(P);
        };
        break;
      case HDIV:
        forderTable[MBVERTEX] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBEDGE] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBTRI] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBQUAD] = [](int P) -> int {
          (void)P;
          return 0;
        };
        forderTable[MBTET] = [](int P) -> int {
          return 4 * NBFACETRI_DEMKOWICZ_HDIV(P) +
                 NBVOLUMETET_DEMKOWICZ_HDIV(P);
        };
        forderTable[MBHEX] = [](int P) -> int {
          return 6 * NBFACEQUAD_DEMKOWICZ_HDIV(P) +
                 NBVOLUMEHEX_DEMKOWICZ_HDIV(P);
        };
        break;
      default:
        THROW_MESSAGE("unknown approximation space or not yet implemented");
      }
      break;
    case USER_BASE:
      for (int ee = 0; ee < MBMAXTYPE; ee++) {
        forderTable[ee] = [](int P) -> int {
          (void)P;
          return 0;
        };
      }
      break;
    default:
      if (*tagSpaceData != NOFIELD) {
        THROW_MESSAGE("unknown approximation base");
      } else {
        for (EntityType t = MBVERTEX; t < MBMAXTYPE; t++)
          forderTable[t] = [](int P) -> int {
            (void)P;
            return 1;
          };
      }
    }
  };
 
  reset_entity_order_table();
  switch (*tagFieldContinuityData) {
  case CONTINUOUS:
    set_continuous_entity_order_table();
    break;
  case DISCONTINUOUS:
    set_discontinuous_entity_order_table();
    break;
  default:
    *tagFieldContinuityData = CONTINUOUS;
    set_continuous_entity_order_table();
    MOFEM_LOG("SELF", Sev::warning)
        << "unknown field continuity, set CONTINUOUS";
    break;
  }
  ierr = rebuildDofsOrderMap();
  CHKERRABORT(PETSC_COMM_SELF, ierr);
};

~Field()

virtual MoFEM::Field::~Field ( )

virtualdefault

Virtual destructor.

Member Function Documentation

getApproxBase()

FieldApproximationBase MoFEM::Field::getApproxBase ( ) const

inline

Get approximation basis type.

Returns

Approximation basis enumeration

Definition at line 161 of file FieldMultiIndices.hpp.

{ return *tagBaseData; }

getApproxBaseName()

auto MoFEM::Field::getApproxBaseName ( ) const

inline

Get approximation basis name.

Returns

Approximation basis name string

Definition at line 167 of file FieldMultiIndices.hpp.

                                        {
    return std::string(ApproximationBaseNames[getApproxBase()]);
  }

getBitNumber()

FieldBitNumber MoFEM::Field::getBitNumber ( ) const

inline

Get bit number for this field's ID.

Returns

Bit position in field ID bitset

Definition at line 188 of file FieldMultiIndices.hpp.

{ return bitNumber; }

getBitNumberCalculate() [1/2]

FieldBitNumber MoFEM::Field::getBitNumberCalculate ( ) const

inline

Calculate bit number for this field's ID.

Returns

Bit position (1-based) or 0 if no bits set

Definition at line 208 of file FieldMultiIndices.hpp.

                                                      {
    return getBitNumberCalculate(static_cast<BitFieldId &>(*tagId));
  }

getBitNumberCalculate() [2/2]

static FieldBitNumber MoFEM::Field::getBitNumberCalculate ( const BitFieldId &  id )

inlinestatic

Calculate bit number from field ID bitset.

Parameters

id	Field ID bitset

Returns

Bit position (1-based) or 0 if no bits set

Definition at line 195 of file FieldMultiIndices.hpp.

                                                                           {
    static_assert(BITFIELDID_SIZE >= 32,
                  "Too many fields allowed, can be more but ...");
    FieldBitNumber b = ffsl(id.to_ulong());
    if (b != 0)
      return b;
    return 0;
  }

getContinuity()

FieldContinuity MoFEM::Field::getContinuity ( ) const

inline

Get field continuity type.

There are two types of continuity: CONTINUOUS and DISCONTINUOUS. Discontinuous is used to indicate broken spaces.

Returns

Field continuity enumeration

Definition at line 145 of file FieldMultiIndices.hpp.

                                               {
    return *tagFieldContinuityData;
  }

getContinuityName()

auto MoFEM::Field::getContinuityName ( ) const

inline

Get field continuity name.

Returns

Field continuity name string

Definition at line 153 of file FieldMultiIndices.hpp.

                                        {
    return std::string(FieldContinuityNames[getContinuity()]);
  }

getDofOrderMap() [1/2]

const DofsOrderMap & MoFEM::Field::getDofOrderMap ( ) const

inline

Get complete DOF order mapping for all entity types.

Returns

Full DOF order mapping array

Definition at line 239 of file FieldMultiIndices.hpp.

{ return dofOrderMap; }

getDofOrderMap() [2/2]

const std::array< ApproximationOrder, MAX_DOFS_ON_ENTITY > & MoFEM::Field::getDofOrderMap ( const EntityType  type ) const

inline

Get DOF order mapping for specific entity type.

Parameters

type	Entity type (vertex, edge, face, volume)

Returns

Array mapping DOF index to approximation order

Examples

mofem/atom_tests/forces_and_sources_testing_users_base.cpp.

Definition at line 231 of file FieldMultiIndices.hpp.

                                              {
    return dofOrderMap[type];
  }

getDofSequenceContainer()

SequenceDofContainer & MoFEM::Field::getDofSequenceContainer ( ) const

inline

Get sequence container for bulk DOF allocation.

Container stores DOF data in bulk for efficiency. Vectors are destroyed when last entity referencing them is removed. Used primarily for vertex DOFs in H1 spaces where DOF count per vertex is fixed.

Returns

Reference to DOF sequence container

Definition at line 221 of file FieldMultiIndices.hpp.

                                                               {
    return sequenceDofContainer;
  }

getDofSideMap()

std::map< int, BaseFunction::DofsSideMap > & MoFEM::Field::getDofSideMap ( ) const

inline

Get DOF side mapping for broken spaces.

Maps interior DOFs in broken spaces to entities where their traces are non-zero. Used for discontinuous Galerkin methods.

Returns

Reference to DOF side mapping

Definition at line 251 of file FieldMultiIndices.hpp.

                                                                     {
    return dofSideMap;
  }

getFieldOrderTable()

FieldOrderTable & MoFEM::Field::getFieldOrderTable ( )

inline

Get field order table.

Returns

Reference to DOF count functions for each entity type

Definition at line 84 of file FieldMultiIndices.hpp.

{ return forderTable; }

getFieldRawPtr()

const Field * MoFEM::Field::getFieldRawPtr ( ) const

inline

Get raw pointer to this field.

Returns

Pointer to this field object

Definition at line 268 of file FieldMultiIndices.hpp.

{ return this; };

getId()

const BitFieldId & MoFEM::Field::getId ( ) const

inline

Get unique field identifier.

Returns

Field ID bitset

Definition at line 105 of file FieldMultiIndices.hpp.

{ return *((BitFieldId *)tagId); }

getMeshset()

EntityHandle MoFEM::Field::getMeshset ( ) const

inline

Get field meshset handle.

On this meshset handle are stored tags with field data about base, space, number of coefficients, continuity, etc.

Meshset contains entities on which the field is defined.

Returns

EntityHandle containing field entities

Definition at line 99 of file FieldMultiIndices.hpp.

{ return meshSet; }

getName()

std::string MoFEM::Field::getName ( ) const

inline

Get field name as string.

Returns

Field name string

Definition at line 119 of file FieldMultiIndices.hpp.

                                   {
    return std::string((char *)tagName, tagNameSize);
  }

getNameRef()

boost::string_ref MoFEM::Field::getNameRef ( ) const

inline

Get field name as string reference.

Returns

Field name string reference

Definition at line 111 of file FieldMultiIndices.hpp.

                                            {
    return boost::string_ref((char *)tagName, tagNameSize);
  }

getNbOfCoeffs()

FieldCoefficientsNumber MoFEM::Field::getNbOfCoeffs ( ) const

inline

Get number of field coefficients per DOF.

Scalar fields have 1 coefficient, vector fields in 3D have 3. Coefficients may represent spatial components, physical quantities, or mixed formulations depending on the field interpretation.

Returns

Number of coefficients

Definition at line 180 of file FieldMultiIndices.hpp.

                                                       {
    return *tagNbCoeffData;
  };

getSpace()

FieldSpace MoFEM::Field::getSpace ( ) const

inline

Get field approximation space.

Returns

Approximation space enumeration

Definition at line 127 of file FieldMultiIndices.hpp.

{ return *tagSpaceData; }

getSpaceName()

auto MoFEM::Field::getSpaceName ( ) const

inline

Get field approximation space name.

Returns

Approximation space name string

Definition at line 133 of file FieldMultiIndices.hpp.

                                   {
    return std::string(FieldSpaceNames[getSpace()]);
  }

rebuildDofsOrderMap()

MoFEMErrorCode MoFEM::Field::rebuildDofsOrderMap

(

)

Rebuild DOF order mapping arrays.

Returns

Error code

Definition at line 517 of file FieldMultiIndices.cpp.

                                          {
  MoFEMFunctionBegin;
 
  for (auto t = MBVERTEX; t != MBMAXTYPE; ++t) {
 
    int DD = 0;
    int nb_last_order_dofs = 0;
    const int rank = (*tagNbCoeffData);
    if (forderTable[t]) {
 
      for (int oo = 0; oo < MAX_DOFS_ON_ENTITY; ++oo) {
 
        const int nb_order_dofs = forderTable[t](oo);
        const int diff_oo = nb_order_dofs - nb_last_order_dofs;
        if (diff_oo >= 0) {
 
          if ((DD + rank * diff_oo) < MAX_DOFS_ON_ENTITY)
            for (int dd = 0; dd < diff_oo; ++dd)
              for (int rr = 0; rr != rank; ++rr, ++DD)
                dofOrderMap[t][DD] = oo;
          else
            break;
 
          nb_last_order_dofs = nb_order_dofs;
 
        } else {
          break;
        }
      }
    }
 
    std::fill(&dofOrderMap[t][DD], dofOrderMap[t].end(), -1);
  }
 
  MoFEMFunctionReturn(0);
}

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream &  os, const Field &  e  )

friend

Output stream operator for field information.

Definition at line 554 of file FieldMultiIndices.cpp.

                                                       {
  os << e.getNameRef() << " field_id " << e.getId().to_ulong() << " space "
     << e.getSpaceName() << " field continuity " << e.getContinuityName()
     << " approximation base " << e.getApproxBaseName() << " nb coefficients "
     << e.getNbOfCoeffs() << " meshset " << e.meshSet;
  return os;
}

Member Data Documentation

bitNumber

unsigned int MoFEM::Field::bitNumber

Bit number corresponding to this field's unique ID.

Definition at line 87 of file FieldMultiIndices.hpp.

dofOrderMap

DofsOrderMap MoFEM::Field::dofOrderMap

mutableprivate

Definition at line 272 of file FieldMultiIndices.hpp.

dofSideMap

std::map<int, BaseFunction::DofsSideMap> MoFEM::Field::dofSideMap

mutableprivate

Definition at line 273 of file FieldMultiIndices.hpp.

forderTable

FieldOrderTable MoFEM::Field::forderTable

DOF count functions for each entity type.

Definition at line 78 of file FieldMultiIndices.hpp.

maxBrokenDofsOrder

constexpr int MoFEM::Field::maxBrokenDofsOrder = 10

staticconstexpr

Maximum order for broken space DOFs.

Definition at line 241 of file FieldMultiIndices.hpp.

meshSet

EntityHandle MoFEM::Field::meshSet

Meshset containing field entities.

Definition at line 59 of file FieldMultiIndices.hpp.

moab

moab::Interface& MoFEM::Field::moab

MOAB interface reference.

Definition at line 57 of file FieldMultiIndices.hpp.

sequenceDofContainer

SequenceDofContainer MoFEM::Field::sequenceDofContainer

mutableprivate

Definition at line 271 of file FieldMultiIndices.hpp.

tagBaseData

FieldApproximationBase* MoFEM::Field::tagBaseData

Field basis functions.

Definition at line 70 of file FieldMultiIndices.hpp.

tagFieldContinuityData

FieldContinuity* MoFEM::Field::tagFieldContinuityData

Field continuity type.

Definition at line 69 of file FieldMultiIndices.hpp.

tagFieldDataVertsType

TagType MoFEM::Field::tagFieldDataVertsType

Tag type for vertex data storage.

Definition at line 61 of file FieldMultiIndices.hpp.

tagId

BitFieldId* MoFEM::Field::tagId

Field unique identifier.

Definition at line 67 of file FieldMultiIndices.hpp.

tagName

const void* MoFEM::Field::tagName

Field name.

Definition at line 74 of file FieldMultiIndices.hpp.

tagNamePrefixData

const void* MoFEM::Field::tagNamePrefixData

Field name prefix.

Definition at line 76 of file FieldMultiIndices.hpp.

tagNamePrefixSize

int MoFEM::Field::tagNamePrefixSize

Field name prefix size in bytes.

Definition at line 77 of file FieldMultiIndices.hpp.

tagNameSize

int MoFEM::Field::tagNameSize

Field name size in bytes.

Definition at line 75 of file FieldMultiIndices.hpp.

tagNbCoeffData

FieldCoefficientsNumber* MoFEM::Field::tagNbCoeffData

Field rank (e.g. Temperature=1, displacement in 3D=3)

Definition at line 73 of file FieldMultiIndices.hpp.

tagSpaceData

FieldSpace* MoFEM::Field::tagSpaceData

Field approximation space.

Definition at line 68 of file FieldMultiIndices.hpp.

th_AppOrder

Tag MoFEM::Field::th_AppOrder

Tag for approximation order on entities.

Definition at line 64 of file FieldMultiIndices.hpp.

th_FieldData

Tag MoFEM::Field::th_FieldData

Tag for field values on entities.

Definition at line 63 of file FieldMultiIndices.hpp.

th_FieldDataVerts

Tag MoFEM::Field::th_FieldDataVerts

Tag for field values on vertices.

Definition at line 62 of file FieldMultiIndices.hpp.

th_FieldRank

Tag MoFEM::Field::th_FieldRank

Tag for field rank (vector dimension)

Definition at line 65 of file FieldMultiIndices.hpp.

---

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

• src/multi_indices/FieldMultiIndices.hpp
• src/multi_indices/impl/FieldMultiIndices.cpp