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

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

#include <HOAlignment.h>

Public Member Functions
	HOQuadrilateral (std::vector< int > pVertId, std::vector< T > pSurfVerts)
	HOQuadrilateral (std::vector< int > pVertId)
void	ReverseX ()
void	ReverseY ()
void	Transpose ()
void	Align (std::vector< int > vertId)
	Align this surface to a given vertex ID. More...

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

Detailed Description

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

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

Definition at line 208 of file HOAlignment.h.

Constructor & Destructor Documentation

HOQuadrilateral() [1/2]

template<typename T>

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

inline

Definition at line 210 of file HOAlignment.h.

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

HOQuadrilateral() [2/2]

template<typename T>

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

inline

Definition at line 215 of file HOAlignment.h.

                                            : vertId(pVertId)
    {
    }

Member Function Documentation

Align()

template<typename T>

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

inline

Align this surface to a given vertex ID.

Definition at line 270 of file HOAlignment.h.

References ASSERTL1, Nektar::StdRegions::eDir1BwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1BwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1BwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1BwdDir2_Dir2FwdDir1, Nektar::StdRegions::eDir1FwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1FwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1FwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, Nektar::StdRegions::eNoOrientation, and Nektar::Transpose().

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

    {

        int vmap[4] = {-1, -1, -1, -1};

        // Determine which vertices map to vertId
        for (int i = 0; i < 4; ++i)
        {
            for (int j = 0; j < 4; ++j)
            {
                if (this->vertId[j] == vertId[i])
                {
                    vmap[i] = j;
                    break;
                }
            }

            ASSERTL1(vmap[i] != -1,
                     "Could not determine mapping between vertex IDs");
        }

        StdRegions::Orientation orient = StdRegions::eNoOrientation;

        if (vmap[1] == (vmap[0]+1) % 4)
        {
            switch (vmap[0])
            {
                case 0:
                    orient = StdRegions::eDir1FwdDir1_Dir2FwdDir2;
                    break;
                case 1:
                    orient = StdRegions::eDir1BwdDir2_Dir2FwdDir1;
                    break;
                case 2:
                    orient = StdRegions::eDir1BwdDir1_Dir2BwdDir2;
                    break;
                case 3:
                    orient = StdRegions::eDir1FwdDir2_Dir2BwdDir1;
                    break;
            }
        }
        else
        {
            switch (vmap[0])
            {
                case 0:
                    orient = StdRegions::eDir1FwdDir2_Dir2FwdDir1;
                    break;
                case 1:
                    orient = StdRegions::eDir1BwdDir1_Dir2FwdDir2;
                    break;
                case 2:
                    orient = StdRegions::eDir1BwdDir2_Dir2BwdDir1;
                    break;
                case 3:
                    orient = StdRegions::eDir1FwdDir1_Dir2BwdDir2;
                    break;
            }
        }

        if (orient == StdRegions::eDir1FwdDir2_Dir2FwdDir1 ||
            orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
            orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
            orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
        {
            Transpose();
        }

        if (orient == StdRegions::eDir1BwdDir1_Dir2FwdDir2 ||
            orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
            orient == StdRegions::eDir1FwdDir2_Dir2BwdDir1 ||
            orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
        {
            ReverseX();
        }

        if (orient == StdRegions::eDir1FwdDir1_Dir2BwdDir2 ||
            orient == StdRegions::eDir1BwdDir1_Dir2BwdDir2 ||
            orient == StdRegions::eDir1BwdDir2_Dir2FwdDir1 ||
            orient == StdRegions::eDir1BwdDir2_Dir2BwdDir1)
        {
            ReverseY();
        }
    }

ReverseX()

template<typename T>

void Nektar::NekMeshUtils::HOQuadrilateral< T >::ReverseX ( )

inline

Definition at line 226 of file HOAlignment.h.

    {
        int np = (int)(sqrt((NekDouble)surfVerts.size()) + 0.5);
        for (int i = 0; i < np; ++i)
        {
            for (int j = 0; j < np/2; ++j)
            {
                swap(surfVerts[i*np + j], surfVerts[i*np + np-j-1]);
            }
        }
    }

ReverseY()

template<typename T>

void Nektar::NekMeshUtils::HOQuadrilateral< T >::ReverseY ( )

inline

Definition at line 238 of file HOAlignment.h.

    {
        int np = (int)(sqrt((NekDouble)surfVerts.size()) + 0.5);
        // Reverse y direction
        for (int j = 0; j < np; ++j)
        {
            for (int i = 0; i < np/2; ++i)
            {
                swap(surfVerts[i*np + j], surfVerts[(np-i-1)*np + j]);
            }
        }
    }

Transpose()

template<typename T>

void Nektar::NekMeshUtils::HOQuadrilateral< T >::Transpose ( )

inline

Definition at line 251 of file HOAlignment.h.

    {
        int np = (int)(sqrt((NekDouble)surfVerts.size()) + 0.5);
        std::vector<T> tmp(surfVerts.size());

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

        surfVerts = tmp;
    }

Member Data Documentation

surfVerts

template<typename T>

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

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

Definition at line 224 of file HOAlignment.h.

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

vertId

template<typename T>

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

The quadrilateral vertex IDs.

Definition at line 220 of file HOAlignment.h.