#include <NodalPrismElec.h>

Inheritance diagram for Nektar::LibUtilities::NodalPrismElec:

Collaboration diagram for Nektar::LibUtilities::NodalPrismElec:

Public Member Functions
virtual	~NodalPrismElec ()

	NodalPrismElec (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

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 numpoints, 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 boost::shared_ptr < PointsBaseType >	Create (const PointsKey &key)

Private Member Functions
	NodalPrismElec ()
	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
boost::shared_ptr< NodalUtilPrism >	m_util

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

typedef boost::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 53 of file NodalPrismElec.h.

Constructor & Destructor Documentation

virtual Nektar::LibUtilities::NodalPrismElec::~NodalPrismElec ( )

inlinevirtual

Definition at line 56 of file NodalPrismElec.h.

57 {

58 }

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

inline

Definition at line 60 of file NodalPrismElec.h.

                                          : PointsBaseType(key)
     {
     }

Nektar::LibUtilities::NodalPrismElec::NodalPrismElec ( )

inlineprivate

Default constructor should not be called except by Create matrix.

Definition at line 96 of file NodalPrismElec.h.

                      : PointsBaseType(NullPointsKey)
     {
     }

Member Function Documentation

void Nektar::LibUtilities::NodalPrismElec::CalculateDerivMatrix ( )

privatevirtual

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

Definition at line 437 of file NodalPrismElec.cpp.

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

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

void Nektar::LibUtilities::NodalPrismElec::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 419 of file NodalPrismElec.cpp.

References m_util, and Vmath::Vcopy().

Referenced by GetI().

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

void Nektar::LibUtilities::NodalPrismElec::CalculatePoints ( )

privatevirtual

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

Definition at line 143 of file NodalPrismElec.cpp.

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

 {
     // Allocate the storage for points
     PointsBaseType::CalculatePoints();
 
     // Populate m_points
     unsigned int npts = GetNumPoints();
 
     LibUtilities::PointsKey pkey1(npts, LibUtilities::eNodalTriElec);
     Array<OneD, NekDouble> u1, v1;
     LibUtilities::PointsManager()[pkey1]->GetPoints(u1, v1);
     LibUtilities::PointsKey pkey2(npts, LibUtilities::eGaussLobattoLegendre);
     Array<OneD, NekDouble> u;
     LibUtilities::PointsManager()[pkey2]->GetPoints(u);
 
     for (int y = 0, index = 0; y < npts; y++)
     {
         for (int t = 0; t < u1.num_elements(); t++, index++)
         {
             m_points[0][index] = u1[t];
             m_points[1][index] = u[y];
             m_points[2][index] = v1[t];
         }
     }
 
     NodalPointReorder3d();
     m_util = MemoryManager<NodalUtilPrism>::AllocateSharedPtr(
         npts - 1, m_points[0], m_points[1], m_points[2]);
 }

void Nektar::LibUtilities::NodalPrismElec::CalculateWeights ( )

privatevirtual

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

Definition at line 404 of file NodalPrismElec.cpp.

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

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

boost::shared_ptr< PointsBaseType > Nektar::LibUtilities::NodalPrismElec::Create ( const PointsKey & key )

static

Definition at line 447 of file NodalPrismElec.cpp.

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

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

inlinevirtual

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

Definition at line 67 of file NodalPrismElec.h.

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

     {
         ASSERTL0(pkey.GetPointsDim() == 3,
                  "NodalPrismElec 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);
     }

const MatrixSharedPtrType Nektar::LibUtilities::NodalPrismElec::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 77 of file NodalPrismElec.h.

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

     {
         int numpoints   = x.num_elements();
         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);
     }

void Nektar::LibUtilities::NodalPrismElec::NodalPointReorder3d ( )

private

Definition at line 173 of file NodalPrismElec.cpp.

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

Referenced by CalculatePoints().

 {
     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 (int y = 0, index = 0; y < npts; y++)
     {
         for (int t = 0; t < npts * (npts + 1) / 2; t++, index++)
         {
             if (isVertex(t, y, npts))
             {
                 vertex.push_back(index);
             }
             else if (isEdge(t, y, npts))
             {
                 if (isEdge_01(t, y, npts))
                 {
                     iEdge_01.push_back(index);
                 }
                 else if (isEdge_12(t, y, npts))
                 {
                     iEdge_12.push_back(index);
                 }
                 else if (isEdge_23(t, y, npts))
                 {
                     iEdge_23.push_back(index);
                 }
                 else if (isEdge_30(t, y, npts))
                 {
                     iEdge_30.push_back(index);
                 }
                 else if (isEdge_04(t, y, npts))
                 {
                     iEdge_04.push_back(index);
                 }
                 else if (isEdge_14(t, y, npts))
                 {
                     iEdge_14.push_back(index);
                 }
                 else if (isEdge_25(t, y, npts))
                 {
                     iEdge_25.push_back(index);
                 }
                 else if (isEdge_35(t, y, npts))
                 {
                     iEdge_35.push_back(index);
                 }
                 else if (isEdge_45(t, y, npts))
                 {
                     iEdge_45.push_back(index);
                 }
             }
             else if (isFace(t, y, npts))
             {
                 if (isFace_0123(t, y, npts))
                 {
                     iFace_0123.push_back(index);
                 }
                 else if (isFace_014(t, y, npts))
                 {
                     iFace_014.push_back(index);
                 }
                 else if (isFace_1254(t, y, npts))
                 {
                     iFace_1254.push_back(index);
                 }
                 else if (isFace_325(t, y, npts))
                 {
                     iFace_325.push_back(index);
                 }
                 else if (isFace_0354(t, y, npts))
                 {
                     iFace_0354.push_back(index);
                 }
             }
             else
             {
                 interiorVolumePoints.push_back(index);
             }
         }
     }
 
     // sort vertices
     swap(vertex[2], vertex[4]);
     // sort edges
     reverse(iEdge_23.begin(), iEdge_23.end());
     reverse(iEdge_30.begin(), iEdge_30.end());
     reverse(iEdge_04.begin(), iEdge_04.end());
     reverse(iEdge_35.begin(), iEdge_35.end());
 
     // faces
     for (int i = 0; i < npts - 2; i++)
     {
         for (int j = i + 1; j < npts - 2; j++)
         {
             swap(iFace_1254[i * (npts - 2) + j],
                  iFace_1254[j * (npts - 2) + i]);
         }
     }
     for (int i = 0; i < npts - 2; i++)
     {
         reverse(iFace_0354.begin() + i * (npts - 2),
                 iFace_0354.begin() + i * (npts - 2) + npts - 2);
     }
     for (int i = 0; i < npts - 2; i++)
     {
         for (int j = i + 1; j < npts - 2; j++)
         {
             swap(iFace_0354[i * (npts - 2) + j],
                  iFace_0354[j * (npts - 2) + i]);
         }
     }
 
     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]];
     }
 }

Member Data Documentation

boost::shared_ptr<NodalUtilPrism> Nektar::LibUtilities::NodalPrismElec::m_util

private

Definition at line 93 of file NodalPrismElec.h.

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

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation