#include "src/post_proc/PostProcBrokenMeshInMoabBase.hpp"

Inheritance diagram for MoFEM::PostProcGenerateRefMesh< MBTRI >:

Collaboration diagram for MoFEM::PostProcGenerateRefMesh< MBTRI >:

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< MBTRI >::generateReferenceElementMesh ( )

virtual

Implements MoFEM::PostProcGenerateRefMeshBase.

Definition at line 261 of file PostProcBrokenMeshInMoabBase.cpp.

                                                                            {
  MoFEMFunctionBegin;
 
  const int max_level = defMaxLevel;
 
  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
 
    };
    EntityHandle nodes[3];
    for (int nn = 0; nn != 3; ++nn)
      CHKERR moab_ref.create_vertex(&base_coords[3 * nn], nodes[nn]);
    EntityHandle tri;
    CHKERR moab_ref.create_element(MBTRI, nodes, 3, tri);
 
    Range edges;
    CHKERR moab_ref.get_adjacencies(&tri, 1, 1, true, edges,
                                    moab::Interface::UNION);
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR create_reference_element();
 
  MoFEM::CoreTmp<-1> m_core_ref(moab_ref, PETSC_COMM_SELF, -2);
  MoFEM::Interface &m_field_ref = m_core_ref;
 
  auto refine_ref_triangles = [this, &m_field_ref, max_level]() {
    MoFEMFunctionBegin;
    // seed ref mofem database by setting bit ref level to reference
    // tetrahedron
    CHKERR
    m_field_ref.getInterface<BitRefManager>()->setBitRefLevelByDim(
        0, 2, BitRefLevel().set(0));
 
    for (int ll = 0; ll != max_level; ++ll) {
      MOFEM_TAG_AND_LOG_C("WORLD", Sev::noisy, "PostProc", "Refine Level %d",
                          ll);
      Range edges;
      CHKERR m_field_ref.getInterface<BitRefManager>()
          ->getEntitiesByTypeAndRefLevel(BitRefLevel().set(ll),
                                         BitRefLevel().set(), MBEDGE, edges);
      Range tris;
      CHKERR m_field_ref.getInterface<BitRefManager>()
          ->getEntitiesByTypeAndRefLevel(BitRefLevel().set(ll),
                                         BitRefLevel(ll).set(), MBTRI, tris);
      // refine mesh
      auto m_ref = m_field_ref.getInterface<MeshRefinement>();
      CHKERR m_ref->addVerticesInTheMiddleOfEdges(edges,
                                                  BitRefLevel().set(ll + 1));
      CHKERR m_ref->refineTris(tris, BitRefLevel().set(ll + 1));
    }
    MoFEMFunctionReturn(0);
  };
 
  // auto set_gauss_pts = [&](std::map<EntityHandle, int> &little_map) {
  //   MoFEMFunctionBegin;
  //   Range faces;
  //   CHKERR moab_ref.get_entities_by_type(0, MBTRI, faces, true);
  //   Range faces_nodes;
  //   CHKERR moab_ref.get_connectivity(faces, faces_nodes, false);
  //   auto &gauss_pts = levelGaussPtsOnRefMesh[0];
  //   gauss_pts.resize(faces_nodes.size(), 4, false);
  //   size_t gg = 0;
  //   for (auto node : faces_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 get_ref_gauss_pts_and_shape_functions = [this, max_level, &moab_ref,
                                                &m_field_ref]() {
    MoFEMFunctionBegin;
    for (int ll = 0; ll != max_level + 1; ++ll) {
 
      Range tris;
      CHKERR
      m_field_ref.getInterface<BitRefManager>()->getEntitiesByTypeAndRefLevel(
          BitRefLevel().set(ll), BitRefLevel().set(ll), MBTRI, tris);
 
      if (hoNodes) {
        EntityHandle meshset;
        CHKERR moab_ref.create_meshset(MESHSET_SET, meshset);
        CHKERR moab_ref.add_entities(meshset, tris);
        CHKERR moab_ref.convert_entities(meshset, true, false, false);
        CHKERR moab_ref.delete_entities(&meshset, 1);
      }
 
      Range elem_nodes;
      CHKERR moab_ref.get_connectivity(tris, elem_nodes, false);
 
      auto &gauss_pts = levelGaussPtsOnRefMesh[ll];
      gauss_pts.resize(elem_nodes.size(), 3, false);
      std::map<EntityHandle, int> little_map;
      Range::iterator nit = elem_nodes.begin();
      for (int gg = 0; nit != elem_nodes.end(); nit++, gg++) {
        CHKERR moab_ref.get_coords(&*nit, 1, &gauss_pts(gg, 0));
        little_map[*nit] = gg;
      }
      gauss_pts = trans(gauss_pts);
 
      auto &ref_tris = levelRef[ll];
      Range::iterator tit = tris.begin();
      for (int tt = 0; tit != tris.end(); ++tit, ++tt) {
        const EntityHandle *conn;
        int num_nodes;
        CHKERR moab_ref.get_connectivity(*tit, conn, num_nodes, false);
        if (tt == 0) {
          ref_tris.resize(tris.size(), num_nodes);
        }
        for (int nn = 0; nn != num_nodes; ++nn) {
          ref_tris(tt, nn) = little_map[conn[nn]];
        }
      }
 
      auto &shape_functions = levelShapeFunctions[ll];
      shape_functions.resize(elem_nodes.size(), 3);
      CHKERR ShapeMBTRI(&*shape_functions.data().begin(), &gauss_pts(0, 0),
                        &gauss_pts(1, 0), elem_nodes.size());
    }
    MoFEMFunctionReturn(0);
  };
 
  levelRef.resize(max_level + 1);
  levelGaussPtsOnRefMesh.resize(max_level + 1);
  levelShapeFunctions.resize(max_level + 1);
 
  CHKERR refine_ref_triangles();
  CHKERR get_ref_gauss_pts_and_shape_functions();
 
  MoFEMFunctionReturn(0);
}