Nektar::NekMeshUtils::TetMesh Class Reference

class for taking surface mesh and octree spec and making a 3d tet mesh More...

#include <TetMesh.h>

Public Member Functions
	TetMesh (MeshSharedPtr m, int id, std::vector< ElementSharedPtr > e=std::vector< ElementSharedPtr >())
	default constructor More...
void	Mesh ()
	execute tet meshing More...

Private Attributes
MeshSharedPtr	m_mesh
std::vector< ElementSharedPtr >	m_surface
int	m_numtet
	number of tetrahedra More...
int	m_id
std::vector< Array< OneD, int > >	m_tetconnect
	conncetivity of the tets from the interface More...
TetGenInterfaceSharedPtr	tetgen

Friends
class	MemoryManager< TetMesh >

Detailed Description

class for taking surface mesh and octree spec and making a 3d tet mesh

Definition at line 53 of file TetMesh.h.

Constructor & Destructor Documentation

TetMesh()

Nektar::NekMeshUtils::TetMesh::TetMesh ( MeshSharedPtr  m, int  id, std::vector< ElementSharedPtr >  e = std::vector<ElementSharedPtr>()  )

inline

default constructor

Definition at line 61 of file TetMesh.h.

References Mesh().

                : m_mesh(m), m_surface(e), m_id(id)
    {
    };

Member Function Documentation

Mesh()

void Nektar::NekMeshUtils::TetMesh::Mesh

(

)

execute tet meshing

Definition at line 44 of file TetMesh.cpp.

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::eTetrahedron, Nektar::NekMeshUtils::GetElementFactory(), and class_topology::Node.

Referenced by TetMesh().

{
    if (m_mesh->m_verbose)
        cout << endl << endl << "Tetrahdral mesh generation" << endl;

    tetgen = MemoryManager<TetGenInterface>::AllocateSharedPtr();

    map<int, NodeSharedPtr> IdToNode;
    map<NodeSharedPtr, int> IdToNodeRev;

    // build sequentially ordered maps of nodes that exist and there delta value
    // in the octree
    map<int, NekDouble> IdToDelta;
    vector<Array<OneD, int> > surfacetris;
    NodeSet alreadyInSurface;

    if(m_surface.size() == 0)
    {
        m_surface = m_mesh->m_element[2];
    }

    int cnt = 0;
    for(int i = 0; i < m_surface.size(); i++)
    {
        vector<NodeSharedPtr> n = m_surface[i]->GetVertexList();
        Array<OneD, int> tri(3);
        for(int j = 0; j < n.size(); j++)
        {
            pair<NodeSet::iterator,bool> testIns =
                alreadyInSurface.insert(n[j]);

            if (testIns.second)
            {
                if(cnt == 2114)
                {
                    //cout << n[j]->m_x << " " << n[j]->m_y << " " << n[j]->m_z << endl;
                }
                tri[j] = cnt;
                IdToNode[cnt] = n[j];
                IdToNodeRev[n[j]] = cnt;
                IdToDelta[cnt] = m_mesh->m_octree->Query(n[j]->GetLoc());
                cnt++;
            }
            else
            {
                tri[j] = IdToNodeRev[(*testIns.first)];
            }
        }
        surfacetris.push_back(tri);
    }

    //m_mesh->m_expDim--;
    //m_mesh->m_element[3].clear();
    //m_mesh->m_element[2] = m_surface;
    //return;

    if (m_mesh->m_verbose)
    {
        cout << "\tInital Node Count: " << IdToNode.size() << endl;
    }

    tetgen->InitialMesh(IdToNode, surfacetris);

    vector<Array<OneD, NekDouble> > newp;
    int ctbefore = IdToNode.size();
    int newpb;
    do
    {
        newpb = newp.size();
        newp.clear();
        tetgen->GetNewPoints(ctbefore, newp);
        for (int i = 0; i < newp.size(); i++)
        {
            NekDouble d = m_mesh->m_octree->Query(newp[i]);
            IdToDelta[ctbefore + i] = d;
        }
        tetgen->RefineMesh(IdToDelta);
    } while (newpb != newp.size());

    // make new map of all nodes to build tets.
    newp.clear();
    tetgen->GetNewPoints(ctbefore, newp);
    for (int i = 0; i < newp.size(); i++)
    {
        NodeSharedPtr n = std::shared_ptr<Node>(
            new Node(ctbefore + i, newp[i][0], newp[i][1], newp[i][2]));
        IdToNode[ctbefore + i] = n;
    }

    m_tetconnect = tetgen->Extract();

    // tetgen->freetet();

    // create tets
    for (int i = 0; i < m_tetconnect.size(); i++)
    {
        vector<NodeSharedPtr> n;
        n.push_back(IdToNode[m_tetconnect[i][0]]);
        n.push_back(IdToNode[m_tetconnect[i][1]]);
        n.push_back(IdToNode[m_tetconnect[i][2]]);
        n.push_back(IdToNode[m_tetconnect[i][3]]);
        ElmtConfig conf(LibUtilities::eTetrahedron, 1, false, false);
        vector<int> tags;
        tags.push_back(m_id);
        ElementSharedPtr E = GetElementFactory().CreateInstance(
            LibUtilities::eTetrahedron, conf, n, tags);

        m_mesh->m_element[3].push_back(E);
    }

    if (m_mesh->m_verbose)
        cout << "\tTets :" << m_tetconnect.size() << endl;
}

Friends And Related Function Documentation

MemoryManager< TetMesh >

friend class MemoryManager< TetMesh >

friend

Definition at line 56 of file TetMesh.h.

Member Data Documentation

m_id

int Nektar::NekMeshUtils::TetMesh::m_id

private

Definition at line 78 of file TetMesh.h.

m_mesh

MeshSharedPtr Nektar::NekMeshUtils::TetMesh::m_mesh

private

Definition at line 74 of file TetMesh.h.

m_numtet

int Nektar::NekMeshUtils::TetMesh::m_numtet

private

number of tetrahedra

Definition at line 77 of file TetMesh.h.

m_surface

std::vector<ElementSharedPtr> Nektar::NekMeshUtils::TetMesh::m_surface

private

Definition at line 75 of file TetMesh.h.

m_tetconnect

std::vector<Array<OneD, int> > Nektar::NekMeshUtils::TetMesh::m_tetconnect

private

conncetivity of the tets from the interface

Definition at line 80 of file TetMesh.h.

tetgen

TetGenInterfaceSharedPtr Nektar::NekMeshUtils::TetMesh::tetgen

private

Definition at line 82 of file TetMesh.h.