Nektar::NekMeshUtils::Edge Class Reference

Represents an edge which joins two points. More...

#include <Edge.h>

Collaboration diagram for Nektar::NekMeshUtils::Edge:

Public Member Functions
NEKMESHUTILS_EXPORT	Edge (NodeSharedPtr pVertex1, NodeSharedPtr pVertex2, std::vector< NodeSharedPtr > pEdgeNodes, LibUtilities::PointsType pCurveType)
	Creates a new edge. More...
NEKMESHUTILS_EXPORT	Edge (NodeSharedPtr pVertex1, NodeSharedPtr pVertex2)
	Creates a new linear edge. More...
NEKMESHUTILS_EXPORT	Edge (const Edge &pSrc)
	Copies an existing edge. More...
NEKMESHUTILS_EXPORT	~Edge ()
NEKMESHUTILS_EXPORT unsigned int	GetNodeCount () const
	Returns the total number of nodes defining the edge. More...
NEKMESHUTILS_EXPORT void	GetCurvedNodes (std::vector< NodeSharedPtr > &nodeList) const
NEKMESHUTILS_EXPORT std::string	GetXmlCurveString ()
	Creates a Nektar++ string listing the coordinates of all the nodes. More...
NEKMESHUTILS_EXPORT SpatialDomains::SegGeomSharedPtr	GetGeom (int coordDim)
	Generate a SpatialDomains::SegGeom object for this edge. More...
void	MakeOrder (int order, SpatialDomains::GeometrySharedPtr geom, LibUtilities::PointsType edgeType, int coordDim, int &id)
	Make this edge an order order edge. More...

Public Attributes
unsigned int	m_id
	ID of edge. More...
NodeSharedPtr	m_n1
	First vertex node. More...
NodeSharedPtr	m_n2
	Second vertex node. More...
std::vector< NodeSharedPtr >	m_edgeNodes
	List of control nodes between the first and second vertices. More...
LibUtilities::PointsType	m_curveType
	Distributions of points along edge. More...
std::vector< std::pair < ElementSharedPtr, int > >	m_elLink
	Element(s) which are linked to this edge. More...
CADObjectSharedPtr	m_parentCAD

Private Attributes
SpatialDomains::SegGeomSharedPtr	m_geom

Detailed Description

Represents an edge which joins two points.

An edge is defined by two nodes (vertices) and, for high-order edges, a set of control nodes defining the shape of the edge.

Definition at line 58 of file Edge.h.

Constructor & Destructor Documentation

NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Edge::Edge ( NodeSharedPtr  pVertex1, NodeSharedPtr  pVertex2, std::vector< NodeSharedPtr >  pEdgeNodes, LibUtilities::PointsType  pCurveType  )

inline

Creates a new edge.

Definition at line 62 of file Edge.h.

        : m_n1(pVertex1), m_n2(pVertex2), m_edgeNodes(pEdgeNodes),
          m_curveType(pCurveType), m_geom(){}

NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Edge::Edge ( NodeSharedPtr  pVertex1, NodeSharedPtr  pVertex2  )

inline

Creates a new linear edge.

Definition at line 70 of file Edge.h.

        : m_n1(pVertex1), m_n2(pVertex2), m_edgeNodes(), m_curveType(), m_geom()
    {}

NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Edge::Edge ( const Edge &  pSrc )

inline

Copies an existing edge.

Definition at line 75 of file Edge.h.

        : m_n1(pSrc.m_n1), m_n2(pSrc.m_n2), m_edgeNodes(pSrc.m_edgeNodes),
          m_curveType(pSrc.m_curveType), m_geom(pSrc.m_geom)
    {
    }

NEKMESHUTILS_EXPORT Nektar::NekMeshUtils::Edge::~Edge ( )

inline

Definition at line 81 of file Edge.h.

    {
    }

Member Function Documentation

NEKMESHUTILS_EXPORT void Nektar::NekMeshUtils::Edge::GetCurvedNodes ( std::vector< NodeSharedPtr > &  nodeList ) const

