#include <NodalPrismEvenlySpaced.h>

Inheritance diagram for Nektar::LibUtilities::NodalPrismEvenlySpaced:

Public Member Functions
virtual	~NodalPrismEvenlySpaced ()

	NodalPrismEvenlySpaced (const PointsKey &key)

const MatrixSharedPtrType	GetI (const PointsKey &pkey)

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

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

const Array< OneD, const NekDouble > &	GetBaryWeights () 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)

virtual const MatrixSharedPtrType	GetGalerkinProjection (const PointsKey &pkey)

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

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

void	CalculatePoints ()

void	CalculateWeights ()

void	CalculateDerivMatrix ()

void	NodalPointReorder3d ()

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

Private Attributes
std::shared_ptr< NodalUtilPrism >	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 >
virtual void	CalculateBaryWeights ()
	This function calculates the barycentric weights used for enhanced interpolation speed. More...

	Points (const PointsKey &key)

Protected Attributes inherited from Nektar::LibUtilities::Points< NekDouble >
PointsKey	m_pointsKey
	Points type for this points distributions. More...

Array< OneD, DataType >	m_points [3]
	Storage for the point locations, allowing for up to a 3D points storage. More...

Array< OneD, DataType >	m_weights
	Quadrature weights for the weights. More...

Array< OneD, DataType >	m_bcweights
	Barycentric weights. More...

MatrixSharedPtrType	m_derivmatrix [3]
	Derivative matrices. More...

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

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

Detailed Description

Definition at line 52 of file NodalPrismEvenlySpaced.h.

Constructor & Destructor Documentation

◆ ~NodalPrismEvenlySpaced()

virtual Nektar::LibUtilities::NodalPrismEvenlySpaced::~NodalPrismEvenlySpaced ( )

inlinevirtual

Definition at line 55 of file NodalPrismEvenlySpaced.h.

56 {

57 }

◆ NodalPrismEvenlySpaced() [1/2]

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

inline

Definition at line 59 of file NodalPrismEvenlySpaced.h.

                                                  : PointsBaseType(key)
     {
     }

◆ NodalPrismEvenlySpaced() [2/2]

Nektar::LibUtilities::NodalPrismEvenlySpaced::NodalPrismEvenlySpaced ( )

inlineprivate

Default constructor should not be called except by Create matrix.

Definition at line 97 of file NodalPrismEvenlySpaced.h.

                              : PointsBaseType(NullPointsKey)
     {
     }

Member Function Documentation

◆ CalculateDerivMatrix()

void Nektar::LibUtilities::NodalPrismEvenlySpaced::CalculateDerivMatrix ( )

privatevirtual

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

Definition at line 429 of file NodalPrismEvenlySpaced.cpp.

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

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

◆ CalculateInterpMatrix()

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

private

Definition at line 411 of file NodalPrismEvenlySpaced.cpp.

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

References m_util, and Vmath::Vcopy().

Referenced by GetI().

◆ CalculatePoints()

void Nektar::LibUtilities::NodalPrismEvenlySpaced::CalculatePoints ( )

privatevirtual

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

Definition at line 163 of file NodalPrismEvenlySpaced.cpp.

 {
     // Allocate the storage for points
     PointsBaseType::CalculatePoints();
  
     // Populate m_points
     unsigned int npts = GetNumPoints();
     NekDouble delta   = 2.0 / (npts - 1.0);
     for (unsigned int z = 0, index = 0; z < npts; ++z)
     {
         for (unsigned int y = 0; y < npts; ++y)
         {
             for (unsigned int x = 0; x < npts - z; ++x, ++index)
             {
                 NekDouble xi = -1.0 + x * delta;
                 NekDouble yi = -1.0 + y * delta;
                 NekDouble zi = -1.0 + z * delta;
  
                 m_points[0][index] = xi;
                 m_points[1][index] = yi;
                 m_points[2][index] = zi;
             }
         }
     }
  
     NodalPointReorder3d();
     m_util = MemoryManager<NodalUtilPrism>::AllocateSharedPtr(
         npts - 1, m_points[0], m_points[1], m_points[2]);
 }

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

