Specialisation of the NodalUtil class to support nodal tetrahedral elements. More...

#include <NodalUtil.h>

Inheritance diagram for Nektar::LibUtilities::NodalUtilTetrahedron:

Collaboration diagram for Nektar::LibUtilities::NodalUtilTetrahedron:

Public Member Functions
	NodalUtilTetrahedron (int degree, Array< OneD, NekDouble > r, Array< OneD, NekDouble > s, Array< OneD, NekDouble > t)
	Construct the nodal utility class for a tetrahedron. More...

virtual	~NodalUtilTetrahedron ()

Public Member Functions inherited from Nektar::LibUtilities::NodalUtil
NekVector< NekDouble >	GetWeights ()
	Obtain the integration weights for the given nodal distribution. More...

SharedMatrix	GetVandermonde ()
	Return the Vandermonde matrix for the nodal distribution. More...

SharedMatrix	GetVandermondeForDeriv (int dir)
	Return the Vandermonde matrix of the derivative of the basis functions for the nodal distribution. More...

SharedMatrix	GetDerivMatrix (int dir)
	Return the derivative matrix for the nodal distribution. More...

SharedMatrix	GetInterpolationMatrix (Array< OneD, Array< OneD, NekDouble > > &xi)
	Construct the interpolation matrix used to evaluate the basis at the points `xi` inside the element. More...

Protected Member Functions
virtual NekVector< NekDouble >	v_OrthoBasis (const int mode)
	Return the value of the modal functions for the tetrahedral element at the nodal points m_xi for a given mode. More...

virtual NekVector< NekDouble >	v_OrthoBasisDeriv (const int dir, const int mode)
	Return the value of the derivative of the modal functions for the tetrahedral element at the nodal points m_xi for a given mode. More...

virtual boost::shared_ptr < NodalUtil >	v_CreateUtil (Array< OneD, Array< OneD, NekDouble > > &xi)
	Construct a NodalUtil object of the appropriate element type for a given set of points. More...

virtual NekDouble	v_ModeZeroIntegral ()
	Return the value of the integral of the zero-th mode for this element. More...

virtual int	v_NumModes ()
	Calculate the number of degrees of freedom for this element. More...

Protected Member Functions inherited from Nektar::LibUtilities::NodalUtil
	NodalUtil (int degree, int dim)
	Set up the NodalUtil object. More...

Protected Attributes
std::vector< Mode >	m_ordering
	Mapping from the indexing of the basis to a continuous ordering. More...

Array< OneD, Array< OneD, NekDouble > >	m_eta
	Collapsed coordinates $(\eta_1, \eta_2, \eta_3)$ of the nodal points. More...

Protected Attributes inherited from Nektar::LibUtilities::NodalUtil
int	m_dim
	Dimension of the nodal element. More...

int	m_degree
	Degree of the nodal element. More...

int	m_numPoints
	Total number of nodal points. More...

Array< OneD, Array< OneD, NekDouble > >	m_xi
	Coordinates of the nodal points defining the basis. More...

Private Types
typedef boost::tuple< int, int, int >	Mode

Detailed Description

Specialisation of the NodalUtil class to support nodal tetrahedral elements.

Definition at line 215 of file NodalUtil.h.

Member Typedef Documentation

typedef boost::tuple<int, int, int> Nektar::LibUtilities::NodalUtilTetrahedron::Mode

private

Definition at line 217 of file NodalUtil.h.

Constructor & Destructor Documentation

Nektar::LibUtilities::NodalUtilTetrahedron::NodalUtilTetrahedron	(	int	degree,
		Array< OneD, NekDouble >	r,
		Array< OneD, NekDouble >	s,
		Array< OneD, NekDouble >	t
	)

Construct the nodal utility class for a tetrahedron.

The constructor of this class sets up two member variables used in the evaluation of the orthogonal basis:

NodalUtilTetrahedron::m_eta is used to construct the collapsed coordinate locations of the nodal points $(\eta_1, \eta_2, \eta_3)$ inside the cube on which the orthogonal basis functions are defined.
NodalUtilTetrahedron::m_ordering constructs a mapping from the index set $I = \{ (i,j,k)\ |\ 0\leq i,j,k \leq P, i+j \leq P, i+j+k \leq P \}$ to an ordering $0 \leq m(ijk) \leq (P+1)(P+2)(P+3)/6$ that defines the monomials $\xi_1^i \xi_2^j \xi_3^k$ that span the tetrahedral space. This is then used to calculate which triple (represented as a boost tuple) corresponding to a column of the Vandermonde matrix when calculating the orthogonal polynomials.

