Nektar::NekMeshUtils::CurveMesh Class Reference

#include <CurveMesh.h>

Collaboration diagram for Nektar::NekMeshUtils::CurveMesh:

Public Member Functions
	CurveMesh (int id, MeshSharedPtr m, CADCurveSharedPtr c, OctreeSharedPtr o)
	default constructor More...
void	Mesh ()
	execute meshing More...
NodeSharedPtr	GetFirstPoint ()
	get id of first node More...
NodeSharedPtr	GetLastPoint ()
	get id of last node More...
std::vector< NodeSharedPtr >	GetMeshPoints ()
	get list of mesh nodes More...
int	GetNumPoints ()
	get the number of points in the curve More...
NekDouble	GetLength ()
	get the length of the curve More...

Private Member Functions
void	GetSampleFunction ()
	get node spacing sampling function More...
void	GetPhiFunction ()
	get node spacing phi function More...
NekDouble	EvaluateDS (NekDouble s)
	evaluate paramter ds at curve location s More...
NekDouble	EvaluatePS (NekDouble s)
	evaluate paramter ps at curve location s More...

Private Attributes
CADCurveSharedPtr	m_cadcurve
	CAD curve. More...
OctreeSharedPtr	m_octree
	Octree object. More...
NekDouble	m_curvelength
	length of the curve in real space More...
int	m_numSamplePoints
	number of sampling points used in algorithm More...
Array< OneD, NekDouble >	m_bounds
	coords of the ends of the parametric curve More...
std::vector< std::vector < NekDouble > >	m_dst
	array of function ds evaluations More...
std::vector< std::vector < NekDouble > >	m_ps
	array of function ps evaluations More...
NekDouble	Ae
	spacing function evaluation More...
NekDouble	ds
	ds More...
int	Ne
	number of edges to be made in the curve as defined by the spacing funtion More...
std::vector< NekDouble >	meshsvalue
	paramteric coordiates of the mesh nodes More...
std::vector< NodeSharedPtr >	m_meshpoints
	ids of the mesh nodes More...
int	m_id
	id of the curvemesh More...
MeshSharedPtr	m_mesh

Friends
class	MemoryManager< CurveMesh >

Detailed Description

Definition at line 57 of file CurveMesh.h.

Constructor & Destructor Documentation

Nektar::NekMeshUtils::CurveMesh::CurveMesh ( int  id, MeshSharedPtr  m, CADCurveSharedPtr  c, OctreeSharedPtr  o  )

inline

default constructor

Definition at line 65 of file CurveMesh.h.

        : m_cadcurve(c), m_octree(o), m_id(id), m_mesh(m){};

Member Function Documentation

NekDouble Nektar::NekMeshUtils::CurveMesh::EvaluateDS ( NekDouble  s )

private

evaluate paramter ds at curve location s

Definition at line 261 of file CurveMesh.cpp.

References ASSERTL0.

{
    int a = 0;
    int b = 0;

    if (s == 0)
    {
        return m_dst[0][0];
    }
    else if (s == m_curvelength)
    {
        return m_dst[m_numSamplePoints - 1][0];
    }

    for (int i = 0; i < m_numSamplePoints - 1; i++)
    {
        if (m_dst[i][1] < s && m_dst[i + 1][1] >= s)
        {
            a = i;
            b = i + 1;
            break;
        }
    }

    NekDouble s1 = m_dst[a][1];
    NekDouble s2 = m_dst[b][1];
    NekDouble d1 = m_dst[a][0];
    NekDouble d2 = m_dst[b][0];

    NekDouble m = (d2 - d1) / (s2 - s1);
    NekDouble c = d2 - m * s2;

    ASSERTL0(m * s + c == m * s + c, "DS"); // was getting nans here

    return m * s + c;
}

NekDouble Nektar::NekMeshUtils::CurveMesh::EvaluatePS ( NekDouble  s )

private

evaluate paramter ps at curve location s

Definition at line 298 of file CurveMesh.cpp.

References ASSERTL0.

{
    int a = 0;
    int b = 0;

    if (s == 0)
    {
        return m_ps[0][0];
    }
    else if (s == m_curvelength)
    {
        return m_ps[m_numSamplePoints - 1][0];
    }

    for (int i = 0; i < m_numSamplePoints - 1; i++)
    {
        if (m_ps[i][1] < s && m_ps[i + 1][1] >= s)
        {
            a = i;
            b = i + 1;
            break;
        }
    }

    if (a == b)
    {
        cout << endl;
        cout << a << " " << b << endl;
        cout << s << endl;
        exit(-1);
    }

    NekDouble s1 = m_ps[a][1];
    NekDouble s2 = m_ps[b][1];
    NekDouble d1 = m_ps[a][0];
    NekDouble d2 = m_ps[b][0];

    NekDouble m = (d2 - d1) / (s2 - s1);
    NekDouble c = d2 - m * s2;

    ASSERTL0(m * s + c == m * s + c, "PS");

    return m * s + c;
}

NodeSharedPtr Nektar::NekMeshUtils::CurveMesh::GetFirstPoint ( )

inline

get id of first node

Definition at line 76 of file CurveMesh.h.

References m_meshpoints.

    {
        return m_meshpoints[0];
    }

NodeSharedPtr Nektar::NekMeshUtils::CurveMesh::GetLastPoint ( )

inline

get id of last node

Definition at line 84 of file CurveMesh.h.

References m_meshpoints.

    {
        return m_meshpoints.back();
    }

NekDouble Nektar::NekMeshUtils::CurveMesh::GetLength ( )

inline

get the length of the curve

Definition at line 108 of file CurveMesh.h.

References m_curvelength.

    {
        return m_curvelength;
    }

std::vector<NodeSharedPtr> Nektar::NekMeshUtils::CurveMesh::GetMeshPoints ( )

inline

get list of mesh nodes

Definition at line 92 of file CurveMesh.h.

References m_meshpoints.

    {
        return m_meshpoints;
    }

int Nektar::NekMeshUtils::CurveMesh::GetNumPoints ( )

inline

get the number of points in the curve

Definition at line 100 of file CurveMesh.h.

References m_meshpoints.

    {
        return m_meshpoints.size();
    }

void Nektar::NekMeshUtils::CurveMesh::GetPhiFunction ( )

private

get node spacing phi function

Definition at line 239 of file CurveMesh.cpp.

{
    m_ps.resize(m_numSamplePoints);
    vector<NekDouble> newPhi;
    newPhi.resize(2);

    newPhi[0] = 0.0;
    newPhi[1] = 0.0;

    m_ps[0] = newPhi;

    NekDouble runningInt = 0.0;

    for (int i = 1; i < m_numSamplePoints; i++)
    {
        runningInt += (1.0 / m_dst[i - 1][0] + 1.0 / m_dst[i][0]) / 2.0 * ds;
        newPhi[0] = Ne / Ae * runningInt;
        newPhi[1] = m_dst[i][1];
        m_ps[i]   = newPhi;
    }
}

void Nektar::NekMeshUtils::CurveMesh::GetSampleFunction ( )

private

get node spacing sampling function

Definition at line 343 of file CurveMesh.cpp.

{
    m_dst.resize(m_numSamplePoints);
    Array<OneD, NekDouble> loc = m_cadcurve->P(m_bounds[0]);

    vector<NekDouble> dsti;
    dsti.resize(3);

    dsti[0] = m_octree->Query(loc);
    dsti[1] = 0.0;
    dsti[2] = m_bounds[0];

    m_dst[0] = dsti;

    for (int i = 1; i < m_numSamplePoints; i++)
    {
        dsti[1]     = i * ds;
        NekDouble t = m_cadcurve->tAtArcLength(dsti[1]);

        loc = m_cadcurve->P(t);

        dsti[0] = m_octree->Query(loc);
        dsti[2] = t;

        m_dst[i] = dsti;
    }
}

void Nektar::NekMeshUtils::CurveMesh::Mesh

(

)

execute meshing

Definition at line 44 of file CurveMesh.cpp.

References ASSERTL0.

