Nektar::NekMeshUtils::CurveMesh Class Reference

class for meshing individual curves (1d meshing) More...

#include <CurveMesh.h>

Public Member Functions
	CurveMesh (int id, MeshSharedPtr m, std::string expr="0.0")
	default constructor More...
	CurveMesh (int id, MeshSharedPtr m, std::vector< NodeSharedPtr > ns)
void	Mesh (bool forceThree=false)
	execute meshing More...
void	ReMesh ()
	Delete old mesh and mesh with forceThree on. 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...
std::vector< EdgeSharedPtr >	GetMeshEdges ()
int	GetNumPoints ()
	get the number of points in the curve More...
NekDouble	GetLength ()
	get the length of the curve More...
void	PeriodicOverwrite (CurveMeshSharedPtr from)
int	GetId ()
void	SetOffset (unsigned i, NekDouble offset)

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...
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< EdgeSharedPtr >	m_meshedges
	list of mesh edges in the curvemesh More...
int	m_id
	id of the curvemesh More...
MeshSharedPtr	m_mesh
std::vector< NodeSharedPtr >	m_meshpoints
	ids of the mesh nodes More...
LibUtilities::Interpreter	m_bl
int	m_blID
std::map< unsigned, NekDouble >	m_endoffset
	offset of second point at each end More...

Friends
class	MemoryManager< CurveMesh >

Detailed Description

class for meshing individual curves (1d meshing)

Definition at line 57 of file CurveMesh.h.

Constructor & Destructor Documentation

CurveMesh() [1/2]

Nektar::NekMeshUtils::CurveMesh::CurveMesh ( int  id, MeshSharedPtr  m, std::string  expr = "0.0"  )

inline

default constructor

Definition at line 65 of file CurveMesh.h.

References Nektar::LibUtilities::Interpreter::DefineFunction(), m_bl, m_blID, m_cadcurve, m_id, and m_mesh.

        : m_id(id), m_mesh(m)
    {
        m_blID = m_bl.DefineFunction("x y z", expr);
        m_cadcurve = m_mesh->m_cad->GetCurve(m_id);
    }

CurveMesh() [2/2]

Nektar::NekMeshUtils::CurveMesh::CurveMesh ( int  id, MeshSharedPtr  m, std::vector< NodeSharedPtr >  ns  )

inline

Definition at line 72 of file CurveMesh.h.

References m_cadcurve, m_id, m_mesh, Mesh(), and ReMesh().

        : m_id(id), m_mesh(m), m_meshpoints(ns)
    {
        m_cadcurve = m_mesh->m_cad->GetCurve(m_id);
    }

Member Function Documentation

EvaluateDS()

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

private

evaluate paramter ds at curve location s

Definition at line 267 of file CurveMesh.cpp.

References ASSERTL0, and ASSERTL1.

Referenced by SetOffset().

{
    int a = 0;
    int b = 0;

    ASSERTL1(!(s < 0)&& !(s > m_curvelength), "s out of bounds");

    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;
}

EvaluatePS()

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

private

evaluate paramter ps at curve location s

Definition at line 306 of file CurveMesh.cpp.

References ASSERTL0, and ASSERTL1.

Referenced by SetOffset().

{
    int a = 0;
    int b = 0;

    ASSERTL1(!(s < 0) && !(s > m_curvelength), "s out of bounds");

    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;
}

GetFirstPoint()

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

inline

get id of first node

Definition at line 91 of file CurveMesh.h.

References m_meshpoints.

    {
        return m_meshpoints[0];
    }

GetId()

int Nektar::NekMeshUtils::CurveMesh::GetId ( )

inline

Definition at line 135 of file CurveMesh.h.

References m_id.

    {
        return m_id;
    }

GetLastPoint()

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

inline

get id of last node

Definition at line 99 of file CurveMesh.h.

References m_meshpoints.

    {
        return m_meshpoints.back();
    }

GetLength()

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

inline

get the length of the curve

Definition at line 128 of file CurveMesh.h.

References m_curvelength, and PeriodicOverwrite().

    {
        return m_curvelength;
    }

GetMeshEdges()

std::vector<EdgeSharedPtr> Nektar::NekMeshUtils::CurveMesh::GetMeshEdges ( )

inline

Definition at line 112 of file CurveMesh.h.

References m_meshedges.

    {
        return m_meshedges;
    }

GetMeshPoints()

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

inline

get list of mesh nodes

Definition at line 107 of file CurveMesh.h.

References m_meshpoints.

    {
        return m_meshpoints;
    }

GetNumPoints()

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

inline

get the number of points in the curve

Definition at line 120 of file CurveMesh.h.

References m_meshpoints.

    {
        return m_meshpoints.size();
    }

GetPhiFunction()

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

private

get node spacing phi function

Definition at line 245 of file CurveMesh.cpp.

Referenced by SetOffset().

{
    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;
    }
}

GetSampleFunction()

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

private

get node spacing sampling function

Definition at line 353 of file CurveMesh.cpp.

References CG_Iterations::loc.

Referenced by SetOffset().

{
    m_dst.resize(m_numSamplePoints);

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

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

        Array<OneD, NekDouble> loc = m_cadcurve->P(t);

        bool found = false;

        // if inside the BL, dsti[0] set to the BL thickness, i.e. the offset
        if (m_endoffset.count(0))
        {
            if (dsti[1] < m_endoffset[0])
            {
                dsti[0] = m_endoffset[0];
                found   = true;
            }
        }
        if (m_endoffset.count(1) && !found)
        {
            if (dsti[1] > m_curvelength - m_endoffset[1])
            {
                dsti[0] = m_endoffset[1];
                found   = true;
            }
        }
        // else, dsti[0] is found from the octree
        if (!found)
        {
            dsti[0] = m_mesh->m_octree->Query(loc);
        }

        dsti[2] = t;

        m_dst[i] = dsti;
    }
}

Mesh()

void Nektar::NekMeshUtils::CurveMesh::Mesh

(

bool

forceThree = false

)

execute meshing

Definition at line 59 of file CurveMesh.cpp.

References ASSERTL0, CG_Iterations::loc, class_topology::Node, and Nektar::rhs.

Referenced by CurveMesh().

{
    // this algorithm is mostly based on the work in chapter 19

    m_bounds      = m_cadcurve->GetBounds();
    m_curvelength = m_cadcurve->GetTotLength();
    m_numSamplePoints =
        int(m_curvelength / m_mesh->m_octree->GetMinDelta()) + 10;
    ds = m_curvelength / (m_numSamplePoints - 1);

    // compute the offset due to adjacent BLs
    NekDouble totalOffset = 0.0;
    for (map<unsigned, NekDouble>::iterator ie = m_endoffset.begin();
         ie != m_endoffset.end(); ++ie)
    {
        totalOffset += ie->second;
    }
    ASSERTL0(m_curvelength > totalOffset,
             "Boundary layers too thick for adjacent curve");

    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 + m_endoffset.size())
    {
        Ne = 1 + m_endoffset.size();

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

        if (m_endoffset.count(0))
        {
            meshsvalue[1] = m_endoffset[0];
        }
        if (m_endoffset.count(1))
        {
            meshsvalue[Ne - 1] = m_curvelength - m_endoffset[1];
        }
    }
    else if(Ne + 1 == 2 && forceThree)
    {
        Ne++;
        meshsvalue.resize(Ne + 1);
        meshsvalue[0] = 0.0;
        meshsvalue[1] = m_curvelength/ 2.0;
        meshsvalue[2] = m_curvelength;
    }
    else
    {

        GetPhiFunction();

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

        // force the second and/or the second to last point(s) if an offset is
        // defined
        if (m_endoffset.count(0))
        {
            meshsvalue[1] = m_endoffset[0];
        }
        if (m_endoffset.count(1))
        {
            meshsvalue[Ne - 1] = m_curvelength - m_endoffset[1];
        }

        for (int i = 1 + m_endoffset.count(0); i < Ne - m_endoffset.count(1);
             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-8)
                {
                    iterate = false;
                }

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

            meshsvalue[i] = ski;
        }
    }

    NekDouble t;
    Array<OneD, NekDouble> loc;

    vector<CADVertSharedPtr> verts = m_cadcurve->GetVertex();
    vector<pair<CADSurfSharedPtr, CADOrientation::Orientation> > s =
        m_cadcurve->GetAdjSurf();

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

        Array<OneD, NekDouble> uv = s[j].first->locuv(loc);
        n->SetCADSurf(s[j].first, 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 = std::shared_ptr<Node>(
            new Node(m_mesh->m_numNodes++, loc[0], loc[1], loc[2]));
        n2->SetCADCurve(m_cadcurve, t);
        for (int j = 0; j < s.size(); j++)
        {
            Array<OneD, NekDouble> uv = s[j].first->locuv(loc);
            n2->SetCADSurf(s[j].first, uv);
        }
        m_meshpoints.push_back(n2);
    }

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

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

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

    // 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 = std::shared_ptr<Edge>(
            new Edge(m_meshpoints[i], m_meshpoints[i + 1]));
        e->m_parentCAD = m_cadcurve;
        m_mesh->m_edgeSet.insert(e);
        m_meshedges.push_back(e);
    }

    if (m_mesh->m_verbose)
    {
        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;
    }
}