inline

Definition at line 91 of file Edge.h.

References m_edgeNodes, m_n1, and m_n2.

    {
        nodeList.push_back(m_n1);
        for (int k = 0; k < m_edgeNodes.size(); ++k)
        {
            nodeList.push_back(m_edgeNodes[k]);
        }
        nodeList.push_back(m_n2);
    }

SpatialDomains::SegGeomSharedPtr Edge::GetGeom

(

int

coordDim

)

Generate a SpatialDomains::SegGeom object for this edge.

Definition at line 70 of file Edge.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Vmath::mutex, and CellMLToNektar.cellml_metadata::p.

{
    static boost::mutex io_mutex;
    boost::mutex::scoped_lock lock(io_mutex);

    // Create edge vertices.
    SpatialDomains::PointGeomSharedPtr p[2];
    SpatialDomains::SegGeomSharedPtr ret;

    p[0] = m_n1->GetGeom(coordDim);
    p[1] = m_n2->GetGeom(coordDim);

    // Create a curve if high-order information exists.
    if (m_edgeNodes.size() > 0)
    {
        SpatialDomains::CurveSharedPtr c =
            MemoryManager<SpatialDomains::Curve>::AllocateSharedPtr(
                m_id, m_curveType);

        c->m_points.push_back(p[0]);
        for (int i = 0; i < m_edgeNodes.size(); ++i)
        {
            c->m_points.push_back(m_edgeNodes[i]->GetGeom(coordDim));
        }
        c->m_points.push_back(p[1]);

        ret = MemoryManager<SpatialDomains::SegGeom>::AllocateSharedPtr(
            m_id, coordDim, p, c);
    }
    else
    {
        ret = MemoryManager<SpatialDomains::SegGeom>::AllocateSharedPtr(
            m_id, coordDim, p);
    }

    return ret;
}

NEKMESHUTILS_EXPORT unsigned int Nektar::NekMeshUtils::Edge::GetNodeCount ( ) const

inline

Returns the total number of nodes defining the edge.

Definition at line 86 of file Edge.h.

References m_edgeNodes.

    {
        return m_edgeNodes.size() + 2;
    }

string Edge::GetXmlCurveString

(

)

Creates a Nektar++ string listing the coordinates of all the nodes.

Definition at line 50 of file Edge.cpp.

{
    std::vector<NodeSharedPtr> nodeList;

    GetCurvedNodes(nodeList);

    std::stringstream s;
    std::string str;

    // put them into a string and return
    for (int k = 0; k < nodeList.size(); ++k)
    {
        s << std::scientific << std::setprecision(8) << "    "
          << nodeList[k]->m_x << "  " << nodeList[k]->m_y << "  "
          << nodeList[k]->m_z << "    ";
    }

    return s.str();
}

void Edge::MakeOrder	(	int	order,
		SpatialDomains::GeometrySharedPtr	geom,
		LibUtilities::PointsType	edgeType,
		int	coordDim,
		int &	id
	)

Make this edge an order order edge.

See also

Element::MakeOrder.

Definition at line 108 of file Edge.cpp.

References Nektar::NekMeshUtils::CADType::eCurve, class_topology::Node, and Nektar::LibUtilities::PointsManager().

{
    int nPoints                            = order + 1;
    StdRegions::StdExpansionSharedPtr xmap = geom->GetXmap();

    Array<OneD, NekDouble> edgePoints;
    LibUtilities::PointsKey edgeKey(nPoints, edgeType);
    LibUtilities::PointsManager()[edgeKey]->GetPoints(edgePoints);

    Array<OneD, Array<OneD, NekDouble> > phys(coordDim);

    for (int i = 0; i < coordDim; ++i)
    {
        phys[i] = Array<OneD, NekDouble>(xmap->GetTotPoints());
        xmap->BwdTrans(geom->GetCoeffs(i), phys[i]);
    }

    m_edgeNodes.resize(nPoints - 2);

    for (int i = 1; i < nPoints - 1; ++i)
    {
        Array<OneD, NekDouble> x(3, 0.0);
        for (int j = 0; j < coordDim; ++j)
        {
            x[j] = xmap->PhysEvaluate(edgePoints + i, phys[j]);
        }

        m_edgeNodes[i - 1] =
            boost::shared_ptr<Node>(new Node(id++, x[0], x[1], x[2]));
    }

    m_curveType = edgeType;

    if (m_parentCAD)
    {
        if (m_parentCAD->GetType() == CADType::eCurve)
        {
            CADCurveSharedPtr c =
                boost::dynamic_pointer_cast<CADCurve>(m_parentCAD);
            for (int i = 0; i < m_edgeNodes.size(); i++)
            {
                Array<OneD, NekDouble> loc(3);
                loc[0]      = m_edgeNodes[i]->m_x;
                loc[1]      = m_edgeNodes[i]->m_y;
                loc[2]      = m_edgeNodes[i]->m_z;
                NekDouble t = c->loct(loc);
                m_edgeNodes[i]->SetCADCurve(c->GetId(), c, t);
                loc                 = c->P(t);
                m_edgeNodes[i]->m_x = loc[0];
                m_edgeNodes[i]->m_y = loc[1];
                m_edgeNodes[i]->m_z = loc[2];

                std::vector<
                    std::pair<CADSurfSharedPtr, CADOrientation::Orientation> >
                    s = c->GetAdjSurf();
                for (int j = 0; j < s.size(); j++)
                {
                    Array<OneD, NekDouble> uv(2);
                    s[j].first->ProjectTo(loc, uv);
                    m_edgeNodes[i]->SetCADSurf(s[j].first->GetId(), s[j].first,
                                               uv);
                }
            }
        }
        else
        {
            CADSurfSharedPtr s =
                boost::dynamic_pointer_cast<CADSurf>(m_parentCAD);
            for (int i = 0; i < m_edgeNodes.size(); i++)
            {
                Array<OneD, NekDouble> loc(3);
                loc[0] = m_edgeNodes[i]->m_x;
                loc[1] = m_edgeNodes[i]->m_y;
                loc[2] = m_edgeNodes[i]->m_z;
                Array<OneD, NekDouble> uv(2);
                s->ProjectTo(loc, uv);
                loc                 = s->P(uv);
                m_edgeNodes[i]->m_x = loc[0];
                m_edgeNodes[i]->m_y = loc[1];
                m_edgeNodes[i]->m_z = loc[2];
                m_edgeNodes[i]->SetCADSurf(s->GetId(), s, uv);
            }
        }
    }
}

Member Data Documentation

LibUtilities::PointsType Nektar::NekMeshUtils::Edge::m_curveType

Distributions of points along edge.

Definition at line 125 of file Edge.h.

std::vector<NodeSharedPtr> Nektar::NekMeshUtils::Edge::m_edgeNodes

List of control nodes between the first and second vertices.

Definition at line 123 of file Edge.h.

Referenced by GetCurvedNodes(), and GetNodeCount().

std::vector<std::pair<ElementSharedPtr, int> > Nektar::NekMeshUtils::Edge::m_elLink

Element(s) which are linked to this edge.

Definition at line 127 of file Edge.h.

SpatialDomains::SegGeomSharedPtr Nektar::NekMeshUtils::Edge::m_geom

private

Definition at line 132 of file Edge.h.

unsigned int Nektar::NekMeshUtils::Edge::m_id

ID of edge.

Definition at line 117 of file Edge.h.

NodeSharedPtr Nektar::NekMeshUtils::Edge::m_n1

First vertex node.

Definition at line 119 of file Edge.h.

Referenced by GetCurvedNodes().

NodeSharedPtr Nektar::NekMeshUtils::Edge::m_n2

Second vertex node.

Definition at line 121 of file Edge.h.

Referenced by GetCurvedNodes().

CADObjectSharedPtr Nektar::NekMeshUtils::Edge::m_parentCAD

Definition at line 129 of file Edge.h.