#include "src/post_proc/PostProcBrokenMeshInMoabBase.hpp"

Inheritance diagram for MoFEM::PostProcGenerateRefMesh< MBPRISM >:

Collaboration diagram for MoFEM::PostProcGenerateRefMesh< MBPRISM >:

Public Member Functions
MoFEMErrorCode	generateReferenceElementMesh ()

	PostProcGenerateRefMeshBase ()

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

virtual	~PostProcGenerateRefMeshBase ()=default

virtual MoFEMErrorCode	getOptions (std::string prefix)

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 77 of file PostProcBrokenMeshInMoabBase.hpp.

Member Function Documentation

◆ generateReferenceElementMesh()

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

virtual

Implements MoFEM::PostProcGenerateRefMeshBase.

Definition at line 262 of file PostProcBrokenMeshInMoabBase.cpp.

                                                               {
  MoFEMFunctionBegin;
 
#ifndef NDEBUG
  if (defMaxLevel > 0)
    MOFEM_LOG("WORLD", Sev::warning)
        << "Refinement for prisms 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, 0, 1, 0,
                                      0, 0, 1, 1, 0, 1, 0, 1, 1};
    EntityHandle nodes[6];
    for (int nn = 0; nn != 6; ++nn)
      CHKERR moab_ref.create_vertex(&base_coords[3 * nn], nodes[nn]);
    EntityHandle prism;
    CHKERR moab_ref.create_element(MBPRISM, nodes, 6, prism);
    MoFEMFunctionReturn(0);
  };
 
  auto add_ho_nodes = [&]() {
    MoFEMFunctionBegin;
    Range prisms;
    CHKERR moab_ref.get_entities_by_type(0, MBPRISM, prisms, true);
    EntityHandle meshset;
    CHKERR moab_ref.create_meshset(MESHSET_SET, meshset);
    CHKERR moab_ref.add_entities(meshset, prisms);
    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 prisms;
    CHKERR moab_ref.get_entities_by_type(0, MBPRISM, prisms, true);
    Range prism_nodes;
    CHKERR moab_ref.get_connectivity(prisms, prism_nodes, false);
    auto &gauss_pts = levelGaussPtsOnRefMesh[0];
    gauss_pts.resize(prism_nodes.size(), 4, false);
    size_t gg = 0;
    for (auto node : prism_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_prisms = [&](std::map<EntityHandle, int> &little_map) {
    MoFEMFunctionBegin;
    Range prisms;
    CHKERR moab_ref.get_entities_by_type(0, MBPRISM, prisms, true);
    size_t pp = 0;
    auto &ref_prisms = levelRef[0];
    for (auto prism : prisms) {
      const EntityHandle *conn;
      int num_nodes;
      CHKERR moab_ref.get_connectivity(prism, conn, num_nodes, false);
      if (ref_prisms.size2() != num_nodes)
        ref_prisms.resize(prisms.size(), num_nodes);
      for (int nn = 0; nn != num_nodes; ++nn)
        ref_prisms(pp, nn) = little_map[conn[nn]];
      ++pp;
    }
    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, 6);
    for (int gg = 0; gg != nb_gauss_pts; ++gg) {
      const double ksi = gauss_pts(0, gg);
      const double eta = gauss_pts(1, gg);
      const double zeta = gauss_pts(2, gg);
      const double n0 = 1 - ksi - eta;
      shape_functions(gg, 0) = n0 * (1 - zeta);
      shape_functions(gg, 1) = ksi * (1 - zeta);
      shape_functions(gg, 2) = eta * (1 - zeta);
      shape_functions(gg, 3) = n0 * zeta;
      shape_functions(gg, 4) = ksi * zeta;
      shape_functions(gg, 5) = eta * zeta;
    }
    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_prisms(little_map);
  CHKERR set_shape_functions();
 
  MoFEMFunctionReturn(0);
}