MoFEM::ParentFiniteElementAdjacencyFunction< DIM > Struct Template Reference

Create adjacency to parent elements. More...

#include "src/finite_elements/MeshProjectionDataOperators.hpp"

Inheritance diagram for MoFEM::ParentFiniteElementAdjacencyFunction< DIM >:

Collaboration diagram for MoFEM::ParentFiniteElementAdjacencyFunction< DIM >:

Public Member Functions
	ParentFiniteElementAdjacencyFunction (BitRefLevel bit_parent, BitRefLevel bit_parent_mask, BitRefLevel bit_ent, BitRefLevel bit_ent_mask)
MoFEMErrorCode	operator() (moab::Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)
	Function setting adjacencies to DOFs of parent element.

Protected Member Functions
MoFEMErrorCode	getParent (EntityHandle fe, std::vector< EntityHandle > &parents, moab::Interface &moab, Tag th_parent_handle, Tag th_bit_level)
MoFEMErrorCode	getParentsAdjacencies (const Field &field, moab::Interface &moab, std::vector< EntityHandle > &parents, std::vector< EntityHandle > &adjacency)
MoFEMErrorCode	getDefaultAdjacencies (moab::Interface &moab, const Field &field, const EntFiniteElement &fe, std::vector< EntityHandle > &adjacency)

Protected Attributes
BitRefLevel	bitParent
BitRefLevel	bitParentMask
BitRefLevel	bitEnt
BitRefLevel	bitEntMask
std::vector< EntityHandle >	adjTmp

Detailed Description

template<int DIM>
struct MoFEM::ParentFiniteElementAdjacencyFunction< DIM >

Create adjacency to parent elements.

That class is used during entity finite element construction.

Template Parameters

DIM	dimension of parent element

Definition at line 20 of file Simple.hpp.

Constructor & Destructor Documentation

ParentFiniteElementAdjacencyFunction()

template<int DIM>

MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::ParentFiniteElementAdjacencyFunction ( BitRefLevel bit_parent, BitRefLevel bit_parent_mask, BitRefLevel bit_ent, BitRefLevel bit_ent_mask )

inline

Definition at line 135 of file MeshProjectionDataOperators.hpp.

      : bitParent(bit_parent), bitParentMask(bit_parent_mask), bitEnt(bit_ent),
        bitEntMask(bit_ent_mask) {}

Member Function Documentation

getDefaultAdjacencies()

template<int DIM>

MoFEMErrorCode MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::getDefaultAdjacencies ( moab::Interface & moab, const Field & field, const EntFiniteElement & fe, std::vector< EntityHandle > & adjacency )

inlineprotected

Definition at line 282 of file MeshProjectionDataOperators.hpp.

                                                                           {
    MoFEMFunctionBegin;
    if constexpr (DIM == 3)
      CHKERR DefaultElementAdjacency::defaultVolume(moab, field, fe, adjacency);
    if constexpr (DIM == 2)
      CHKERR DefaultElementAdjacency::defaultFace(moab, field, fe, adjacency);
    else if constexpr (DIM == 1)
      CHKERR DefaultElementAdjacency::defaultEdge(moab, field, fe, adjacency);
    else if constexpr (DIM == 0)
      CHKERR DefaultElementAdjacency::defaultVertex(moab, field, fe, adjacency);
    MoFEMFunctionReturn(0);
  };

getParent()

template<int DIM>

MoFEMErrorCode MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::getParent ( EntityHandle fe, std::vector< EntityHandle > & parents, moab::Interface & moab, Tag th_parent_handle, Tag th_bit_level )

inlineprotected

this function os called recursively, until all stack of parents is found.

Definition at line 198 of file MeshProjectionDataOperators.hpp.

                                             {
    MoFEMFunctionBegin;
 
    auto check = [](auto &b, auto &m, auto &bit) {
      return ((bit & b).any()) && ((bit & m) == bit);
    };
 
    BitRefLevel bit_fe;
    CHKERR moab.tag_get_data(th_bit_level, &fe, 1, &bit_fe);
    if (check(bitEnt, bitEntMask, bit_fe)) {
 
      using GetParent = boost::function<MoFEMErrorCode(
          EntityHandle fe, std::vector<EntityHandle> & parents)>;
      /**
       * @brief this function os called recursively, until all stack of parents
       * is found.
       *
       */
      GetParent get_parent = [&](EntityHandle fe,
                                 std::vector<EntityHandle> &parents) {
        MoFEMFunctionBegin;
        EntityHandle fe_parent;
 
        CHKERR moab.tag_get_data(th_parent_handle, &fe, 1, &fe_parent);
        auto parent_type = type_from_handle(fe_parent);
        auto back_type = type_from_handle(fe);
        BitRefLevel bit_parent;
        CHKERR moab.tag_get_data(th_bit_level, &fe_parent, 1, &bit_parent);
        if (check(bitParent, bitParentMask, bit_parent)) {
          if ((fe_parent != 0) && (fe_parent != fe) &&
              (parent_type == back_type)) {
            parents.push_back(fe_parent);
            CHKERR get_parent(parents.back(), parents);
          }
        }
        MoFEMFunctionReturn(0);
      };
 
      CHKERR get_parent(fe, parents);
    }
    MoFEMFunctionReturn(0);
  }

