Provide data structure for (tensor) field approximation. More...

#include "src/multi_indices/FieldMultiIndices.hpp"

Collaboration diagram for MoFEM::Field:

Public Types
using	SequenceDofContainer

using	DofsOrderMap

Public Member Functions
	Field (moab::Interface &moab, const EntityHandle meshset)
	constructor for moab field

virtual	~Field ()=default

FieldOrderTable &	getFieldOrderTable ()
	Get the Field Order Table.

EntityHandle	getMeshset () const
	Get field meshset.

const BitFieldId &	getId () const
	Get unique field id.

boost::string_ref	getNameRef () const
	Get string reference to field name.

std::string	getName () const
	Get field name.

FieldSpace	getSpace () const
	Get field approximation space.

auto	getSpaceName () const
	Get field approximation space.

FieldContinuity	getContinuity () const
	Get field space continuity.

auto	getContinuityName () const
	Get field space continuity name.

FieldApproximationBase	getApproxBase () const
	Get approximation base.

auto	getApproxBaseName () const
	Get approximation base.

FieldCoefficientsNumber	getNbOfCoeffs () const
	Get number of field coefficients.

FieldBitNumber	getBitNumber () const
	Get number of set bit in Field ID. Each field has uid, get getBitNumber get number of bit set for given field. Field ID has only one bit set for each field.

FieldBitNumber	getBitNumberCalculate () const
	Calculate number of set bit in Field ID. Each field has uid, get getBitNumber get number of bit set for given field. Field ID has only one bit set for each field.

SequenceDofContainer &	getDofSequenceContainer () const
	Get reference to sequence data container.

const std::array< ApproximationOrder, MAX_DOFS_ON_ENTITY > &	getDofOrderMap (const EntityType type) const
	get hash-map relating dof index on entity with its order

const DofsOrderMap &	getDofOrderMap () const
	get hash-map relating dof index on entity with its order

std::map< int, BaseFunction::DofsSideMap > &	getDofSideMap () const
	Get the dofs side map.

MoFEMErrorCode	rebuildDofsOrderMap ()

const Field *	getFieldRawPtr () const

Static Public Member Functions
static FieldBitNumber	getBitNumberCalculate (const BitFieldId &id)
	Calculate number of set bit in Field ID. Each field has uid, get getBitNumber get number of bit set for given field. Field ID has only one bit set for each field.

Public Attributes
moab::Interface &	moab

EntityHandle	meshSet
	keeps entities for this meshset

TagType	tagFieldDataVertsType

Tag	th_FieldDataVerts
	Tag storing field values on vertices in the field.

Tag	th_FieldData
	Tag storing field values on entity in the field.

Tag	th_AppOrder
	Tag storing approximation order on entity.

Tag	th_FieldRank

BitFieldId *	tagId
	Tag field rank.

FieldSpace *	tagSpaceData
	tag keeps field space

FieldContinuity *	tagFieldContinuityData
	tag keeps field continuity

FieldApproximationBase *	tagBaseData
	tag keeps field base

FieldCoefficientsNumber *	tagNbCoeffData

const void *	tagName
	tag keeps name of the field

int	tagNameSize
	number of bits necessary to keep field name

const void *	tagNamePrefixData
	tag keeps name prefix of the field

int	tagNamePrefixSize

FieldOrderTable	forderTable
	nb. DOFs table for entities

unsigned int	bitNumber

Static Public Attributes
static constexpr int	maxBrokenDofsOrder = 10
	max number of broken dofs

Private Attributes
SequenceDofContainer	sequenceDofContainer

DofsOrderMap	dofOrderMap

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

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

Detailed Description

Provide data structure for (tensor) field approximation.

The Field is intended to provide support for fields, with a strong bias towards supporting first and best the capabilities required for scientific computing applications. Since we work with discrete spaces, data structure has to carry information about type of approximation space, its regularity.

Field data structure storing information about space, approximation base, coordinate systems, etc. It stores additional data needed for book keeping, like tags to data on the mesh.

Each field has unique ID and name. This data structure is shared between entities on which is spanning and DOFs on those entities.