{
    m_bounds          = m_cadcurve->Bounds();
    m_curvelength     = m_cadcurve->GetTotLength();
    m_numSamplePoints = int(m_curvelength / m_octree->GetMinDelta()) + 5;
    ds                = m_curvelength / (m_numSamplePoints - 1);

    GetSampleFunction();

    Ae = 0.0;

    for (int i = 0; i < m_numSamplePoints - 1; i++)
    {
        Ae += ds * (1.0 / m_dst[i][0] + 1.0 / m_dst[i + 1][0]) / 2.0;
    }

    Ne = round(Ae);

    if (Ne + 1 < 2)
    {
        meshsvalue.resize(2);
        meshsvalue[0] = 0.0;
        meshsvalue[1] = m_curvelength;
        Ne            = 1;
    }
    else
    {

        GetPhiFunction();

        meshsvalue.resize(Ne + 1);
        meshsvalue[0]  = 0.0;
        meshsvalue[Ne] = m_curvelength;

        for (int i = 1; i < Ne; i++)
        {
            int iterationcounter = 0;
            bool iterate         = true;
            int k                = i;
            NekDouble ski        = meshsvalue[i - 1];
            NekDouble lastSki;
            while (iterate)
            {
                iterationcounter++;
                NekDouble rhs = EvaluateDS(ski) / Ae * (EvaluatePS(ski) - k);
                lastSki       = ski;
                ski = ski - rhs;
                if (abs(lastSki - ski) < 1E-10)
                {
                    iterate = false;
                }

                ASSERTL0(iterationcounter < 1000000, "iteration failed");
            }

            meshsvalue[i] = ski;
        }
    }

    NekDouble t;
    Array<OneD, NekDouble> loc;

    vector<CADVertSharedPtr> verts = m_cadcurve->GetVertex();
    vector<CADSurfSharedPtr> s = m_cadcurve->GetAdjSurf();
    ASSERTL0(s.size() == 2, "invalid curve");

    NodeSharedPtr n = verts[0]->GetNode();
    t = m_bounds[0];
    n->SetCADCurve(m_id, m_cadcurve, t);
    loc = n->GetLoc();
    for (int j = 0; j < 2; j++)
    {
        if (verts[0]->IsDegen() == s[j]->GetId()) // if the degen has been set
                                                  // for this node the node
                                                  // already knows its corrected
                                                  // location
            continue;

        Array<OneD, NekDouble> uv = s[j]->locuv(loc);
        n->SetCADSurf(s[j]->GetId(), s[j], uv);
    }
    m_meshpoints.push_back(n);

    for (int i = 1; i < meshsvalue.size() - 1; i++)
    {
        t                = m_cadcurve->tAtArcLength(meshsvalue[i]);
        loc              = m_cadcurve->P(t);
        NodeSharedPtr n2 = boost::shared_ptr<Node>(
            new Node(m_mesh->m_numNodes++, loc[0], loc[1], loc[2]));
        n2->SetCADCurve(m_id, m_cadcurve, t);
        for (int j = 0; j < 2; j++)
        {
            Array<OneD, NekDouble> uv = s[j]->locuv(loc);
            n2->SetCADSurf(s[j]->GetId(), s[j], uv);
        }
        m_meshpoints.push_back(n2);
    }

    n = verts[1]->GetNode();
    t = m_bounds[1];
    n->SetCADCurve(m_id, m_cadcurve, t);
    loc = n->GetLoc();
    for (int j = 0; j < 2; j++)
    {
        if (verts[1]->IsDegen() == s[j]->GetId()) // if the degen has been set
                                                  // for this node the node
                                                  // already knows its corrected
                                                  // location
            continue;

        Array<OneD, NekDouble> uv = s[j]->locuv(loc);
        n->SetCADSurf(s[j]->GetId(), s[j], uv);
    }
    m_meshpoints.push_back(n);

    ASSERTL0(Ne + 1 == m_meshpoints.size(),
             "incorrect number of points in curve mesh");

    for (int i = 0; i < m_meshpoints.size(); i++)
    {
        Array<OneD, NekDouble> loc = m_meshpoints[i]->GetLoc();
        for (int j = 0; j < 2; j++)
        {
            Array<OneD, NekDouble> uv = s[j]->locuv(loc);
            m_meshpoints[i]->SetCADSurf(s[j]->GetId(), s[j], uv);
        }
    }

    /*//post process the curve mesh to analyse for bad segments based on
    high-order normals and split if needed
    int ct = 1;
    while(ct > 0)
    {
        ct = 0;
        for(int i = 0; i < m_meshpoints.size() - 1; i++)
        {
            bool split = false;
            for(int j = 0; j < 2; j++)
            {
                Array<OneD, NekDouble> uv1, uv2;
                uv1 = m_meshpoints[i]->GetCADSurfInfo(s[j]->GetId());
                uv2 = m_meshpoints[i+1]->GetCADSurfInfo(s[j]->GetId());
                Array<OneD, NekDouble> N1, N2;
                N1 = s[j]->N(uv1);
                N2 = s[j]->N(uv2);
                NekDouble dot = N1[0]*N2[0] + N1[1]*N2[1] + N1[2]*N2[2];
                if(acos(dot) > 3.142/2.0-0.1)
                {
                    split = true;
                }
            }

            if(split)
            {
                ct++;
                NekDouble t1, t2;
                t1 = m_meshpoints[i]->GetCADCurveInfo(m_id);
                t2 = m_meshpoints[i+1]->GetCADCurveInfo(m_id);
                NekDouble tn = (t1 + t2)/2.0;
                Array<OneD, NekDouble> loc = m_cadcurve->P(tn);
                NodeSharedPtr nn = boost::shared_ptr<Node>(new
    Node(m_mesh->m_numNodes++,
                                                            loc[0],loc[1],loc[2]));
                nn->SetCADCurve(m_id, m_cadcurve, tn);
                for(int j = 0; j < 2; j++)
                {
                    Array<OneD, NekDouble> uv = s[j]->locuv(loc);
                    nn->SetCADSurf(s[j]->GetId(), s[j], uv);
                }
                m_meshpoints.insert(m_meshpoints.begin() + i+1, nn);
                break;
            }
        }
    }*/

    // make edges and add them to the edgeset for the face mesher to use
    for (int i = 0; i < m_meshpoints.size() - 1; i++)
    {
        EdgeSharedPtr e = boost::shared_ptr<Edge>(
            new Edge(m_meshpoints[i], m_meshpoints[i + 1]));
        e->CADCurveId = m_id;
        e->CADCurve   = m_cadcurve;
        e->onCurve = true;
        m_mesh->m_edgeSet.insert(e);
    }

    cout << "\r                                                                "
            "                             ";
    cout << scientific << "\r\t\tCurve " << m_id << endl
         << "\t\t\tLength: " << m_curvelength << endl
         << "\t\t\tNodes: " << m_meshpoints.size() << endl
         << "\t\t\tSample points: " << m_numSamplePoints << endl
         << endl;
}