getParentsAdjacencies()

template<int DIM>

MoFEMErrorCode MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::getParentsAdjacencies ( const Field & field, moab::Interface & moab, std::vector< EntityHandle > & parents, std::vector< EntityHandle > & adjacency )

inlineprotected

Definition at line 243 of file MeshProjectionDataOperators.hpp.

                                                                           {
    MoFEMFunctionBegin;
 
    switch (field.getSpace()) {
    case H1:
      for (int i = 0; i != parents.size(); ++i)
        CHKERR moab.get_connectivity(&*parents.begin(), parents.size(),
                                     adjacency, true);
    case HCURL:
      if constexpr (DIM >= 1)
        for (auto fe_ent : parents)
          CHKERR moab.get_adjacencies(&fe_ent, 1, 1, false, adjacency,
                                      moab::Interface::UNION);
    case HDIV:
      if constexpr (DIM == 2)
        for (auto fe_ent : parents)
          CHKERR moab.get_adjacencies(&fe_ent, 1, 2, false, adjacency,
                                      moab::Interface::UNION);
    case L2:
      for (auto fe_ent : parents)
        adjacency.push_back(fe_ent);
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "this field is not implemented for face finite element");
    }
 
    if (adjacency.size()) {
      std::sort(adjacency.begin(), adjacency.end());
      auto it = std::unique(adjacency.begin(), adjacency.end());
      adjacency.resize(std::distance(adjacency.begin(), it));
    }
 
    MoFEMFunctionReturn(0);
  }

operator()()

template<int DIM>

MoFEMErrorCode MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::operator() ( moab::Interface & moab, const Field & field, const EntFiniteElement & fe, std::vector< EntityHandle > & adjacency )

inline

Function setting adjacencies to DOFs of parent element.

Note

elements form child, see dofs from parent, so DOFs located on adjacencies of parent entity has adjacent to dofs of child.

Template Parameters

DIM	dimension of the element entity

Parameters

moab
field
fe
adjacency

Returns

MoFEMErrorCode

Definition at line 155 of file MeshProjectionDataOperators.hpp.

                                                                {
    MoFEMFunctionBegin;
 
    static_assert(DIM >= 0 && DIM <= 3, "DIM is out of scope");
 
    adjacency.clear();
 
    if (field.getSpace() != NOFIELD) {
 
      auto basic_entity_data_ptr = fe.getBasicDataPtr();
      auto th_parent_handle = basic_entity_data_ptr->th_RefParentHandle;
      auto th_bit_level = basic_entity_data_ptr->th_RefBitLevel;
 
      std::vector<EntityHandle> parents;
      parents.reserve(BITREFLEVEL_SIZE);
 
      CHKERR getParent(fe.getEnt(), parents, moab, th_parent_handle,
                       th_bit_level);
 
      CHKERR getParentsAdjacencies(field, moab, parents, adjacency);
    }
 
    adjTmp.clear();
    CHKERR getDefaultAdjacencies(moab, field, fe, adjTmp);
    adjacency.insert(adjacency.end(), adjTmp.begin(), adjTmp.end());
 
    std::sort(adjacency.begin(), adjacency.end());
    auto it = std::unique(adjacency.begin(), adjacency.end());
    adjacency.resize(std::distance(adjacency.begin(), it));
 
    for (auto e : adjacency) {
      auto &side_table = fe.getSideNumberTable();
      if (side_table.find(e) == side_table.end())
        const_cast<SideNumber_multiIndex &>(side_table)
            .insert(boost::shared_ptr<SideNumber>(new SideNumber(e, -1, 0, 0)));
    }
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

adjTmp

template<int DIM>

std::vector<EntityHandle> MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::adjTmp

protected

Definition at line 302 of file MeshProjectionDataOperators.hpp.

bitEnt

template<int DIM>

BitRefLevel MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::bitEnt

protected

Definition at line 300 of file MeshProjectionDataOperators.hpp.

bitEntMask

template<int DIM>

BitRefLevel MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::bitEntMask

protected

Definition at line 301 of file MeshProjectionDataOperators.hpp.

bitParent

template<int DIM>

BitRefLevel MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::bitParent

protected

Definition at line 298 of file MeshProjectionDataOperators.hpp.

bitParentMask

template<int DIM>

BitRefLevel MoFEM::ParentFiniteElementAdjacencyFunction< DIM >::bitParentMask

protected

Definition at line 299 of file MeshProjectionDataOperators.hpp.

---

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

• src/finite_elements/MeshProjectionDataOperators.hpp
• src/interfaces/Simple.hpp