Examples: EshelbianPlasticity.cpp, forces_and_sources_testing_users_base.cpp, and scalar_check_approximation.cpp.

Definition at line 51 of file FieldMultiIndices.hpp.

Member Typedef Documentation

◆ DofsOrderMap

using MoFEM::Field::DofsOrderMap

Initial value:

std::array<std::array<int, MAX_DOFS_ON_ENTITY>, MBMAXTYPE>

Definition at line 68 of file FieldMultiIndices.hpp.

◆ SequenceDofContainer

using MoFEM::Field::SequenceDofContainer

Initial value:

 multi_index_container<
 
      boost::weak_ptr<std::vector<DofEntity>>,
 
      indexed_by<sequenced<>>>

Definition at line 62 of file FieldMultiIndices.hpp.

Constructor & Destructor Documentation

◆ Field()

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

constructor for moab field

Parameters

meshset which keeps entities for this field

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

Member Function Documentation

◆ getApproxBase()

FieldApproximationBase MoFEM::Field::getApproxBase ( ) const

inline

Get approximation base.

Returns: Approximation base

Definition at line 178 of file FieldMultiIndices.hpp.

178{ return *tagBaseData; }

◆ getApproxBaseName()

auto MoFEM::Field::getApproxBaseName ( ) const

inline

Get approximation base.

Returns: Approximation base name

Definition at line 184 of file FieldMultiIndices.hpp.

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

◆ getBitNumber()

FieldBitNumber MoFEM::Field::getBitNumber ( ) const

inline

Get number of set bit in Field ID. Each field has uid, get getBitNumber get number of bit set for given field. Field ID has only one bit set for each field.

Definition at line 211 of file FieldMultiIndices.hpp.

211{ return bitNumber; }

◆ getBitNumberCalculate() [1/2]

FieldBitNumber MoFEM::Field::getBitNumberCalculate ( ) const

inline

Calculate number of set bit in Field ID. Each field has uid, get getBitNumber get number of bit set for given field. Field ID has only one bit set for each field.

Definition at line 232 of file FieldMultiIndices.hpp.

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

◆ getBitNumberCalculate() [2/2]

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

inlinestatic

Calculate number of set bit in Field ID. Each field has uid, get getBitNumber get number of bit set for given field. Field ID has only one bit set for each field.

Definition at line 218 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 space continuity.

Definition at line 162 of file FieldMultiIndices.hpp.

                                               {
    return *tagFieldContinuityData;
  }

◆ getContinuityName()

auto MoFEM::Field::getContinuityName ( ) const

inline

Get field space continuity name.

Definition at line 170 of file FieldMultiIndices.hpp.

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

◆ getDofOrderMap() [1/2]

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

inline

get hash-map relating dof index on entity with its order

Dofs of given field are indexed on entity of the same type, same space, approximation base and number of coefficients, are sorted in the way.

Definition at line 280 of file FieldMultiIndices.hpp.

280{ return dofOrderMap; }

MoFEM::Field::dofOrderMap

DofsOrderMap dofOrderMap

Definition FieldMultiIndices.hpp:304

◆ getDofOrderMap() [2/2]

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

inline

get hash-map relating dof index on entity with its order

Dofs of given field are indexed on entity of the same type, same space, approximation base and number of coefficients, are sorted in the way.

Examples: forces_and_sources_testing_users_base.cpp.

Definition at line 268 of file FieldMultiIndices.hpp.

                                              {
    return dofOrderMap[type];
  }

◆ getDofSequenceContainer()

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

inline

Get reference to sequence data container.

In sequence data container data are physically stored. The purpose of this is to allocate DofEntity data in bulk, having only one allocation instead each time entity is inserted. That makes code efficient.

The vector in sequence is destroyed if last entity inside that vector is destroyed. All MoFEM::MoFEMEntities have aliased shared_ptr which points to the vector.

Not all DOFs are stored in this way, currently such cases are considered;

DOFs on vertices. That is exploited that for H1 space, there is some fixed number of DOFs on each vertex

For other cases, DOFs are stored locally in each MoFEM::MoFEMEntities.