Parameters

degree	Polynomial order of this nodal tetrahedron
r	$\xi_1$ -coordinates of nodal points in the standard element.
s	$\xi_2$ -coordinates of nodal points in the standard element.
t	$\xi_3$ -coordinates of nodal points in the standard element.

Definition at line 420 of file NodalUtil.cpp.

References Nektar::NekConstants::kNekZeroTol, Nektar::LibUtilities::NodalUtil::m_degree, m_eta, Nektar::LibUtilities::NodalUtil::m_numPoints, m_ordering, and Nektar::LibUtilities::NodalUtil::m_xi.

     : NodalUtil(degree, 3), m_eta(3)
 {
     m_numPoints = r.num_elements();
     m_xi[0] = r;
     m_xi[1] = s;
     m_xi[2] = t;
 
     for (int i = 0; i <= m_degree; ++i)
     {
         for (int j = 0; j <= m_degree - i; ++j)
         {
             for (int k = 0; k <= m_degree - i - j; ++k)
             {
                 m_ordering.push_back(Mode(i, j, k));
             }
         }
     }
 
     // Calculate collapsed coordinates from r/s values
     m_eta[0] = Array<OneD, NekDouble>(m_numPoints);
     m_eta[1] = Array<OneD, NekDouble>(m_numPoints);
     m_eta[2] = Array<OneD, NekDouble>(m_numPoints);
 
     for (int i = 0; i < m_numPoints; ++i)
     {
         if (fabs(m_xi[2][i] - 1.0) < NekConstants::kNekZeroTol)
         {
             // Very top point of the tetrahedron
             m_eta[0][i] = -1.0;
             m_eta[1][i] = -1.0;
             m_eta[2][i] = m_xi[2][i];
         }
         else
         {
             if (fabs(m_xi[1][i] - 1.0) <  NekConstants::kNekZeroTol)
             {
                 // Distant diagonal edge shared by all eta_x coordinate planes:
                 // the xi_y == -xi_z line
                 m_eta[0][i] = -1.0;
             }
             else if (fabs(m_xi[1][i] + m_xi[2][i]) < NekConstants::kNekZeroTol)
             {
                 m_eta[0][i] = -1.0;
             }
             else
             {
                 m_eta[0][i] = 2.0 * (1.0 + m_xi[0][i]) /
                     (-m_xi[1][i] - m_xi[2][i]) - 1.0;
             }
             m_eta[1][i] = 2.0 * (1.0 + m_xi[1][i]) / (1.0 - m_xi[2][i]) - 1.0;
             m_eta[2][i] = m_xi[2][i];
         }
     }
 }

virtual Nektar::LibUtilities::NodalUtilTetrahedron::~NodalUtilTetrahedron ( )

inlinevirtual

Definition at line 225 of file NodalUtil.h.

226 {

227 }

Member Function Documentation

virtual boost::shared_ptr<NodalUtil> Nektar::LibUtilities::NodalUtilTetrahedron::v_CreateUtil ( Array< OneD, Array< OneD, NekDouble > > & xi )

inlineprotectedvirtual

Construct a NodalUtil object of the appropriate element type for a given set of points.

This function is used inside NodalUtil::GetInterpolationMatrix so that the (potentially non-square) Vandermonde matrix can be constructed to create the interpolation matrix at an arbitrary set of points in the domain.

Parameters

xi	Distribution of nodal points to create utility with.

Implements Nektar::LibUtilities::NodalUtil.

Definition at line 242 of file NodalUtil.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::LibUtilities::NodalUtil::m_degree.

     {
         return MemoryManager<NodalUtilTetrahedron>::AllocateSharedPtr(
             m_degree, xi[0], xi[1], xi[2]);
     }

virtual NekDouble Nektar::LibUtilities::NodalUtilTetrahedron::v_ModeZeroIntegral ( )

inlineprotectedvirtual

Return the value of the integral of the zero-th mode for this element.

