#include <NodalTriEvenlySpaced.h>

Inheritance diagram for Nektar::LibUtilities::NodalTriEvenlySpaced:

Public Member Functions
virtual	~NodalTriEvenlySpaced ()

	NodalTriEvenlySpaced (const PointsKey &key)

const MatrixSharedPtrType	GetI (const PointsKey &pkey)

const MatrixSharedPtrType	GetI (const Array< OneD, const NekDouble > &x, const Array< OneD, const NekDouble > &y)

Public Member Functions inherited from Nektar::LibUtilities::Points< NekDouble >
virtual	~Points ()

virtual void	Initialize (void)

unsigned int	GetPointsDim () const

unsigned int	GetNumPoints () const

unsigned int	GetTotNumPoints () const

PointsType	GetPointsType () const

const Array< OneD, const DataType > &	GetZ () const

const Array< OneD, const DataType > &	GetW () const

void	GetZW (Array< OneD, const DataType > &z, Array< OneD, const DataType > &w) const

void	GetPoints (Array< OneD, const DataType > &x) const

void	GetPoints (Array< OneD, const DataType > &x, Array< OneD, const DataType > &y) const

void	GetPoints (Array< OneD, const DataType > &x, Array< OneD, const DataType > &y, Array< OneD, const DataType > &z) const

const MatrixSharedPtrType &	GetD (Direction dir=xDir) const

virtual const MatrixSharedPtrType	GetI (const Array< OneD, const DataType > &x)

virtual const MatrixSharedPtrType	GetI (unsigned int, const Array< OneD, const DataType > &x)

virtual const MatrixSharedPtrType	GetI (const Array< OneD, const DataType > &x, const Array< OneD, const DataType > &y, const Array< OneD, const DataType > &z)

virtual const MatrixSharedPtrType	GetGalerkinProjection (const PointsKey &pkey)

Static Public Member Functions
static std::shared_ptr< PointsBaseType >	Create (const PointsKey &key)

Private Member Functions
	NodalTriEvenlySpaced ()
	Deafult constructor should not be called except by Create matrix. More...

void	CalculatePoints ()

void	CalculateWeights ()

void	CalculateDerivMatrix ()

void	NodalPointReorder2d ()

void	CalculateInterpMatrix (const Array< OneD, const NekDouble > &xi, const Array< OneD, const NekDouble > &yi, Array< OneD, NekDouble > &interp)

Private Attributes
std::shared_ptr< NodalUtilTriangle >	m_util

Static Private Attributes
static bool	initPointsManager []

Additional Inherited Members
Public Types inherited from Nektar::LibUtilities::Points< NekDouble >
typedef NekDouble	DataType

typedef std::shared_ptr< NekMatrix< DataType > >	MatrixSharedPtrType

Protected Member Functions inherited from Nektar::LibUtilities::Points< NekDouble >
	Points (const PointsKey &key)

Protected Attributes inherited from Nektar::LibUtilities::Points< NekDouble >
PointsKey	m_pointsKey

Array< OneD, DataType >	m_points [3]

Array< OneD, DataType >	m_weights

MatrixSharedPtrType	m_derivmatrix [3]

NekManager< PointsKey, NekMatrix< DataType >, PointsKey::opLess >	m_InterpManager

NekManager< PointsKey, NekMatrix< DataType >, PointsKey::opLess >	m_GalerkinProjectionManager

Detailed Description

Definition at line 51 of file NodalTriEvenlySpaced.h.

Constructor & Destructor Documentation

◆ ~NodalTriEvenlySpaced()

virtual Nektar::LibUtilities::NodalTriEvenlySpaced::~NodalTriEvenlySpaced ( )

inlinevirtual

Definition at line 54 of file NodalTriEvenlySpaced.h.

             {
                             
             }

◆ NodalTriEvenlySpaced() [1/2]

Nektar::LibUtilities::NodalTriEvenlySpaced::NodalTriEvenlySpaced ( const PointsKey & key )

inline

Definition at line 59 of file NodalTriEvenlySpaced.h.

References Create(), and LIB_UTILITIES_EXPORT.

                                                        : PointsBaseType(key)
             {
 
             }

◆ NodalTriEvenlySpaced() [2/2]

Nektar::LibUtilities::NodalTriEvenlySpaced::NodalTriEvenlySpaced ( )

inlineprivate

Deafult constructor should not be called except by Create matrix.

Definition at line 98 of file NodalTriEvenlySpaced.h.

References CalculateDerivMatrix(), CalculateInterpMatrix(), CalculatePoints(), CalculateWeights(), and NodalPointReorder2d().

                                   :PointsBaseType(NullPointsKey)
             {
             }

Member Function Documentation

◆ CalculateDerivMatrix()

void Nektar::LibUtilities::NodalTriEvenlySpaced::CalculateDerivMatrix ( )

privatevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 135 of file NodalTriEvenlySpaced.cpp.