◆ CalculateWeights()

void Nektar::LibUtilities::NodalPrismEvenlySpaced::CalculateWeights ( )

privatevirtual

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

Definition at line 396 of file NodalPrismEvenlySpaced.cpp.

 {
     // 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());
 }

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

◆ Create()

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

static

Definition at line 439 of file NodalPrismEvenlySpaced.cpp.

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

◆ GetI() [1/2]

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

inlinevirtual

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

Definition at line 76 of file NodalPrismEvenlySpaced.h.

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

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

◆ GetI() [2/2]

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

inlinevirtual

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

Definition at line 66 of file NodalPrismEvenlySpaced.h.

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

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

◆ NodalPointReorder3d()

void Nektar::LibUtilities::NodalPrismEvenlySpaced::NodalPointReorder3d ( )

private

Definition at line 193 of file NodalPrismEvenlySpaced.cpp.

 {
     unsigned int npts = GetNumPoints();
     using std::vector;
     vector<int> vertex;
     vector<int> iEdge_01;             // interior edge 0
     vector<int> iEdge_12;             // interior edge 1
     vector<int> iEdge_23;             // interior edge 2
     vector<int> iEdge_30;             // interior edge 3
     vector<int> iEdge_04;             // interior edge 4
     vector<int> iEdge_14;             // interior edge 5
     vector<int> iEdge_25;             // interior edge 6
     vector<int> iEdge_35;             // interior edge 7
     vector<int> iEdge_45;             // interior edge 8
     vector<int> iFace_0123;           // interior face 0
     vector<int> iFace_014;            // interior face 1
     vector<int> iFace_1254;           // interior face 2
     vector<int> iFace_325;            // interior face 3
     vector<int> iFace_0354;           // interior face 4
     vector<int> interiorVolumePoints; // interior volume points
     vector<int> map;
  
     // Build the lattice prism left to right - bottom to top
     for (unsigned int z = 0, index = 0; z < npts; ++z)
     {
         for (unsigned int y = 0; y < npts; ++y)
         {
             for (unsigned int x = 0; x < npts - z; ++x, ++index)
             {
                 if (isVertex(x, y, z, npts))
                 {
                     vertex.push_back(index);
                 }
                 else if (isEdge(x, y, z, npts))
                 {
                     if (isEdge_01(x, y, z, npts))
                     {
                         iEdge_01.push_back(index);
                     }
                     else if (isEdge_12(x, y, z, npts))
                     {
                         iEdge_12.push_back(index);
                     }
                     else if (isEdge_23(x, y, z, npts))
                     {
                         iEdge_23.push_back(index);
                     }
                     else if (isEdge_30(x, y, z, npts))
                     {
                         iEdge_30.push_back(index);
                     }
                     else if (isEdge_04(x, y, z, npts))
                     {
                         iEdge_04.push_back(index);
                     }
                     else if (isEdge_14(x, y, z, npts))
                     {
                         iEdge_14.push_back(index);
                     }
                     else if (isEdge_25(x, y, z, npts))
                     {
                         iEdge_25.push_back(index);
                     }
                     else if (isEdge_35(x, y, z, npts))
                     {
                         iEdge_35.push_back(index);
                     }
                     else if (isEdge_45(x, y, z, npts))
                     {
                         iEdge_45.push_back(index);
                     }
                 }
                 else if (isFace(x, y, z, npts))
                 {
                     if (isFace_0123(x, y, z, npts))
                     {
                         iFace_0123.push_back(index);
                     }
                     else if (isFace_014(x, y, z, npts))
                     {
                         iFace_014.push_back(index);
                     }
                     else if (isFace_1254(x, y, z, npts))
                     {
                         iFace_1254.push_back(index);
                     }
                     else if (isFace_325(x, y, z, npts))
                     {
                         iFace_325.push_back(index);
                     }
                     else if (isFace_0354(x, y, z, npts))
                     {
                         iFace_0354.push_back(index);
                     }
                 }
                 else
                 {
                     interiorVolumePoints.push_back(index);
                 }
             }
         }
     }
  
     for (unsigned int n = 0; n < vertex.size(); ++n)
     {
         map.push_back(vertex[n]);
     }
  
     for (unsigned int n = 0; n < iEdge_01.size(); ++n)
     {
         map.push_back(iEdge_01[n]);
     }
  
     for (unsigned int n = 0; n < iEdge_12.size(); ++n)
     {
         map.push_back(iEdge_12[n]);
     }
  
     for (unsigned int n = 0; n < iEdge_23.size(); ++n)
     {
         map.push_back(iEdge_23[n]);
     }
  
     for (unsigned int n = 0; n < iEdge_30.size(); ++n)
     {
         map.push_back(iEdge_30[n]);
     }
  
     for (unsigned int n = 0; n < iEdge_04.size(); ++n)
     {
         map.push_back(iEdge_04[n]);
     }
  
     for (unsigned int n = 0; n < iEdge_14.size(); ++n)
     {
         map.push_back(iEdge_14[n]);
     }
  
     for (unsigned int n = 0; n < iEdge_25.size(); ++n)
     {
         map.push_back(iEdge_25[n]);
     }
  
     for (unsigned int n = 0; n < iEdge_35.size(); ++n)
     {
         map.push_back(iEdge_35[n]);
     }
  
     for (unsigned int n = 0; n < iEdge_45.size(); ++n)
     {
         map.push_back(iEdge_45[n]);
     }
  
     for (unsigned int n = 0; n < iFace_0123.size(); ++n)
     {
         map.push_back(iFace_0123[n]);
     }
  
     for (unsigned int n = 0; n < iFace_014.size(); ++n)
     {
         map.push_back(iFace_014[n]);
     }
  
     for (unsigned int n = 0; n < iFace_1254.size(); ++n)
     {
         map.push_back(iFace_1254[n]);
     }
  
     for (unsigned int n = 0; n < iFace_325.size(); ++n)
     {
         map.push_back(iFace_325[n]);
     }
  
     for (unsigned int n = 0; n < iFace_0354.size(); ++n)
     {
         map.push_back(iFace_0354[n]);
     }
  
     for (unsigned int n = 0; n < interiorVolumePoints.size(); ++n)
     {
         map.push_back(interiorVolumePoints[n]);
     }
  
     Array<OneD, NekDouble> points[3];
     points[0] = Array<OneD, NekDouble>(GetTotNumPoints());
     points[1] = Array<OneD, NekDouble>(GetTotNumPoints());
     points[2] = 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];
         points[2][index] = m_points[2][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]];
         m_points[2][index] = points[2][map[index]];
     }
 }

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

Referenced by CalculatePoints().

Member Data Documentation

◆ initPointsManager

bool Nektar::LibUtilities::NodalPrismEvenlySpaced::initPointsManager

staticprivate

Initial value:

= {
    PointsManager().RegisterCreator(PointsKey(0, eNodalPrismEvenlySpaced),
                                    NodalPrismEvenlySpaced::Create)}

Definition at line 92 of file NodalPrismEvenlySpaced.h.

◆ m_util

std::shared_ptr<NodalUtilPrism> Nektar::LibUtilities::NodalPrismEvenlySpaced::m_util

private

Definition at line 94 of file NodalPrismEvenlySpaced.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

◆ ~NodalPrismEvenlySpaced()

◆ NodalPrismEvenlySpaced() [1/2]

◆ NodalPrismEvenlySpaced() [2/2]

Member Function Documentation

◆ CalculateDerivMatrix()

◆ CalculateInterpMatrix()

◆ CalculatePoints()

◆ CalculateWeights()

◆ Create()

◆ GetI() [1/2]

◆ GetI() [2/2]

◆ NodalPointReorder3d()

Member Data Documentation

◆ initPointsManager

◆ m_util