Returns: MoFEM::Field::SequenceDofContainer

Definition at line 255 of file FieldMultiIndices.hpp.

                                                               {
    return sequenceDofContainer;
  }

◆ getDofSideMap()

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

inline

Get the dofs side map.

This establish connection between dofs in the interior of broken specs and entity on which trace of the dof is nonzero.

Returns: const BaseFunction::DofsSideMap&

Definition at line 292 of file FieldMultiIndices.hpp.

                                                                     {
    return dofSideMap;
  }

◆ getFieldOrderTable()

FieldOrderTable & MoFEM::Field::getFieldOrderTable ( )

inline

Get the Field Order Table.

Returns: FieldOrderTable&

Definition at line 101 of file FieldMultiIndices.hpp.

101{ return forderTable; }

◆ getFieldRawPtr()

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

inline

Definition at line 300 of file FieldMultiIndices.hpp.

300{ return this; };

◆ getId()

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

inline

Get unique field id.

Returns: Filed ID

Definition at line 129 of file FieldMultiIndices.hpp.

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

◆ getMeshset()

EntityHandle MoFEM::Field::getMeshset ( ) const

inline

Get field meshset.

To meshsets entity are attached Tags which keeps basic information about field. Those information is field name, approximation base, approximation space, id, etc.

In meshset contains entities on which given field is sparing. Type of entities depended on approximations space.

Returns: EntityHandle

Definition at line 123 of file FieldMultiIndices.hpp.

123{ return meshSet; }

◆ getName()

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

inline

Get field name.

Returns: Field name

Definition at line 143 of file FieldMultiIndices.hpp.

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

◆ getNameRef()

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

inline

Get string reference to field name.

Returns: Field name

Definition at line 135 of file FieldMultiIndices.hpp.

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

◆ getNbOfCoeffs()

FieldCoefficientsNumber MoFEM::Field::getNbOfCoeffs ( ) const

inline

Get number of field coefficients.

Scalar field has only one coefficient, vector field in 3D has three. In general number determine space needed to keep data on entities. What coefficient means depend on interpretation and associated coordinate system. For example 3 coefficient means could be covariant or contravariant, or mean three temperatures for mixture of solid, air and water, etc.

Definition at line 202 of file FieldMultiIndices.hpp.

                                                       {
    return *tagNbCoeffData;
  };

◆ getSpace()

FieldSpace MoFEM::Field::getSpace ( ) const

inline

Get field approximation space.

Returns: approximation space

Definition at line 151 of file FieldMultiIndices.hpp.

151{ return *tagSpaceData; }

◆ getSpaceName()

auto MoFEM::Field::getSpaceName ( ) const

inline

Get field approximation space.

Returns: approximation space name

Definition at line 157 of file FieldMultiIndices.hpp.

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

◆ rebuildDofsOrderMap()

MoFEMErrorCode MoFEM::Field::rebuildDofsOrderMap ( )

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

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

Field Id is bit set. Each field has only one bit on, bitNumber stores number of set bit

Definition at line 107 of file FieldMultiIndices.hpp.

◆ dofOrderMap

DofsOrderMap MoFEM::Field::dofOrderMap

mutableprivate

Definition at line 304 of file FieldMultiIndices.hpp.

◆ dofSideMap

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

mutableprivate

Definition at line 305 of file FieldMultiIndices.hpp.

◆ forderTable

FieldOrderTable MoFEM::Field::forderTable

nb. DOFs table for entities

Definition at line 94 of file FieldMultiIndices.hpp.

◆ maxBrokenDofsOrder

int MoFEM::Field::maxBrokenDofsOrder = 10

staticconstexpr

max number of broken dofs

Definition at line 282 of file FieldMultiIndices.hpp.

◆ meshSet

EntityHandle MoFEM::Field::meshSet

keeps entities for this meshset

Definition at line 73 of file FieldMultiIndices.hpp.

◆ moab

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

Definition at line 71 of file FieldMultiIndices.hpp.

◆ sequenceDofContainer

SequenceDofContainer MoFEM::Field::sequenceDofContainer

