Nektar::NekMeshUtils::HOTriangle< T > Struct Template Reference

A lightweight struct for dealing with high-order triangle alignment. More...

#include <HOAlignment.h>

Public Member Functions
	HOTriangle (std::vector< int > pVertId, std::vector< T > pSurfVerts)
	HOTriangle (std::vector< int > pVertId)
void	Rotate (int nrot)
	Rotates the triangle of data points inside surfVerts counter-clockwise nrot times. More...
void	Reflect ()
	Reflect data points inside surfVerts. More...
void	Align (std::vector< int > vertId)
	Align this surface to a given vertex ID. More...

Public Attributes
std::vector< int >	vertId
	The triangle vertex IDs. More...
std::vector< T >	surfVerts
	The triangle surface vertices – templated so that this can either be nodes or IDs. More...

Detailed Description

template<typename T>
struct Nektar::NekMeshUtils::HOTriangle< T >

A lightweight struct for dealing with high-order triangle alignment.

The logic underlying these routines is taken from the original Nektar code.

Definition at line 49 of file HOAlignment.h.

Constructor & Destructor Documentation

HOTriangle() [1/2]

template<typename T>

Nektar::NekMeshUtils::HOTriangle< T >::HOTriangle ( std::vector< int >  pVertId, std::vector< T >  pSurfVerts  )

inline

Definition at line 51 of file HOAlignment.h.

        : vertId(pVertId), surfVerts(pSurfVerts)
    {
    }

HOTriangle() [2/2]

template<typename T>

Nektar::NekMeshUtils::HOTriangle< T >::HOTriangle ( std::vector< int >  pVertId )

inline

Definition at line 55 of file HOAlignment.h.

                                       : vertId(pVertId)
    {
    }

Member Function Documentation

Align()

template<typename T>

void Nektar::NekMeshUtils::HOTriangle< T >::Align ( std::vector< int >  vertId )

inline

Align this surface to a given vertex ID.

Definition at line 134 of file HOAlignment.h.

References Nektar::NekMeshUtils::HOTriangle< T >::Reflect(), and Nektar::NekMeshUtils::HOTriangle< T >::Rotate().

Referenced by Nektar::NekMeshUtils::Prism::GetCurvedNodes(), Nektar::NekMeshUtils::Tetrahedron::GetCurvedNodes(), Nektar::Utilities::InputGmsh::PrismReordering(), Nektar::Utilities::OutputGmsh::Process(), Nektar::NekMeshUtils::Tetrahedron::Tetrahedron(), Nektar::Utilities::InputGmsh::TetReordering(), and Nektar::Utilities::tetTensorNodeOrdering().

    {
        if (vertId[0] == this->vertId[0])
        {
            if (vertId[1] == this->vertId[1] || vertId[1] == this->vertId[2])
            {
                if (vertId[1] == this->vertId[2])
                {
                    Rotate(1);
                    Reflect();
                }
            }
        }
        else if (vertId[0] == this->vertId[1])
        {
            if (vertId[1] == this->vertId[0] || vertId[1] == this->vertId[2])
            {
                if (vertId[1] == this->vertId[0])
                {
                    Reflect();
                }
                else
                {
                    Rotate(2);
                }
            }
        }
        else if (vertId[0] == this->vertId[2])
        {
            if (vertId[1] == this->vertId[0] || vertId[1] == this->vertId[1])
            {
                if (vertId[1] == this->vertId[1])
                {
                    Rotate(2);
                    Reflect();
                }
                else
                {
                    Rotate(1);
                }
            }
        }
    }

Reflect()

template<typename T>

void Nektar::NekMeshUtils::HOTriangle< T >::Reflect ( )

inline

Reflect data points inside surfVerts.

This applies a mapping essentially doing the following reordering:

9 9 7 8 -> 8 7 4 5 6 6 5 4 0 1 2 3 3 2 1 0

Definition at line 108 of file HOAlignment.h.

Referenced by Nektar::NekMeshUtils::HOTriangle< T >::Align().

    {
        int i, j, cnt;
        int np = ((int)sqrt(8.0 * surfVerts.size() + 1.0) - 1) / 2;
        std::vector<T> tmp(np * np);

        for (cnt = i = 0; i < np; ++i)
        {
            for (j = 0; j < np - i; ++j, cnt++)
            {
                tmp[i * np + np - i - 1 - j] = surfVerts[cnt];
            }
        }

        for (cnt = i = 0; i < np; ++i)
        {
            for (j = 0; j < np - i; ++j, cnt++)
            {
                surfVerts[cnt] = tmp[i * np + j];
            }
        }
    }

Rotate()

template<typename T>

void Nektar::NekMeshUtils::HOTriangle< T >::Rotate ( int  nrot )

inline

Rotates the triangle of data points inside surfVerts counter-clockwise nrot times.

Parameters

nrot	Number of times to rotate triangle.

Definition at line 72 of file HOAlignment.h.

Referenced by Nektar::NekMeshUtils::HOTriangle< T >::Align().

    {
        int n, i, j, cnt;
        int np = ((int)sqrt(8.0 * surfVerts.size() + 1.0) - 1) / 2;
        std::vector<T> tmp(np * np);

        for (n = 0; n < nrot; ++n)
        {
            for (cnt = i = 0; i < np; ++i)
            {
                for (j = 0; j < np - i; ++j, cnt++)
                {
                    tmp[i * np + j] = surfVerts[cnt];
                }
            }
            for (cnt = i = 0; i < np; ++i)
            {
                for (j = 0; j < np - i; ++j, cnt++)
                {
                    surfVerts[cnt] = tmp[(np - 1 - i - j) * np + i];
                }
            }
        }
    }

Member Data Documentation

surfVerts

template<typename T>

std::vector<T> Nektar::NekMeshUtils::HOTriangle< T >::surfVerts

The triangle surface vertices – templated so that this can either be nodes or IDs.

Definition at line 64 of file HOAlignment.h.

Referenced by Nektar::NekMeshUtils::Prism::GetCurvedNodes(), Nektar::NekMeshUtils::Tetrahedron::GetCurvedNodes(), Nektar::Utilities::InputGmsh::PrismReordering(), Nektar::Utilities::OutputGmsh::Process(), Nektar::NekMeshUtils::Tetrahedron::Tetrahedron(), Nektar::Utilities::InputGmsh::TetReordering(), and Nektar::Utilities::tetTensorNodeOrdering().

vertId

template<typename T>

std::vector<int> Nektar::NekMeshUtils::HOTriangle< T >::vertId

The triangle vertex IDs.

Definition at line 60 of file HOAlignment.h.