PeriodicOverwrite()

void Nektar::NekMeshUtils::CurveMesh::PeriodicOverwrite

(

CurveMeshSharedPtr

from

)

Definition at line 398 of file CurveMesh.cpp.

References CG_Iterations::loc, and class_topology::Node.

Referenced by GetLength().

{
    // clear current mesh points and remove edges from edgeset
    m_meshpoints.clear();
    for (int i = 0; i < m_meshedges.size(); i++)
    {
        m_mesh->m_edgeSet.erase(m_meshedges[i]);
    }
    m_meshedges.clear();

    ///////

    int tid = from->GetId();
    Array<OneD, NekDouble> T =
        m_mesh->m_cad->GetPeriodicTranslationVector(tid, m_id);

    CADCurveSharedPtr c1 = m_mesh->m_cad->GetCurve(tid);

    bool reversed = c1->GetOrienationWRT(1) == m_cadcurve->GetOrienationWRT(1);

    vector<NodeSharedPtr> nodes = from->GetMeshPoints();

    vector<pair<CADSurfSharedPtr, CADOrientation::Orientation> > surfs =
        m_cadcurve->GetAdjSurf();

    for (int i = 1; i < nodes.size() - 1; i++)
    {
        Array<OneD, NekDouble> loc = nodes[i]->GetLoc();
        NodeSharedPtr nn = NodeSharedPtr(
            new Node(m_mesh->m_numNodes++, loc[0] + T[0], loc[1] + T[1], 0.0));

        for (int j = 0; j < surfs.size(); j++)
        {
            Array<OneD, NekDouble> uv = surfs[j].first->locuv(nn->GetLoc());
            nn->SetCADSurf(surfs[j].first, uv);
        }

        NekDouble t;
        m_cadcurve->loct(nn->GetLoc(), t);
        nn->SetCADCurve(m_cadcurve, t);

        m_meshpoints.push_back(nn);
    }

    // Reverse internal nodes of the vector if necessary
    if (reversed)
    {
        reverse(m_meshpoints.begin(), m_meshpoints.end());
    }

    vector<CADVertSharedPtr> verts = m_cadcurve->GetVertex();

    m_meshpoints.insert(m_meshpoints.begin(), verts[0]->GetNode());
    m_meshpoints.push_back(verts[1]->GetNode());
    // dont need to realign cad for vertices

    // 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 = std::shared_ptr<Edge>(
            new Edge(m_meshpoints[i], m_meshpoints[i + 1]));
        e->m_parentCAD = m_cadcurve;
        m_mesh->m_edgeSet.insert(e);
        m_meshedges.push_back(e);
    }
}

ReMesh()