mutableprivate

Definition at line 303 of file FieldMultiIndices.hpp.

◆ tagBaseData

FieldApproximationBase* MoFEM::Field::tagBaseData

tag keeps field base

Definition at line 84 of file FieldMultiIndices.hpp.

◆ tagFieldContinuityData

FieldContinuity* MoFEM::Field::tagFieldContinuityData

tag keeps field continuity

Definition at line 83 of file FieldMultiIndices.hpp.

◆ tagFieldDataVertsType

TagType MoFEM::Field::tagFieldDataVertsType

Definition at line 75 of file FieldMultiIndices.hpp.

◆ tagId

BitFieldId* MoFEM::Field::tagId

Tag field rank.

tag keeps field id

Definition at line 81 of file FieldMultiIndices.hpp.

◆ tagName

const void* MoFEM::Field::tagName

tag keeps name of the field

Definition at line 89 of file FieldMultiIndices.hpp.

◆ tagNamePrefixData

const void* MoFEM::Field::tagNamePrefixData

tag keeps name prefix of the field

Definition at line 91 of file FieldMultiIndices.hpp.

◆ tagNamePrefixSize

int MoFEM::Field::tagNamePrefixSize

number of bits necessary to keep field name prefix

Definition at line 92 of file FieldMultiIndices.hpp.

◆ tagNameSize

int MoFEM::Field::tagNameSize

number of bits necessary to keep field name

Definition at line 90 of file FieldMultiIndices.hpp.

◆ tagNbCoeffData

FieldCoefficientsNumber* MoFEM::Field::tagNbCoeffData

tag keeps field rank (dimension, f.e. Temperature field has rank 1, displacements field in 3d has rank 3)

Definition at line 88 of file FieldMultiIndices.hpp.

◆ tagSpaceData

FieldSpace* MoFEM::Field::tagSpaceData

tag keeps field space

Definition at line 82 of file FieldMultiIndices.hpp.

◆ th_AppOrder

Tag MoFEM::Field::th_AppOrder

Tag storing approximation order on entity.

Definition at line 78 of file FieldMultiIndices.hpp.

◆ th_FieldData

Tag MoFEM::Field::th_FieldData

Tag storing field values on entity in the field.

Definition at line 77 of file FieldMultiIndices.hpp.

◆ th_FieldDataVerts

Tag MoFEM::Field::th_FieldDataVerts

Tag storing field values on vertices in the field.

Definition at line 76 of file FieldMultiIndices.hpp.

◆ th_FieldRank

Tag MoFEM::Field::th_FieldRank

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

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ DofsOrderMap

◆ SequenceDofContainer

Constructor & Destructor Documentation

◆ Field()

◆ ~Field()

Member Function Documentation

◆ getApproxBase()

◆ getApproxBaseName()

◆ getBitNumber()

◆ getBitNumberCalculate() [1/2]

◆ getBitNumberCalculate() [2/2]

◆ getContinuity()

◆ getContinuityName()

◆ getDofOrderMap() [1/2]

◆ getDofOrderMap() [2/2]

◆ getDofSequenceContainer()

◆ getDofSideMap()

◆ getFieldOrderTable()

◆ getFieldRawPtr()

◆ getId()

◆ getMeshset()

◆ getName()

◆ getNameRef()

◆ getNbOfCoeffs()

◆ getSpace()

◆ getSpaceName()

◆ rebuildDofsOrderMap()

Friends And Related Symbol Documentation

◆ operator<<

Member Data Documentation

◆ bitNumber

◆ dofOrderMap

◆ dofSideMap

◆ forderTable

◆ maxBrokenDofsOrder

◆ meshSet

◆ moab

◆ sequenceDofContainer

◆ tagBaseData

◆ tagFieldContinuityData

◆ tagFieldDataVertsType

◆ tagId

◆ tagName

◆ tagNamePrefixData

◆ tagNamePrefixSize

◆ tagNameSize

◆ tagNbCoeffData

◆ tagSpaceData

◆ th_AppOrder

◆ th_FieldData

◆ th_FieldDataVerts

◆ th_FieldRank