#include <src/post_proc/PostProcBrokenMeshInMoabBase.hpp>

Inheritance diagram for MoFEM::PostProcGenerateRefMesh< MBHEX >:

Collaboration diagram for MoFEM::PostProcGenerateRefMesh< MBHEX >:

Public Member Functions
MoFEMErrorCode	generateReferenceElementMesh ()

	PostProcGenerateRefMeshBase ()

Public Member Functions inherited from MoFEM::PostProcGenerateRefMeshBase
	PostProcGenerateRefMeshBase ()

virtual	~PostProcGenerateRefMeshBase ()=default

virtual MoFEMErrorCode	getOptions (std::string prefix)

virtual MoFEMErrorCode	generateReferenceElementMesh ()=0

Additional Inherited Members
Public Attributes inherited from MoFEM::PostProcGenerateRefMeshBase
std::vector< MatrixDouble >	levelShapeFunctions

std::vector< MatrixDouble >	levelGaussPtsOnRefMesh

std::vector< ublas::matrix< int > >	levelRef

EntityHandle	startingVertEleHandle

std::vector< double * >	verticesOnEleArrays

EntityHandle	startingEleHandle

EntityHandle *	eleConn

int	countEle

int	countVertEle

int	nbVertices

int	nbEles

PetscBool	hoNodes

int	defMaxLevel

Detailed Description

Definition at line 71 of file PostProcBrokenMeshInMoabBase.hpp.

Member Function Documentation

◆ generateReferenceElementMesh()

MoFEMErrorCode MoFEM::PostProcGenerateRefMesh< MBHEX >::generateReferenceElementMesh ( )

virtual

Implements MoFEM::PostProcGenerateRefMeshBase.

Definition at line 147 of file PostProcBrokenMeshInMoabBase.cpp.

                                                                            {
  MoFEMFunctionBegin;
 
#ifndef NDEBUG
  if (defMaxLevel > 0)
    MOFEM_LOG("WORLD", Sev::warning)
        << "Refinement for hexes is not implemented";
#endif
 
  moab::Core core_ref;
  moab::Interface &moab_ref = core_ref;
 
  auto create_reference_element = [&moab_ref]() {
    MoFEMFunctionBegin;
    constexpr double base_coords[] = {0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0,
                                      0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1};
    EntityHandle nodes[8];
    for (int nn = 0; nn < 8; nn++)
      CHKERR moab_ref.create_vertex(&base_coords[3 * nn], nodes[nn]);
    EntityHandle hex;
    CHKERR moab_ref.create_element(MBHEX, nodes, 8, hex);
    MoFEMFunctionReturn(0);
  };
 
  auto add_ho_nodes = [&]() {
    MoFEMFunctionBegin;
    Range hexes;
    CHKERR moab_ref.get_entities_by_type(0, MBHEX, hexes, true);
    EntityHandle meshset;
    CHKERR moab_ref.create_meshset(MESHSET_SET, meshset);
    CHKERR moab_ref.add_entities(meshset, hexes);
    CHKERR moab_ref.convert_entities(meshset, true, true, true);
    CHKERR moab_ref.delete_entities(&meshset, 1);
    MoFEMFunctionReturn(0);
  };
 
  auto set_gauss_pts = [&](std::map<EntityHandle, int> &little_map) {
    MoFEMFunctionBegin;
    Range hexes;
    CHKERR moab_ref.get_entities_by_type(0, MBHEX, hexes, true);
    Range hexes_nodes;
    CHKERR moab_ref.get_connectivity(hexes, hexes_nodes, false);
    auto &gauss_pts = levelGaussPtsOnRefMesh[0];
    gauss_pts.resize(hexes_nodes.size(), 4, false);
    size_t gg = 0;
    for (auto node : hexes_nodes) {
      CHKERR moab_ref.get_coords(&node, 1, &gauss_pts(gg, 0));
      little_map[node] = gg;
      ++gg;
    }
    gauss_pts = trans(gauss_pts);
    MoFEMFunctionReturn(0);
  };
 
  auto set_ref_hexes = [&](std::map<EntityHandle, int> &little_map) {
    MoFEMFunctionBegin;
    Range hexes;
    CHKERR moab_ref.get_entities_by_type(0, MBHEX, hexes, true);
    size_t hh = 0;
    auto &ref_hexes = levelRef[0];
    for (auto hex : hexes) {
      const EntityHandle *conn;
      int num_nodes;
      CHKERR moab_ref.get_connectivity(hex, conn, num_nodes, false);
      if (ref_hexes.size2() != num_nodes) {
        ref_hexes.resize(hexes.size(), num_nodes);
      }
      for (int nn = 0; nn != num_nodes; ++nn) {
        ref_hexes(hh, nn) = little_map[conn[nn]];
      }
      ++hh;
    }
    MoFEMFunctionReturn(0);
  };
 
  auto set_shape_functions = [&]() {
    MoFEMFunctionBegin;
    auto &gauss_pts = levelGaussPtsOnRefMesh[0];
    auto &shape_functions = levelShapeFunctions[0];
    const auto nb_gauss_pts = gauss_pts.size2();
    shape_functions.resize(nb_gauss_pts, 8);
    for (int gg = 0; gg != nb_gauss_pts; ++gg) {
      const double ksi = gauss_pts(0, gg);
      const double zeta = gauss_pts(1, gg);
      const double eta = gauss_pts(2, gg);
      shape_functions(gg, 0) = N_MBHEX0(ksi, zeta, eta);
      shape_functions(gg, 1) = N_MBHEX1(ksi, zeta, eta);
      shape_functions(gg, 2) = N_MBHEX2(ksi, zeta, eta);
      shape_functions(gg, 3) = N_MBHEX3(ksi, zeta, eta);
      shape_functions(gg, 4) = N_MBHEX4(ksi, zeta, eta);
      shape_functions(gg, 5) = N_MBHEX5(ksi, zeta, eta);
      shape_functions(gg, 6) = N_MBHEX6(ksi, zeta, eta);
      shape_functions(gg, 7) = N_MBHEX7(ksi, zeta, eta);
    }
    MoFEMFunctionReturn(0);
  };
 
  levelRef.resize(1);
  levelGaussPtsOnRefMesh.resize(1);
  levelShapeFunctions.resize(1);
 
  CHKERR create_reference_element();
  if (hoNodes)
    CHKERR add_ho_nodes();
  std::map<EntityHandle, int> little_map;
  CHKERR set_gauss_pts(little_map);
  CHKERR set_ref_hexes(little_map);
  CHKERR set_shape_functions();
 
  MoFEMFunctionReturn(0);
}