Note that for the orthogonal basis under consideration, all modes integrate to zero asides from the zero-th mode. This function is used in NodalUtil::GetWeights to determine integration weights.

Implements Nektar::LibUtilities::NodalUtil.

Definition at line 249 of file NodalUtil.h.

     {
         return 8.0 * sqrt(2.0) / 3.0;
     }

virtual int Nektar::LibUtilities::NodalUtilTetrahedron::v_NumModes ( )

inlineprotectedvirtual

Calculate the number of degrees of freedom for this element.

Implements Nektar::LibUtilities::NodalUtil.

Definition at line 254 of file NodalUtil.h.

References Nektar::LibUtilities::NodalUtil::m_degree.

     {
         return (m_degree + 1) * (m_degree + 2) * (m_degree + 3) / 6;
     }

NekVector< NekDouble > Nektar::LibUtilities::NodalUtilTetrahedron::v_OrthoBasis ( const int mode )

protectedvirtual

Return the value of the modal functions for the tetrahedral element at the nodal points m_xi for a given mode.

In a tetrahedron, we use the orthogonal basis

$\psi_{m(ijk)} = \sqrt{8} P^{(0,0)}_i(\xi_1) P_j^{(2i+1,0)}(\xi_2) P_k^{(2i+2j+2,0)}(\xi_3) (1-\xi_2)^i (1-\xi_3)^{i+j}$

where $ m(ijk) $ is the mapping defined in m_ordering and $J_n^{(\alpha,\beta)}(z)$ denotes the standard Jacobi polynomial.

Parameters

mode	The mode of the orthogonal basis to evaluate.

Returns: Vector containing orthogonal basis evaluated at the points m_xi.

Implements Nektar::LibUtilities::NodalUtil.

Definition at line 495 of file NodalUtil.cpp.

References Polylib::jacobfd(), m_eta, Nektar::LibUtilities::NodalUtil::m_numPoints, m_ordering, and CG_Iterations::modes.

 {
     std::vector<NekDouble> jacA(m_numPoints), jacB(m_numPoints);
     std::vector<NekDouble> jacC(m_numPoints);
     Mode modes = m_ordering[mode];
 
     const int I = modes.get<0>(), J = modes.get<1>(), K = modes.get<2>();
 
     // Calculate Jacobi polynomials
     Polylib::jacobfd(
         m_numPoints, &m_eta[0][0], &jacA[0], NULL, I, 0.0, 0.0);
     Polylib::jacobfd(
         m_numPoints, &m_eta[1][0], &jacB[0], NULL, J, 2.0 * I + 1.0, 0.0);
     Polylib::jacobfd(
         m_numPoints, &m_eta[2][0], &jacC[0], NULL, K, 2.0 * (I+J) + 2.0, 0.0);
 
     NekVector<NekDouble> ret(m_numPoints);
     NekDouble sqrt8 = sqrt(8.0);
 
     for (int i = 0; i < m_numPoints; ++i)
     {
         ret[i] = sqrt8 * jacA[i] * jacB[i] * jacC[i] *
             pow(1.0 - m_eta[1][i], I) * pow(1.0 - m_eta[2][i], I + J);
     }
 
     return ret;
 }

NekVector< NekDouble > Nektar::LibUtilities::NodalUtilTetrahedron::v_OrthoBasisDeriv	(	const int	dir,
		const int	mode
	)

protectedvirtual

Return the value of the derivative of the modal functions for the tetrahedral element at the nodal points m_xi for a given mode.

Note that this routine must use the chain rule combined with the collapsed coordinate derivatives as described in Sherwin & Karniadakis (2nd edition), pg 152.

Parameters

dir	Coordinate direction in which to evaluate the derivative.
mode	The mode of the orthogonal basis to evaluate.

Returns: Vector containing the derivative of the orthogonal basis evaluated at the points m_xi.

Implements Nektar::LibUtilities::NodalUtil.

Definition at line 537 of file NodalUtil.cpp.