void Nektar::NekMeshUtils::CurveMesh::ReMesh

(

)

Delete old mesh and mesh with forceThree on.

Definition at line 44 of file CurveMesh.cpp.

References CG_Iterations::Mesh.

Referenced by CurveMesh().

{
    m_meshpoints.clear();
    m_dst.clear();
    m_ps.clear();
    meshsvalue.clear();
    for(int i = 0; i < m_meshedges.size(); i++)
    {
        m_mesh->m_edgeSet.erase(m_meshedges[i]);
    }
    m_meshedges.clear();

    Mesh(true);
}

SetOffset()

void Nektar::NekMeshUtils::CurveMesh::SetOffset ( unsigned  i, NekDouble  offset  )

inline

Definition at line 140 of file CurveMesh.h.

References EvaluateDS(), EvaluatePS(), GetPhiFunction(), GetSampleFunction(), and m_endoffset.

    {
        m_endoffset[i] = offset;
    }

Friends And Related Function Documentation

MemoryManager< CurveMesh >

friend class MemoryManager< CurveMesh >

friend

Definition at line 60 of file CurveMesh.h.

Member Data Documentation

Ae

NekDouble Nektar::NekMeshUtils::CurveMesh::Ae

private

spacing function evaluation

Definition at line 179 of file CurveMesh.h.

ds

NekDouble Nektar::NekMeshUtils::CurveMesh::ds

private

ds

Definition at line 181 of file CurveMesh.h.

m_bl

LibUtilities::Interpreter Nektar::NekMeshUtils::CurveMesh::m_bl

private

Definition at line 195 of file CurveMesh.h.

Referenced by CurveMesh().

m_blID

int Nektar::NekMeshUtils::CurveMesh::m_blID

private

Definition at line 196 of file CurveMesh.h.

Referenced by CurveMesh().

m_bounds

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

private

coords of the ends of the parametric curve

Definition at line 173 of file CurveMesh.h.

m_cadcurve

CADCurveSharedPtr Nektar::NekMeshUtils::CurveMesh::m_cadcurve

private

CAD curve.

Definition at line 167 of file CurveMesh.h.

Referenced by CurveMesh().

m_curvelength

NekDouble Nektar::NekMeshUtils::CurveMesh::m_curvelength

private

length of the curve in real space

Definition at line 169 of file CurveMesh.h.

Referenced by GetLength().

m_dst

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

private

array of function ds evaluations

Definition at line 175 of file CurveMesh.h.

m_endoffset

std::map<unsigned, NekDouble> Nektar::NekMeshUtils::CurveMesh::m_endoffset

private

offset of second point at each end

Definition at line 198 of file CurveMesh.h.

Referenced by SetOffset().

m_id

int Nektar::NekMeshUtils::CurveMesh::m_id

private

id of the curvemesh

Definition at line 190 of file CurveMesh.h.

Referenced by CurveMesh(), and GetId().

m_mesh

MeshSharedPtr Nektar::NekMeshUtils::CurveMesh::m_mesh

private

Definition at line 192 of file CurveMesh.h.

Referenced by CurveMesh().

m_meshedges

std::vector<EdgeSharedPtr> Nektar::NekMeshUtils::CurveMesh::m_meshedges

private

list of mesh edges in the curvemesh

Definition at line 188 of file CurveMesh.h.

Referenced by GetMeshEdges().

m_meshpoints

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

private

ids of the mesh nodes

Definition at line 194 of file CurveMesh.h.

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

m_numSamplePoints

int Nektar::NekMeshUtils::CurveMesh::m_numSamplePoints

private

number of sampling points used in algorithm

Definition at line 171 of file CurveMesh.h.

m_ps

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

private

array of function ps evaluations

Definition at line 177 of file CurveMesh.h.

meshsvalue

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

private

paramteric coordiates of the mesh nodes

Definition at line 186 of file CurveMesh.h.

Ne

int Nektar::NekMeshUtils::CurveMesh::Ne

private

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

Definition at line 184 of file CurveMesh.h.