Nektar::NekMeshUtils::TriangleInterface Class Reference

class for interfacing with external library triangle More...

#include <TriangleInterface.h>

Collaboration diagram for Nektar::NekMeshUtils::TriangleInterface:

Public Member Functions
	TriangleInterface ()
	default constructor More...
void	Assign (std::vector< std::vector< NodeSharedPtr > > &boundingloops, std::vector< Array< OneD, NekDouble > > &centers, int i, NekDouble str=1.0)
	assign meshing paramters More...
void	AssignStiener (std::vector< NodeSharedPtr > stiner)
void	Mesh (bool Quiet=true, bool Quality=false)
	Execute meshing. More...
void	Extract (std::vector< std::vector< NodeSharedPtr > > &Connec)
	Extract mesh. More...

Private Member Functions
void	SetUp ()
	Clear memory. More...

Private Attributes
std::vector< std::vector < NodeSharedPtr > >	m_boundingloops
	List of bounding nodes to the surface. More...
std::vector< NodeSharedPtr >	m_stienerpoints
	List of additional nodes. More...
std::vector< Array< OneD, NekDouble > >	m_centers
	Coordinates of the centers of the loops. More...
std::map< int, NodeSharedPtr >	nodemap
	Map from NekMesh id to triangle id. More...
int	sid
	ID of the surface. More...
NekDouble	m_str
	Stretching factor of parameter plane. More...
struct triangulateio in	out
	Triangle data strucutres. More...

Friends
class	MemoryManager< TriangleInterface >

Detailed Description

class for interfacing with external library triangle

Definition at line 63 of file TriangleInterface.h.

Constructor & Destructor Documentation

Nektar::NekMeshUtils::TriangleInterface::TriangleInterface ( )

inline

default constructor

Definition at line 71 of file TriangleInterface.h.

{};

Member Function Documentation

void Nektar::NekMeshUtils::TriangleInterface::Assign ( std::vector< std::vector< NodeSharedPtr > > &  boundingloops, std::vector< Array< OneD, NekDouble > > &  centers, int  i, NekDouble  str = 1.0  )

inline

assign meshing paramters

Definition at line 76 of file TriangleInterface.h.

References m_boundingloops, m_centers, m_str, and sid.

    {
        m_boundingloops = boundingloops;
        m_centers       = centers;
        m_str           = str;
        sid             = i;
    }

void Nektar::NekMeshUtils::TriangleInterface::AssignStiener ( std::vector< NodeSharedPtr >  stiner )

inline

Definition at line 87 of file TriangleInterface.h.

References m_stienerpoints.

    {
        m_stienerpoints = stiner;
    }

void Nektar::NekMeshUtils::TriangleInterface::Extract

(

std::vector< std::vector< NodeSharedPtr > > &

Connec

)

Extract mesh.

Definition at line 205 of file TriangleInterface.cpp.

References ASSERTL0, and Nektar::iterator.

{
    Connec.clear();
    for (int i = 0; i < out.numberoftriangles; i++)
    {
        map<int, NodeSharedPtr>::iterator n1, n2, n3;
        n1 = nodemap.find(out.trianglelist[i * 3 + 0]);
        n2 = nodemap.find(out.trianglelist[i * 3 + 1]);
        n3 = nodemap.find(out.trianglelist[i * 3 + 2]);

        ASSERTL0(n1 != nodemap.end() && n2 != nodemap.end() &&
                     n3 != nodemap.end(),
                 "node index error");

        vector<NodeSharedPtr> tri(3);
        tri[0] = n1->second;
        tri[1] = n2->second;
        tri[2] = n3->second;
        Connec.push_back(tri);
    }
}

void Nektar::NekMeshUtils::TriangleInterface::Mesh	(	bool	Quiet = true,
		bool	Quality = false
	)

Execute meshing.

Definition at line 46 of file TriangleInterface.cpp.

References ASSERTL0, and REAL.

{
    SetUp();

    int numPoints = 0;
    int numSeg = 0;
    for (int i = 0; i < m_boundingloops.size(); i++)
    {
        numSeg += m_boundingloops[i].size();
    }
    numPoints = numSeg + m_stienerpoints.size();

    stringstream ss;
    ss << "3 points required for triangulation, " << numPoints << " provided";

    ASSERTL0(numPoints > 2, ss.str());

    in.numberofpoints          = numPoints;
    in.numberofpointattributes = 0;
    in.pointlist               = new REAL[in.numberofpoints * 2];
    in.pointmarkerlist         = new int [in.numberofpoints];

    int pointc = 0;

    for (int i = 0; i < m_boundingloops.size(); i++)
    {
        for (int j = 0; j < m_boundingloops[i].size(); j++, pointc++)
        {
            nodemap[pointc] = m_boundingloops[i][j];

            Array<OneD, NekDouble> uv =
                m_boundingloops[i][j]->GetCADSurfInfo(sid);
            in.pointlist[pointc * 2 + 0] = uv[0] * m_str;
            in.pointlist[pointc * 2 + 1] = uv[1];
        }
    }

    for (int i = 0; i < m_stienerpoints.size(); i++, pointc++)
    {
        nodemap[pointc] = m_stienerpoints[i];

        Array<OneD, NekDouble> uv    = m_stienerpoints[i]->GetCADSurfInfo(sid);
        in.pointlist[pointc * 2 + 0] = uv[0] * m_str;
        in.pointlist[pointc * 2 + 1] = uv[1];
    }

    in.numberofsegments = numSeg;
    in.segmentlist      = new int[in.numberofsegments * 2];
    pointc = 0;
    for (int i = 0; i < m_boundingloops.size(); i++, pointc++)
    {
        int first = pointc;
        for (int j = 0; j < m_boundingloops[i].size() - 1; j++, pointc++)
        {
            in.segmentlist[pointc * 2 + 0] = pointc;
            in.segmentlist[pointc * 2 + 1] = pointc + 1;
        }
        in.segmentlist[pointc * 2 + 0] = pointc;
        in.segmentlist[pointc * 2 + 1] = first;
    }

    in.numberofregions = 0;
    in.numberofholes   = m_centers.size() - 1;
    in.holelist        = new REAL[in.numberofholes * 2];

    for (int i = 1; i < m_centers.size(); i++)
    {
        in.holelist[(i - 1) * 2 + 0] = m_centers[i][0] * m_str;
        in.holelist[(i - 1) * 2 + 1] = m_centers[i][1];
    }

    if (Quiet && Quality)
    {
        triangulate("pzenqQYY", &in, &out, NULL);
    }
    else if (Quiet && !Quality)
    {
        triangulate("pzenYYQ", &in, &out, NULL);
    }
    else if (!Quiet && Quality)
    {
        triangulate("pzenqYY", &in, &out, NULL);
    }
    else if (!Quiet && !Quality)
    {
        triangulate("pzenYY", &in, &out, NULL);
    }

    // verify the mesh a bit
    if (out.numberofpoints - out.numberofedges + out.numberoftriangles !=
        2 - m_centers.size())
    {
        cout << endl << "epc wrong" << endl;
        cout << out.numberofpoints - out.numberofedges + out.numberoftriangles
             << " " << m_centers.size() << " " << sid << endl;
    }
}

void Nektar::NekMeshUtils::TriangleInterface::SetUp ( )

private

Clear memory.

Definition at line 144 of file TriangleInterface.cpp.

References REAL.

{
    in.pointlist                   = (REAL *)NULL;
    in.pointattributelist          = (REAL *)NULL;
    in.pointmarkerlist             = (int *)NULL;
    in.numberofpoints              = 0;
    in.numberofpointattributes     = 0;
    //
    in.trianglelist                = (int *)NULL;
    in.triangleattributelist       = (REAL *)NULL;
    in.trianglearealist            = (REAL *)NULL;
    in.neighborlist                = (int *)NULL;
    in.numberoftriangles           = 0;
    in.numberofcorners             = 0;
    in.numberoftriangleattributes  = 0;
    //
    in.segmentlist                 = (int *)NULL;
    in.segmentmarkerlist           = (int *)NULL;
    in.numberofsegments            = 0;
    //
    in.holelist                    = (REAL *)NULL;
    in.numberofholes               = 0;
    //
    in.regionlist                  = (REAL *)NULL;
    in.numberofregions             = 0;
    //
    in.edgelist                    = (int *)NULL;
    in.edgemarkerlist              = (int *)NULL;
    in.normlist                    = (REAL *)NULL;
    in.numberofedges               = 0;
    //
    out.pointlist                  = (REAL *)NULL;
    out.pointattributelist         = (REAL *)NULL;
    out.pointmarkerlist            = (int *)NULL;
    out.numberofpoints             = 0;
    out.numberofpointattributes    = 0;
    //
    out.trianglelist               = (int *)NULL;
    out.triangleattributelist      = (REAL *)NULL;
    out.trianglearealist           = (REAL *)NULL;
    out.neighborlist               = (int *)NULL;
    out.numberoftriangles          = 0;
    out.numberofcorners            = 0;
    out.numberoftriangleattributes = 0;
    //
    out.segmentlist                = (int *)NULL;
    out.segmentmarkerlist          = (int *)NULL;
    out.numberofsegments           = 0;
    //
    out.holelist                   = (REAL *)NULL;
    out.numberofholes              = 0;
    //
    out.regionlist                 = (REAL *)NULL;
    out.numberofregions            = 0;
    //
    out.edgelist                   = (int *)NULL;
    out.edgemarkerlist             = (int *)NULL;
    out.normlist                   = (REAL *)NULL;
    out.numberofedges              = 0;
}

Friends And Related Function Documentation

friend class MemoryManager< TriangleInterface >

friend

Definition at line 66 of file TriangleInterface.h.

Member Data Documentation

std::vector<std::vector<NodeSharedPtr> > Nektar::NekMeshUtils::TriangleInterface::m_boundingloops

private

List of bounding nodes to the surface.

Definition at line 109 of file TriangleInterface.h.

Referenced by Assign().

std::vector<Array<OneD, NekDouble> > Nektar::NekMeshUtils::TriangleInterface::m_centers

private

Coordinates of the centers of the loops.

Definition at line 113 of file TriangleInterface.h.

Referenced by Assign().

std::vector<NodeSharedPtr> Nektar::NekMeshUtils::TriangleInterface::m_stienerpoints

private

List of additional nodes.

Definition at line 111 of file TriangleInterface.h.

Referenced by AssignStiener().

NekDouble Nektar::NekMeshUtils::TriangleInterface::m_str

private

Stretching factor of parameter plane.

Definition at line 119 of file TriangleInterface.h.

Referenced by Assign().

std::map<int, NodeSharedPtr> Nektar::NekMeshUtils::TriangleInterface::nodemap

private

Map from NekMesh id to triangle id.

Definition at line 115 of file TriangleInterface.h.

struct triangulateio in Nektar::NekMeshUtils::TriangleInterface::out

private

Triangle data strucutres.

Definition at line 121 of file TriangleInterface.h.

int Nektar::NekMeshUtils::TriangleInterface::sid

private

ID of the surface.

Definition at line 117 of file TriangleInterface.h.

Referenced by Assign().