References Polylib::jacobd(), Polylib::jacobfd(), m_eta, Nektar::LibUtilities::NodalUtil::m_numPoints, m_ordering, and CG_Iterations::modes.

 {
     std::vector<NekDouble> jacA(m_numPoints), jacB(m_numPoints);
     std::vector<NekDouble> jacC(m_numPoints);
     std::vector<NekDouble> jacDerivA(m_numPoints), jacDerivB(m_numPoints);
     std::vector<NekDouble> jacDerivC(m_numPoints);
     Mode modes = m_ordering[mode];
 
     const int I = modes.get<0>(), J = modes.get<1>(), K = modes.get<2>();
 
     // Calculate Jacobi polynomials
     Polylib::jacobfd(
         m_numPoints, &m_eta[0][0], &jacA[0], NULL, I, 0.0, 0.0);
     Polylib::jacobfd(
         m_numPoints, &m_eta[1][0], &jacB[0], NULL, J, 2.0 * I + 1.0, 0.0);
     Polylib::jacobfd(
         m_numPoints, &m_eta[2][0], &jacC[0], NULL, K, 2.0 * (I+J) + 2.0, 0.0);
     Polylib::jacobd(
         m_numPoints, &m_eta[0][0], &jacDerivA[0], I, 0.0, 0.0);
     Polylib::jacobd(
         m_numPoints, &m_eta[1][0], &jacDerivB[0], J, 2.0 * I + 1.0, 0.0);
     Polylib::jacobd(
         m_numPoints, &m_eta[2][0], &jacDerivC[0], K, 2.0 * (I+J) + 2.0, 0.0);
 
     NekVector<NekDouble> ret(m_numPoints);
     NekDouble sqrt8 = sqrt(8.0);
 
     // Always compute x-derivative since this term appears in the latter two
     // terms.
     for (int i = 0; i < m_numPoints; ++i)
     {
         ret[i] = 4.0 * sqrt8 * jacDerivA[i] * jacB[i] * jacC[i];
 
         if (I > 0)
         {
             ret[i] *= pow(1 - m_eta[1][i], I - 1);
         }
 
         if (I + J > 0)
         {
             ret[i] *= pow(1 - m_eta[2][i], I + J - 1);
         }
     }
 
     if (dir >= 1)
     {
         // Multiply by (1+a)/2
         NekVector<NekDouble> tmp(m_numPoints);
 
         for (int i = 0; i < m_numPoints; ++i)
         {
             ret[i] *= 0.5 * (m_eta[0][i] + 1.0);
 
             tmp[i] = 2.0 * sqrt8 * jacA[i] * jacC[i];
             if (I + J > 0)
             {
                 tmp[i] *= pow(1.0 - m_eta[2][i], I + J - 1);
             }
 
             NekDouble tmp2 = jacDerivB[i] * pow(1.0 - m_eta[1][i], I);
             if (I > 0)
             {
                 tmp2 -= I * jacB[i] * pow(1.0 - m_eta[1][i], I - 1);
             }
 
             tmp[i] *= tmp2;
         }
 
         if (dir == 1)
         {
             ret += tmp;
             return ret;
         }
 
         for (int i = 0; i < m_numPoints; ++i)
         {
             ret[i] += 0.5 * (1.0 + m_eta[1][i]) * tmp[i];
 
             NekDouble tmp2 = jacDerivC[i] * pow(1.0 - m_eta[2][i], I + J);
             if (I + J > 0)
             {
                 tmp2 -= jacC[i] * (I + J) * pow(1.0 - m_eta[2][i], I + J - 1);
             }
 
             ret[i] += sqrt8 * jacA[i] * jacB[i] * pow(1.0 - m_eta[1][i], I) *
                 tmp2;
         }
     }
 
     return ret;
 }

Member Data Documentation

Array<OneD, Array<OneD, NekDouble> > Nektar::LibUtilities::NodalUtilTetrahedron::m_eta

protected

Collapsed coordinates $(\eta_1, \eta_2, \eta_3)$ of the nodal points.

Definition at line 236 of file NodalUtil.h.

Referenced by NodalUtilTetrahedron(), v_OrthoBasis(), and v_OrthoBasisDeriv().

std::vector<Mode> Nektar::LibUtilities::NodalUtilTetrahedron::m_ordering

protected

Mapping from the $ (i,j,k) $ indexing of the basis to a continuous ordering.

Definition at line 232 of file NodalUtil.h.

Referenced by NodalUtilTetrahedron(), v_OrthoBasis(), and v_OrthoBasisDeriv().

Public Member Functions

Protected Member Functions

Protected Attributes

Private Types

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation