#include "src/post_proc/PostProcBrokenMeshInMoabBase.hpp"

Inheritance diagram for MoFEM::PostProcGenerateRefMesh< MBQUAD >:

Collaboration diagram for MoFEM::PostProcGenerateRefMesh< MBQUAD >:

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

Member Function Documentation

◆ generateReferenceElementMesh()

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

virtual

Implements MoFEM::PostProcGenerateRefMeshBase.

Definition at line 410 of file PostProcBrokenMeshInMoabBase.cpp.

                                                                             {
  MoFEMFunctionBegin;
 
#ifndef NDEBUG
  if (defMaxLevel > 0)
    MOFEM_LOG("WORLD", Sev::warning)
        << "Refinement for quad 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
 
    };
    EntityHandle nodes[4];
    for (int nn = 0; nn < 4; nn++)
      CHKERR moab_ref.create_vertex(&base_coords[3 * nn], nodes[nn]);
    EntityHandle quad;
    CHKERR moab_ref.create_element(MBQUAD, nodes, 4, quad);
    MoFEMFunctionReturn(0);
  };
 
  auto add_ho_nodes = [&]() {
    MoFEMFunctionBegin;
    Range quads;
    CHKERR moab_ref.get_entities_by_type(0, MBQUAD, quads, true);
    EntityHandle meshset;
    CHKERR moab_ref.create_meshset(MESHSET_SET, meshset);
    CHKERR moab_ref.add_entities(meshset, quads);
    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 quads;
    CHKERR moab_ref.get_entities_by_type(0, MBQUAD, quads, true);
    Range quads_nodes;
    CHKERR moab_ref.get_connectivity(quads, quads_nodes, false);
    auto &gauss_pts = levelGaussPtsOnRefMesh[0];
    gauss_pts.resize(quads_nodes.size(), 4, false);
    size_t gg = 0;
    for (auto node : quads_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_quads = [&](std::map<EntityHandle, int> &little_map) {
    MoFEMFunctionBegin;
    Range quads;
    CHKERR moab_ref.get_entities_by_type(0, MBQUAD, quads, true);
    size_t hh = 0;
    auto &ref_quads = levelRef[0];
    for (auto quad : quads) {
      const EntityHandle *conn;
      int num_nodes;
      CHKERR moab_ref.get_connectivity(quad, conn, num_nodes, false);
      if (ref_quads.size2() != num_nodes) {
        ref_quads.resize(quads.size(), num_nodes);
      }
      for (int nn = 0; nn != num_nodes; ++nn) {
        ref_quads(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, 4);
    for (int gg = 0; gg != nb_gauss_pts; ++gg) {
      const double ksi = gauss_pts(0, gg);
      const double zeta = gauss_pts(1, gg);
      shape_functions(gg, 0) = N_MBQUAD0(ksi, zeta);
      shape_functions(gg, 1) = N_MBQUAD1(ksi, zeta);
      shape_functions(gg, 2) = N_MBQUAD2(ksi, zeta);
      shape_functions(gg, 3) = N_MBQUAD3(ksi, 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_quads(little_map);
  CHKERR set_shape_functions();
 
  MoFEMFunctionReturn(0);
}