Friends And Related Function Documentation

friend class MemoryManager< CurveMesh >

friend

Definition at line 60 of file CurveMesh.h.

Member Data Documentation

NekDouble Nektar::NekMeshUtils::CurveMesh::Ae

private

spacing function evaluation

Definition at line 149 of file CurveMesh.h.

NekDouble Nektar::NekMeshUtils::CurveMesh::ds

private

ds

Definition at line 151 of file CurveMesh.h.

Array<OneD, NekDouble> Nektar::NekMeshUtils::CurveMesh::m_bounds

private

coords of the ends of the parametric curve

Definition at line 143 of file CurveMesh.h.

CADCurveSharedPtr Nektar::NekMeshUtils::CurveMesh::m_cadcurve

private

CAD curve.

Definition at line 135 of file CurveMesh.h.

NekDouble Nektar::NekMeshUtils::CurveMesh::m_curvelength

private

length of the curve in real space

Definition at line 139 of file CurveMesh.h.

Referenced by GetLength().

std::vector<std::vector<NekDouble> > Nektar::NekMeshUtils::CurveMesh::m_dst

private

array of function ds evaluations

Definition at line 145 of file CurveMesh.h.

int Nektar::NekMeshUtils::CurveMesh::m_id

private

id of the curvemesh

Definition at line 160 of file CurveMesh.h.

MeshSharedPtr Nektar::NekMeshUtils::CurveMesh::m_mesh

private

Definition at line 162 of file CurveMesh.h.

std::vector<NodeSharedPtr> Nektar::NekMeshUtils::CurveMesh::m_meshpoints

private

ids of the mesh nodes

Definition at line 158 of file CurveMesh.h.

Referenced by GetFirstPoint(), GetLastPoint(), GetMeshPoints(), and GetNumPoints().

int Nektar::NekMeshUtils::CurveMesh::m_numSamplePoints

private

number of sampling points used in algorithm

Definition at line 141 of file CurveMesh.h.

OctreeSharedPtr Nektar::NekMeshUtils::CurveMesh::m_octree

private

Octree object.

Definition at line 137 of file CurveMesh.h.

std::vector<std::vector<NekDouble> > Nektar::NekMeshUtils::CurveMesh::m_ps

private

array of function ps evaluations

Definition at line 147 of file CurveMesh.h.

std::vector<NekDouble> Nektar::NekMeshUtils::CurveMesh::meshsvalue

private

paramteric coordiates of the mesh nodes

Definition at line 156 of file CurveMesh.h.

int Nektar::NekMeshUtils::CurveMesh::Ne

private

number of edges to be made in the curve as defined by the spacing funtion

Definition at line 154 of file CurveMesh.h.