Nektar::LibUtilities::NodalUtilHex Class Reference

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

#include <NodalUtil.h>

Inheritance diagram for Nektar::LibUtilities::NodalUtilHex:

Public Member Functions
	NodalUtilHex (int degree, Array< OneD, NekDouble > r, Array< OneD, NekDouble > s, Array< OneD, NekDouble > t)
	Construct the nodal utility class for a hexahedron. More...
virtual	~NodalUtilHex ()
Public Member Functions inherited from Nektar::LibUtilities::NodalUtil
virtual	~NodalUtil ()=default
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) override
	Return the value of the modal functions for the hex element at the nodal points m_xi for a given mode. More...
virtual NekVector< NekDouble >	v_OrthoBasisDeriv (const int dir, const int mode) override
	Return the values of the derivative of the orthogonal basis at the nodal points for a given mode. More...
virtual std::shared_ptr< NodalUtil >	v_CreateUtil (Array< OneD, Array< OneD, NekDouble >> &xi) override
	Construct a NodalUtil object of the appropriate element type for a given set of points. More...
virtual NekDouble	v_ModeZeroIntegral () override
	Return the value of the integral of the zero-th mode for this element. More...
virtual int	v_NumModes () override
	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 \( (i,j,k) \) indexing of the basis to a continuous ordering. 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 std::tuple< int, int, int >	Mode

Detailed Description

Specialisation of the NodalUtil class to support nodal hex elements.

Definition at line 349 of file NodalUtil.h.

Member Typedef Documentation

Mode

typedef std::tuple<int, int, int> Nektar::LibUtilities::NodalUtilHex::Mode

private

Definition at line 351 of file NodalUtil.h.

Constructor & Destructor Documentation

NodalUtilHex()

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

Construct the nodal utility class for a hexahedron.

The constructor of this class sets up the m_ordering member variable used in the evaluation of the orthogonal basis.

Parameters

degree	Polynomial order of this nodal hexahedron.
r	\( \xi_1 \)-coordinates of nodal points in the standard element.
s	\( \xi_2 \)-coordinates of nodal points in the standard element.

Definition at line 937 of file NodalUtil.cpp.

    : NodalUtil(degree, 3)
{
    // Set up parent variables.
    m_numPoints = r.size();
    m_xi[0]     = r;
    m_xi[1]     = s;
    m_xi[2]     = t;
 
    // Construct a mapping (i,j,k) -> m from the tensor product space (i,j,k) to
    // a single ordering m.
    for (int k = 0; k <= m_degree; ++k)
    {
        for (int j = 0; j <= m_degree; ++j)
        {
            for (int i = 0; i <= m_degree; ++i)
            {
                m_ordering.push_back(Mode(i, j, k));
            }
        }
    }
}

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

~NodalUtilHex()

virtual Nektar::LibUtilities::NodalUtilHex::~NodalUtilHex ( )

inlinevirtual

Definition at line 358 of file NodalUtil.h.

    {
    }

Member Function Documentation

v_CreateUtil()

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

inlineoverrideprotectedvirtual

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 371 of file NodalUtil.h.

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

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

v_ModeZeroIntegral()

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

inlineoverrideprotectedvirtual

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 378 of file NodalUtil.h.

    {
        return 8.0;
    }

v_NumModes()

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

inlineoverrideprotectedvirtual

Calculate the number of degrees of freedom for this element.

Implements Nektar::LibUtilities::NodalUtil.

Definition at line 383 of file NodalUtil.h.

    {
        return (m_degree + 1) * (m_degree + 1) * (m_degree + 1);
    }

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

v_OrthoBasis()

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

overrideprotectedvirtual

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

In a quad, we use the orthogonal basis

\[ \psi_{m(ijk)} = P^{(0,0)}_i(\xi_1) P_j^{(0,0)}(\xi_2) P_k^{(0,0)}(\xi_3) \]

Parameters

mode	The mode of the orthogonal basis to evaluate.

Implements Nektar::LibUtilities::NodalUtil.

Definition at line 973 of file NodalUtil.cpp.

{
    std::vector<NekDouble> jacobi_i(m_numPoints), jacobi_j(m_numPoints);
    std::vector<NekDouble> jacobi_k(m_numPoints);
 
    int I, J, K;
    std::tie(I, J, K) = m_ordering[mode];
 
    // Calculate Jacobi polynomials
    Polylib::jacobfd(m_numPoints, &m_xi[0][0], &jacobi_i[0], NULL, I, 0.0, 0.0);
    Polylib::jacobfd(m_numPoints, &m_xi[1][0], &jacobi_j[0], NULL, J, 0.0, 0.0);
    Polylib::jacobfd(m_numPoints, &m_xi[2][0], &jacobi_k[0], NULL, K, 0.0, 0.0);
 
    NekVector<NekDouble> ret(m_numPoints);
 
    for (int i = 0; i < m_numPoints; ++i)
    {
        ret[i] = jacobi_i[i] * jacobi_j[i] * jacobi_k[i];
    }
 
    return ret;
}

References Polylib::jacobfd(), Nektar::LibUtilities::NodalUtil::m_numPoints, m_ordering, and Nektar::LibUtilities::NodalUtil::m_xi.

v_OrthoBasisDeriv()

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

overrideprotectedvirtual

Return the values of the derivative of the orthogonal basis at the nodal points for a given mode.

Parameters

dir	Coordinate direction of derivative.
mode	Mode number, which is between 0 and NodalUtil::v_NumModes() 1.

Implements Nektar::LibUtilities::NodalUtil.

Definition at line 996 of file NodalUtil.cpp.

{
    std::vector<NekDouble> jacobi_i(m_numPoints), jacobi_j(m_numPoints);
    std::vector<NekDouble> jacobi_k(m_numPoints);
    std::vector<NekDouble> jacobi_di(m_numPoints), jacobi_dj(m_numPoints);
    std::vector<NekDouble> jacobi_dk(m_numPoints);
 
    int I, J, K;
    std::tie(I, J, K) = m_ordering[mode];
 
    // Calculate Jacobi polynomials and their derivatives. Note that we use both
    // jacobfd and jacobd since jacobfd is only valid for derivatives in the
    // open interval (-1,1).
    Polylib::jacobfd(m_numPoints, &m_xi[0][0], &jacobi_i[0], NULL, I, 0.0, 0.0);
    Polylib::jacobfd(m_numPoints, &m_xi[1][0], &jacobi_j[0], NULL, J, 0.0, 0.0);
    Polylib::jacobfd(m_numPoints, &m_xi[2][0], &jacobi_k[0], NULL, K, 0.0, 0.0);
    Polylib::jacobd(m_numPoints, &m_xi[0][0], &jacobi_di[0], I, 0.0, 0.0);
    Polylib::jacobd(m_numPoints, &m_xi[1][0], &jacobi_dj[0], J, 0.0, 0.0);
    Polylib::jacobd(m_numPoints, &m_xi[2][0], &jacobi_dk[0], K, 0.0, 0.0);
 
    NekVector<NekDouble> ret(m_numPoints);
 
    if (dir == 0)
    {
        for (int i = 0; i < m_numPoints; ++i)
        {
            ret[i] = jacobi_di[i] * jacobi_j[i] * jacobi_k[i];
        }
    }
    else if (dir == 1)
    {
        for (int i = 0; i < m_numPoints; ++i)
        {
            ret[i] = jacobi_dj[i] * jacobi_i[i] * jacobi_k[i];
        }
    }
    else
    {
        for (int i = 0; i < m_numPoints; ++i)
        {
            ret[i] = jacobi_i[i] * jacobi_j[i] * jacobi_dk[i];
        }
    }
 
    return ret;
}

References Polylib::jacobd(), Polylib::jacobfd(), Nektar::LibUtilities::NodalUtil::m_numPoints, m_ordering, and Nektar::LibUtilities::NodalUtil::m_xi.

Member Data Documentation

m_ordering

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

protected

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

Definition at line 365 of file NodalUtil.h.

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