#include <NodalTriFekete.h>

Inheritance diagram for Nektar::LibUtilities::NodalTriFekete:

Public Member Functions
virtual	~NodalTriFekete ()

	NodalTriFekete (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
	NodalTriFekete ()

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 54 of file NodalTriFekete.h.

Constructor & Destructor Documentation

◆ ~NodalTriFekete()

virtual Nektar::LibUtilities::NodalTriFekete::~NodalTriFekete ( )

inlinevirtual

Definition at line 57 of file NodalTriFekete.h.

58 {

59 }

◆ NodalTriFekete() [1/2]

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

inline

Definition at line 61 of file NodalTriFekete.h.

References Create(), and LIB_UTILITIES_EXPORT.

                                                 :PointsBaseType(key)
             {
             }

◆ NodalTriFekete() [2/2]

Nektar::LibUtilities::NodalTriFekete::NodalTriFekete ( )

inlineprivate

Definition at line 98 of file NodalTriFekete.h.

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

                             :PointsBaseType(NullPointsKey)
             {
             }

Member Function Documentation

◆ CalculateDerivMatrix()

void Nektar::LibUtilities::NodalTriFekete::CalculateDerivMatrix ( )

privatevirtual

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

Definition at line 165 of file NodalTriFekete.cpp.

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

Referenced by NodalTriFekete().

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

◆ CalculateInterpMatrix()

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

private

Definition at line 150 of file NodalTriFekete.cpp.

References m_util, and Vmath::Vcopy().

Referenced by GetI(), and NodalTriFekete().

         {
              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::NodalTriFekete::CalculatePoints ( )

privatevirtual

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

Definition at line 56 of file NodalTriFekete.cpp.

Referenced by NodalTriFekete().

         {
             // Allocate the storage for points
             PointsBaseType::CalculatePoints();
 
             int index=0,isum=0;
             const int offset = 3; //offset to match Datafile
             NekDouble b,c;
             unsigned int numPoints = GetNumPoints();
 
             // initialize values
             for(unsigned int i=0; i < numPoints-2; ++i)
             {
                 index += NodalTriFeketeNPTS[i];
             }
 
             for(unsigned int i=0; i < NodalTriFeketeNPTS[numPoints-2]; ++i, ++index)
             {
                 if(int(NodalTriFeketeData[index][0]))
                 {
                     b = NodalTriFeketeData[index][4];
                     c = NodalTriFeketeData[index][5];
 
                     m_points[0][isum] = 2.0*b - 1.0;
                     m_points[1][isum] = 2.0*c - 1.0;
                     isum++;
                     continue;
                 }//end symmetry1
 
 
                 if(int(NodalTriFeketeData[index][1]) == 1)
                 {
                     for(unsigned int j=0; j < 3; ++j)
                     {
                         b = NodalTriFeketeData[index][offset+perm3A_2d[j][1]];
                         c = NodalTriFeketeData[index][offset+perm3A_2d[j][2]];
                         m_points[0][isum] = 2.0*b - 1.0;
                         m_points[1][isum] = 2.0*c - 1.0;
                         isum++;
                     }//end j
                     continue;
                 }//end symmetry3a
 
                 if(int(NodalTriFeketeData[index][1]) == 2)
                 {
                     for(unsigned int j=0; j < 3; ++j)
                     {
                         b = NodalTriFeketeData[index][offset+perm3B_2d[j][1]];
                         c = NodalTriFeketeData[index][offset+perm3B_2d[j][2]];
                         m_points[0][isum] = 2.0*b - 1.0;
                         m_points[1][isum] = 2.0*c - 1.0;
                         isum++;
                     }//end j
                     continue;
                 }//end symmetry3b
 
 
                 if(int(NodalTriFeketeData[index][2]))
                 {
                     for(unsigned int j=0; j < 6; ++j)
                     {
                         b = NodalTriFeketeData[index][offset+perm6_2d[j][1]];
                         c = NodalTriFeketeData[index][offset+perm6_2d[j][2]];
                         m_points[0][isum] = 2.0*b - 1.0;
                         m_points[1][isum] = 2.0*c - 1.0;
                         isum++;
                     }//end j
                     continue;
                 }//end symmetry6
             }//end npts
 
             NodalPointReorder2d();
 
             ASSERTL1((static_cast<unsigned int>(isum)==m_pointsKey.GetTotNumPoints()),"sum not equal to npts");
 
             m_util = MemoryManager<NodalUtilTriangle>::AllocateSharedPtr(
                 numPoints - 1, m_points[0], m_points[1]);
         }

◆ CalculateWeights()

void Nektar::LibUtilities::NodalTriFekete::CalculateWeights ( )

privatevirtual

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

Definition at line 135 of file NodalTriFekete.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 NodalTriFekete().

         {
             // 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::NodalTriFekete::Create ( const PointsKey & key )

static

Definition at line 174 of file NodalTriFekete.cpp.

Referenced by NodalTriFekete().

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

◆ GetI() [1/2]

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

inlinevirtual

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

Definition at line 68 of file NodalTriFekete.h.

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

             {
                 ASSERTL0(pkey.GetPointsDim() == 2,
                          "Fekete 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::NodalTriFekete::GetI	(	const Array< OneD, const NekDouble > &	x,
		const Array< OneD, const NekDouble > &	y
	)

inlinevirtual

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

Definition at line 78 of file NodalTriFekete.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::NodalTriFekete::NodalPointReorder2d ( )

private

Definition at line 181 of file NodalTriFekete.cpp.

References Nektar::LibUtilities::Points< NekDouble >::GetNumPoints(), Nektar::NekConstants::kNekZeroTol, Nektar::LibUtilities::Points< NekDouble >::m_points, and Nektar::Array< OneD, const DataType >::num_elements().

Referenced by CalculatePoints(), and NodalTriFekete().

         {
             int i,j;
             int cnt;
             int istart,iend;
 
             const int nVerts = 3;
             const int nEdgeInteriorPoints = GetNumPoints()-2;
             const int nBoundaryPoints = 3*nEdgeInteriorPoints + 3;
 
             if(nEdgeInteriorPoints==0)
             {
                 return;
             }
 
             // group the points of edge 1 together;
             istart = nVerts;
             for(i = cnt = istart; i < nBoundaryPoints; i++)
             {
                 if( fabs(m_points[1][i] + 1.0) < NekConstants::kNekZeroTol)
                 {
                     std::swap(m_points[0][cnt], m_points[0][i]);
                     std::swap(m_points[1][cnt], m_points[1][i]);
                     cnt++;
                 }
             }
 
             // bubble sort edge 1 (counterclockwise numbering)
             iend = istart + nEdgeInteriorPoints;
             for(i = istart; i < iend; i++)
             {
                 for(j = istart+1; j < iend; j++)
                 {
                     if(m_points[0][j] < m_points[0][j-1])
                     {
                         std::swap(m_points[0][j], m_points[0][j-1]);
                         std::swap(m_points[1][j], m_points[1][j-1]);
                     }
                 }
             }
 
             // group the points of edge 2 together;
             istart = iend;
             for(i = cnt = istart; i < nBoundaryPoints; i++)
             {
                 if( fabs(m_points[1][i]+m_points[0][i]) < NekConstants::kNekZeroTol)
                 {
                     std::swap(m_points[0][cnt], m_points[0][i]);
                     std::swap(m_points[1][cnt], m_points[1][i]);
                     cnt++;
                 }
             }
 
             // bubble sort edge 2 (counterclockwise numbering)
             iend = istart + nEdgeInteriorPoints;
             for(i = istart; i < iend; i++)
             {
                 for(j = istart+1; j < iend; j++)
                 {
                     if(m_points[1][j] < m_points[1][j-1])
                     {
                         std::swap(m_points[0][j], m_points[0][j-1]);
                         std::swap(m_points[1][j], m_points[1][j-1]);
                     }
                 }
             }
 
             // group the points of edge 3 together;
             istart = iend;
             for(i = cnt = istart; i < nBoundaryPoints; i++)
             {
                 if( fabs(m_points[0][i]+1.0) < NekConstants::kNekZeroTol)
                 {
                     std::swap(m_points[0][cnt], m_points[0][i]);
                     std::swap(m_points[1][cnt], m_points[1][i]);
                     cnt++;
                 }
             }
             // bubble sort edge 3 (counterclockwise numbering)
             iend = istart + nEdgeInteriorPoints;
             for(i = istart; i < iend; i++)
             {
                 for(j = istart+1; j < iend; j++)
                 {
                     if(m_points[1][j] > m_points[1][j-1])
                     {
                         std::swap(m_points[0][j], m_points[0][j-1]);
                         std::swap(m_points[1][j], m_points[1][j-1]);
                     }
                 }
             }
 
             if(GetNumPoints() < 5)
             {
                 //at numpoints = 4 there is only one interior point so doesnt
                 //need sorting
                 return;
             }
 
             //someone forgot to finish this piece of code and tell anyone
             //that they didnt
             //face interior nodes needs to be considered
             //make a copy of the unsorted nodes
             //bubble sort by smallest y
             //which will put them into sets of ever decreasing size
             //which can be bubble sorted by x to obtain the distrobution
 
             Array<OneD, NekDouble> xc(m_points[0].num_elements() - iend);
             Array<OneD, NekDouble> yc(m_points[0].num_elements() - iend);
             int ct = 0;
             for(i = iend; i < m_points[0].num_elements(); i++, ct++)
             {
                 xc[ct] = m_points[0][i];
                 yc[ct] = m_points[1][i];
             }
 
             //sort smallest first
             bool repeat = true;
             while(repeat)
             {
                 repeat = false;
                 for(i = 0; i < xc.num_elements() - 1; i++)
                 {
                     if(yc[i] > yc[i+1])
                     {
                         std::swap(xc[i],xc[i+1]);
                         std::swap(yc[i],yc[i+1]);
                         repeat = true;
                     }
                 }
             }
 
             int offset = 0;
             int npl = GetNumPoints() - 3;
             while(npl > 1)
             {
                 repeat = true;
                 while(repeat)
                 {
                     repeat = false;
                     for(i = offset; i < offset + npl - 1; i++)
                     {
                         if(xc[i] > xc[i+1])
                         {
                             std::swap(xc[i],xc[i+1]);
                             std::swap(yc[i],yc[i+1]);
                             repeat = true;
                         }
                     }
                 }
                 offset += npl;
                 npl--;
             }
 
             //copy back in
             ct = 0;
             for(i = iend; i < m_points[0].num_elements(); i++, ct++)
             {
                 m_points[0][i] = xc[ct];
                 m_points[1][i] = yc[ct];
             }
             return;
         }

Member Data Documentation

◆ initPointsManager

bool Nektar::LibUtilities::NodalTriFekete::initPointsManager

staticprivate

Initial value:

= {
            PointsManager().RegisterCreator(PointsKey(0, eNodalTriFekete),       NodalTriFekete::Create)
        }

Definition at line 94 of file NodalTriFekete.h.

◆ m_util

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

private

Definition at line 96 of file NodalTriFekete.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

◆ ~NodalTriFekete()

◆ NodalTriFekete() [1/2]

◆ NodalTriFekete() [2/2]

Member Function Documentation

◆ CalculateDerivMatrix()

◆ CalculateInterpMatrix()

◆ CalculatePoints()

◆ CalculateWeights()

◆ Create()

◆ GetI() [1/2]

◆ GetI() [2/2]

◆ NodalPointReorder2d()

Member Data Documentation

◆ initPointsManager

◆ m_util