References Nektar::LibUtilities::Points< NekDouble >::CalculateDerivMatrix(), Nektar::LibUtilities::Points< NekDouble >::m_derivmatrix, and m_util.

Referenced by NodalTriEvenlySpaced().

         {
             
             // Allocate the derivative matrix.
             PointsBaseType::CalculateDerivMatrix();
 
             m_derivmatrix[0] = m_util->GetDerivMatrix(0);
             m_derivmatrix[1] = m_util->GetDerivMatrix(1);
         } 

◆ CalculateInterpMatrix()

void Nektar::LibUtilities::NodalTriEvenlySpaced::CalculateInterpMatrix	(	const Array< OneD, const NekDouble > &	xi,
		const Array< OneD, const NekDouble > &	yi,
		Array< OneD, NekDouble > &	interp
	)

private

Definition at line 119 of file NodalTriEvenlySpaced.cpp.

References m_util, and Vmath::Vcopy().

Referenced by GetI(), and NodalTriEvenlySpaced().

         {
             Array<OneD, Array<OneD, NekDouble> > xi(2);
             xi[0] = xia;
             xi[1] = yia;
 
             std::shared_ptr<NekMatrix<NekDouble> > mat =
                 m_util->GetInterpolationMatrix(xi);
             Vmath::Vcopy(mat->GetRows() * mat->GetColumns(), mat->GetRawPtr(),
                          1, &interp[0], 1);
         }

◆ CalculatePoints()

void Nektar::LibUtilities::NodalTriEvenlySpaced::CalculatePoints ( )

privatevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 78 of file NodalTriEvenlySpaced.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::Points< NekDouble >::CalculatePoints(), Nektar::LibUtilities::Points< NekDouble >::GetNumPoints(), Nektar::LibUtilities::Points< NekDouble >::m_points, m_util, and NodalPointReorder2d().

Referenced by NodalTriEvenlySpaced().

         {
             // Allocate the storage for points
             PointsBaseType::CalculatePoints();
 
             // Populate m_points
             unsigned int npts = GetNumPoints();
             NekDouble delta = 2.0/(npts - 1.0);
             for(int i=0, index=0; i<npts; ++i){ // y-direction
                 for(int j=0; j<npts-i; ++j,++index){ // x-direction
                     NekDouble    x = -1.0 + j*delta;
                     NekDouble    y = -1.0 + i*delta;
                     m_points[0][index] = x;
                     m_points[1][index] = y;
                 }
             }
 
             NodalPointReorder2d();
 
             m_util = MemoryManager<NodalUtilTriangle>::AllocateSharedPtr(
                 npts - 1, m_points[0], m_points[1]);
         }

◆ CalculateWeights()

void Nektar::LibUtilities::NodalTriEvenlySpaced::CalculateWeights ( )

privatevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 102 of file NodalTriEvenlySpaced.cpp.

References Nektar::LibUtilities::Points< NekDouble >::CalculateWeights(), Nektar::NekVector< DataType >::GetPtr(), Nektar::NekVector< DataType >::GetRows(), m_util, and Nektar::LibUtilities::Points< NekDouble >::m_weights.

Referenced by NodalTriEvenlySpaced().

         {            
             // Allocate the storage for points
             PointsBaseType::CalculateWeights();
 
             typedef DataType T;
             
             // Solve the Vandermonde system of integrals for the weight vector
             NekVector<T> w = m_util->GetWeights();
 
             m_weights = Array<OneD,T>( w.GetRows(), w.GetPtr() );
 
         }

◆ Create()

std::shared_ptr< PointsBaseType > Nektar::LibUtilities::NodalTriEvenlySpaced::Create ( const PointsKey & key )

static

Definition at line 145 of file NodalTriEvenlySpaced.cpp.

Referenced by NodalTriEvenlySpaced().

         {
             std::shared_ptr<PointsBaseType> returnval(MemoryManager<NodalTriEvenlySpaced>::AllocateSharedPtr(key));
 
             returnval->Initialize();
 
             return returnval;
         }

◆ GetI() [1/2]

const MatrixSharedPtrType Nektar::LibUtilities::NodalTriEvenlySpaced::GetI ( const PointsKey & pkey )

inlinevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 67 of file NodalTriEvenlySpaced.h.

References ASSERTL0, Nektar::LibUtilities::PointsKey::GetPointsDim(), and Nektar::LibUtilities::PointsManager().

             {
                 ASSERTL0(pkey.GetPointsDim() == 2, 
                          "NodalTriEvenlySpaced Points can only interp to other "
                          "2d point distributions");
                 Array<OneD, const NekDouble> x, y;
                 PointsManager()[pkey]->GetPoints(x, y);
                 return GetI(x, y);
             }

◆ GetI() [2/2]

const MatrixSharedPtrType Nektar::LibUtilities::NodalTriEvenlySpaced::GetI	(	const Array< OneD, const NekDouble > &	x,
		const Array< OneD, const NekDouble > &	y
	)

inlinevirtual

Reimplemented from Nektar::LibUtilities::Points< NekDouble >.

