#include <src/post_proc/PostProcBrokenMeshInMoabBase.hpp>

Inheritance diagram for MoFEM::PostProcGenerateRefMesh< MBEDGE >:

Collaboration diagram for MoFEM::PostProcGenerateRefMesh< MBEDGE >:

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

Member Function Documentation

◆ generateReferenceElementMesh()

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

virtual

Implements MoFEM::PostProcGenerateRefMeshBase.

Definition at line 528 of file PostProcBrokenMeshInMoabBase.cpp.

                                                                             {
  MoFEMFunctionBegin;
 
#ifndef NDEBUG
  if (defMaxLevel > 0)
    MOFEM_LOG("WORLD", Sev::warning)
        << "Refinement for edges is not implemented";
#endif
 
  auto set_gauss_pts = [&](std::map<EntityHandle, int> &little_map) {
    MoFEMFunctionBegin;
 
    int nb_nodes = 2;
    if (hoNodes)
      nb_nodes = 3;
 
    auto &gauss_pts = levelGaussPtsOnRefMesh[0];
    gauss_pts.resize(2, nb_nodes, false);
    gauss_pts.clear();
 
    int nn = 0;
    for (; nn != 2; ++nn) {
      gauss_pts(0, nn) = static_cast<double>(nn);
      little_map[nn] = nn;
    }
 
    if (nn < nb_nodes) {
      gauss_pts(0, nn) = 0.5;
      little_map[nn] = 2;
    }
 
    MoFEMFunctionReturn(0);
  };
 
  auto set_ref_edges = [&](std::map<EntityHandle, int> &little_map) {
    MoFEMFunctionBegin;
 
    int level = 0;
    int nb_edges = level + 1;
 
    int nb_nodes = 2;
    if (hoNodes)
      nb_nodes = 3;
 
    auto &ref_edges = levelRef[level];
    ref_edges.resize(nb_edges, nb_nodes, false);
 
    for (int ee = 0; ee != nb_edges; ++ee) {
      int nn = 0;
      for (; nn != 2; ++nn) {
        ref_edges(ee, nn) = nb_nodes * ee + nn;
      }
      if (nn < nb_nodes) {
        ref_edges(ee, nn) = nb_nodes * ee + 2;
      }
    }
 
    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, 2);
    for (int gg = 0; gg != nb_gauss_pts; ++gg) {
      const double ksi = gauss_pts(0, gg);
      shape_functions(gg, 0) = N_MBEDGE0(ksi);
      shape_functions(gg, 1) = N_MBEDGE1(ksi);
    }
    MoFEMFunctionReturn(0);
  };
 
  levelRef.resize(1);
  levelGaussPtsOnRefMesh.resize(1);
  levelShapeFunctions.resize(1);
 
  std::map<EntityHandle, int> little_map;
  CHKERR set_gauss_pts(little_map);
  CHKERR set_ref_edges(little_map);
  CHKERR set_shape_functions();
 
  MoFEMFunctionReturn(0);
}