Definition at line 77 of file NodalTriEvenlySpaced.h.

References CalculateInterpMatrix(), and Nektar::LibUtilities::Points< NekDouble >::GetTotNumPoints().

             {
                 size_t       numpoints = x.num_elements();
                 unsigned int np        = GetTotNumPoints();
                 
                 Array<OneD, NekDouble> interp(GetTotNumPoints()*numpoints);
                 CalculateInterpMatrix(x, y, interp);
                 
                 NekDouble* d = interp.data();
                 return MemoryManager<NekMatrix<NekDouble> >
                     ::AllocateSharedPtr(numpoints, np, d);
             }

◆ NodalPointReorder2d()

void Nektar::LibUtilities::NodalTriEvenlySpaced::NodalPointReorder2d ( )

private

Definition at line 154 of file NodalTriEvenlySpaced.cpp.

References Nektar::LibUtilities::Points< NekDouble >::GetNumPoints(), Nektar::LibUtilities::Points< NekDouble >::GetTotNumPoints(), and Nektar::LibUtilities::Points< NekDouble >::m_points.

Referenced by CalculatePoints(), and NodalTriEvenlySpaced().

         {
             unsigned int npts = GetNumPoints();
             using std::vector;
             vector<int> vertex;
             vector<int> iEdge_1; // interior edge points on the bottom triangle edge
             vector<int> iEdge_2; // interior edge points on the right triangle edge
             vector<int> iEdge_3; // interior edge points on the left triangle edge
             vector<int> interiorPoints;
             vector<int> map;
 
                // Build the lattice triangle left to right - bottom to top
             for(int i=0, index=0; i<npts; ++i){ // y-direction
                 for(int j=0; j<npts-i; ++j,++index){ // x-direction
 
                     if( isVertex(i,j,npts) ) {
 
                         vertex.push_back(index);
 
                     } else if( isEdge(i,j,npts) ) { // interior edge
 
                         if(isEdge_1(i,j,npts)){  // bottom edge
 
                             iEdge_1.push_back(index);
 
                         }else if(isEdge_2(i,j,npts)){  // right edge
 
                             iEdge_2.push_back(index);
 
                         }else   // left edge
                         {
                             // Add backwards.  This is because of counter clockwise.
                             iEdge_3.insert(iEdge_3.begin(), index);
                         }
 
                     } else { // Interior points
 
                         interiorPoints.push_back(index);
                     }
                 }
             }
 
             // Mapping the vertex, edges, and interior points using the permutation matrix,
             // so the points are ordered anticlockwise.
             for(unsigned int k=0; k<vertex.size(); ++k){
 
                 map.push_back(vertex[k]);
             }
 
             for(unsigned int k=0; k<iEdge_1.size(); ++k){
 
                 map.push_back(iEdge_1[k]);
             }
 
             for(unsigned int k=0; k<iEdge_2.size(); ++k){
 
                 map.push_back(iEdge_2[k]);
             }
 
             for(unsigned int k=0; k<iEdge_3.size(); ++k){
 
                 map.push_back(iEdge_3[k]);
             }
             
             for(unsigned int k=0; k<interiorPoints.size(); ++k){
 
                 map.push_back(interiorPoints[k]);
             }
 
 
             Array<OneD,NekDouble> points[2];
             points[0] = Array<OneD,NekDouble>(GetTotNumPoints());
             points[1] = Array<OneD,NekDouble>(GetTotNumPoints());
             for(unsigned int index=0; index<map.size(); ++index){
                 points[0][index] = m_points[0][index];
                 points[1][index] = m_points[1][index];
             }
             
             for(unsigned int index=0; index<map.size(); ++index){
                 m_points[0][index] = points[0][map[index]];
                 m_points[1][index] = points[1][map[index]];
             }
 
         }

Member Data Documentation

◆ initPointsManager

bool Nektar::LibUtilities::NodalTriEvenlySpaced::initPointsManager

staticprivate

Initial value:

= {
            PointsManager().RegisterCreator(PointsKey(0, eNodalTriEvenlySpaced), NodalTriEvenlySpaced::Create)
        }

Definition at line 93 of file NodalTriEvenlySpaced.h.

◆ m_util

std::shared_ptr<NodalUtilTriangle> Nektar::LibUtilities::NodalTriEvenlySpaced::m_util

private

Definition at line 95 of file NodalTriEvenlySpaced.h.

Referenced by CalculateDerivMatrix(), CalculateInterpMatrix(), CalculatePoints(), and CalculateWeights().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~NodalTriEvenlySpaced()

◆ NodalTriEvenlySpaced() [1/2]

◆ NodalTriEvenlySpaced() [2/2]

Member Function Documentation

◆ CalculateDerivMatrix()

◆ CalculateInterpMatrix()

◆ CalculatePoints()

◆ CalculateWeights()

◆ Create()

◆ GetI() [1/2]

◆ GetI() [2/2]

◆ NodalPointReorder2d()

Member Data Documentation

◆ initPointsManager

◆ m_util