Nektar::LibUtilities::NodalTetElec Class Reference

#include <NodalTetElec.h>

Inheritance diagram for Nektar::LibUtilities::NodalTetElec:

Public Member Functions
	~NodalTetElec () override
	NodalTetElec (const PointsKey &key)
Public Member Functions inherited from Nektar::LibUtilities::Points< NekDouble >
virtual	~Points ()
void	Initialize (void)
size_t	GetPointsDim () const
size_t	GetNumPoints () const
size_t	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
const MatrixSharedPtrType	GetI (const PointsKey &key)
const MatrixSharedPtrType	GetI (const Array< OneD, const DataType > &x)
const MatrixSharedPtrType	GetI (size_t uint, const Array< OneD, const DataType > &x)
const MatrixSharedPtrType	GetI (const Array< OneD, const DataType > &x, const Array< OneD, const DataType > &y)
const MatrixSharedPtrType	GetI (const Array< OneD, const DataType > &x, const Array< OneD, const DataType > &y, const Array< OneD, const DataType > &z)
const MatrixSharedPtrType	GetGalerkinProjection (const PointsKey &pkey)

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

Protected Member Functions
const MatrixSharedPtrType	v_GetI (const PointsKey &pkey) override
const MatrixSharedPtrType	v_GetI (const Array< OneD, const NekDouble > &x, const Array< OneD, const NekDouble > &y, const Array< OneD, const NekDouble > &z) override
Protected Member Functions inherited from Nektar::LibUtilities::Points< NekDouble >
virtual void	v_Initialize (void)
virtual void	v_CalculatePoints ()
virtual void	v_CalculateWeights ()

Private Member Functions
	NodalTetElec ()=delete
	NodalTetElec (const NodalTetElec &points)=delete
void	NodalPointReorder3d ()
void	v_CalculatePoints () final
void	v_CalculateWeights () final
void	v_CalculateDerivMatrix () final
void	CalculateInterpMatrix (const Array< OneD, const NekDouble > &xia, const Array< OneD, const NekDouble > &yia, const Array< OneD, const NekDouble > &zia, Array< OneD, NekDouble > &interp)

Private Attributes
std::shared_ptr< NodalUtilTetrahedron >	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 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 45 of file NodalTetElec.h.

Constructor & Destructor Documentation

~NodalTetElec()

Nektar::LibUtilities::NodalTetElec::~NodalTetElec ( )

inlineoverride

Definition at line 48 of file NodalTetElec.h.

    {
    }

NodalTetElec() [1/3]

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

inline

Definition at line 55 of file NodalTetElec.h.

                                       : PointsBaseType(key)
    {
    }

NodalTetElec() [2/3]

Nektar::LibUtilities::NodalTetElec::NodalTetElec ( )

privatedelete

NodalTetElec() [3/3]

Nektar::LibUtilities::NodalTetElec::NodalTetElec ( const NodalTetElec &  points )

privatedelete

Member Function Documentation

CalculateInterpMatrix()

void Nektar::LibUtilities::NodalTetElec::CalculateInterpMatrix ( const Array< OneD, const NekDouble > &  xia, const Array< OneD, const NekDouble > &  yia, const Array< OneD, const NekDouble > &  zia, Array< OneD, NekDouble > &  interp  )

private

Definition at line 205 of file NodalTetElec.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 v_GetI().

Create()

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

static

Definition at line 232 of file NodalTetElec.cpp.

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

NodalPointReorder3d()

void Nektar::LibUtilities::NodalTetElec::NodalPointReorder3d ( )

private

Definition at line 240 of file NodalTetElec.cpp.

{
    size_t cnt;
    size_t istart, iend;
 
    const size_t nVerts              = 4;
    const size_t nEdgeInteriorPoints = GetNumPoints() - 2;
    const size_t nFaceInteriorPoints =
        (GetNumPoints() - 3) * (GetNumPoints() - 2) / 2;
    // const size_t nBoundaryPoints = 4 + 6*nEdgeInteriorPoints +
    // 4*nFaceInteriorPoints;
    const size_t nAllPoints =
        GetNumPoints() * (GetNumPoints() + 1) * (GetNumPoints() + 2) / 6;
    if (nEdgeInteriorPoints == 0)
    {
        return;
    }
 
    // group all edge 1 points
    istart = nVerts;
    for (size_t i = cnt = istart; i < nAllPoints; i++)
    {
        if (fabs(m_points[1][i] + 1.0) < NekConstants::kNekZeroTol &&
            fabs(m_points[2][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]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort edge 1 (counterclockwise numbering)
    iend = istart + nEdgeInteriorPoints;
    for (size_t i = istart; i < iend; i++)
    {
        for (size_t 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]);
                std::swap(m_points[2][j], m_points[2][j - 1]);
            }
        }
    }
 
    // group the points of edge 2 together;
    istart = iend;
    for (size_t i = cnt = istart; i < nAllPoints; i++)
    {
        if (fabs(m_points[1][i] + m_points[0][i]) < NekConstants::kNekZeroTol &&
            fabs(m_points[2][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]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort edge 2 (counterclockwise numbering)
    iend = istart + nEdgeInteriorPoints;
    for (size_t i = istart; i < iend; i++)
    {
        for (size_t 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]);
                std::swap(m_points[2][j], m_points[2][j - 1]);
            }
        }
    }
 
    // group the points of edge 3 together;
    istart = iend;
    for (size_t i = cnt = istart; i < nAllPoints; i++)
    {
        if (fabs(m_points[0][i] + 1.0) < NekConstants::kNekZeroTol &&
            fabs(m_points[2][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]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort edge 3 (counterclockwise numbering)
    iend = istart + nEdgeInteriorPoints;
    for (size_t i = istart; i < iend; i++)
    {
        for (size_t 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]);
                std::swap(m_points[2][j], m_points[2][j - 1]);
            }
        }
    }
 
    // group the points of edge 4 together;
    istart = iend;
    for (size_t i = cnt = istart; i < nAllPoints; i++)
    {
        if (fabs(m_points[0][i] + 1.0) < NekConstants::kNekZeroTol &&
            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]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort edge 3 (counterclockwise numbering)
    iend = istart + nEdgeInteriorPoints;
    for (size_t i = istart; i < iend; i++)
    {
        for (size_t j = istart + 1; j < iend; j++)
        {
            if (m_points[2][j] < m_points[2][j - 1])
            {
                std::swap(m_points[0][j], m_points[0][j - 1]);
                std::swap(m_points[1][j], m_points[1][j - 1]);
                std::swap(m_points[2][j], m_points[2][j - 1]);
            }
        }
    }
 
    // group the points of edge 5 together;
    istart = iend;
    for (size_t i = cnt = istart; i < nAllPoints; i++)
    {
        if (fabs(m_points[0][i] + m_points[2][i]) < NekConstants::kNekZeroTol &&
            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]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort edge 5 (counterclockwise numbering)
    iend = istart + nEdgeInteriorPoints;
    for (size_t i = istart; i < iend; i++)
    {
        for (size_t j = istart + 1; j < iend; j++)
        {
            if (m_points[2][j] < m_points[2][j - 1])
            {
                std::swap(m_points[0][j], m_points[0][j - 1]);
                std::swap(m_points[1][j], m_points[1][j - 1]);
                std::swap(m_points[2][j], m_points[2][j - 1]);
            }
        }
    }
 
    // group the points of edge 6 together;
    istart = iend;
    for (size_t i = cnt = istart; i < nAllPoints; i++)
    {
        if (fabs(m_points[1][i] + m_points[2][i]) < NekConstants::kNekZeroTol &&
            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]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort edge 6 (counterclockwise numbering)
    iend = istart + nEdgeInteriorPoints;
    for (size_t i = istart; i < iend; i++)
    {
        for (size_t j = istart + 1; j < iend; j++)
        {
            if (m_points[2][j] < m_points[2][j - 1])
            {
                std::swap(m_points[0][j], m_points[0][j - 1]);
                std::swap(m_points[1][j], m_points[1][j - 1]);
                std::swap(m_points[2][j], m_points[2][j - 1]);
            }
        }
    }
 
    if (GetNumPoints() < 4)
    {
        // no face points
        return;
    }
 
    // group the points of face 1 together;
    istart = iend;
    for (size_t i = cnt = istart; i < nAllPoints; i++)
    {
        if (fabs(m_points[2][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]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort face1 (tensor numbering)
    iend        = istart + nFaceInteriorPoints;
    bool repeat = true;
    while (repeat)
    {
        repeat = false;
        for (size_t i = istart; i < iend - 1; i++)
        {
            if (m_points[1][i] > m_points[1][i + 1])
            {
                std::swap(m_points[0][i + 1], m_points[0][i]);
                std::swap(m_points[1][i + 1], m_points[1][i]);
                std::swap(m_points[2][i + 1], m_points[2][i]);
                repeat = true;
            }
        }
    }
    size_t offset = 0;
    size_t npl    = GetNumPoints() - 3;
    while (npl > 1)
    {
        repeat = true;
        while (repeat)
        {
            repeat = false;
            for (size_t i = offset + istart; i < offset + istart + npl - 1; i++)
            {
                if (m_points[0][i] > m_points[0][i + 1])
                {
                    std::swap(m_points[0][i + 1], m_points[0][i]);
                    std::swap(m_points[1][i + 1], m_points[1][i]);
                    std::swap(m_points[2][i + 1], m_points[2][i]);
                    repeat = true;
                }
            }
        }
        offset += npl;
        npl--;
    }
 
    // group the points of face 2 together;
    istart = iend;
    for (size_t i = cnt = istart; i < nAllPoints; 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]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort face2 (tensor numbering)
    iend   = istart + nFaceInteriorPoints;
    repeat = true;
    while (repeat)
    {
        repeat = false;
        for (size_t i = istart; i < iend - 1; i++)
        {
            if (m_points[2][i] > m_points[2][i + 1])
            {
                std::swap(m_points[0][i + 1], m_points[0][i]);
                std::swap(m_points[1][i + 1], m_points[1][i]);
                std::swap(m_points[2][i + 1], m_points[2][i]);
                repeat = true;
            }
        }
    }
    offset = 0;
    npl    = GetNumPoints() - 3;
    while (npl > 1)
    {
        repeat = true;
        while (repeat)
        {
            repeat = false;
            for (size_t i = offset + istart; i < offset + istart + npl - 1; i++)
            {
                if (m_points[0][i] > m_points[0][i + 1])
                {
                    std::swap(m_points[0][i + 1], m_points[0][i]);
                    std::swap(m_points[1][i + 1], m_points[1][i]);
                    std::swap(m_points[2][i + 1], m_points[2][i]);
                    repeat = true;
                }
            }
        }
        offset += npl;
        npl--;
    }
 
    // group the points of face 3 together;
    istart = iend;
    for (size_t i = cnt = istart; i < nAllPoints; i++)
    {
        if (fabs(m_points[1][i] + m_points[0][i] + m_points[2][i] + 1.0) <
            1E-9) // nek zero tol too small
        {
            std::swap(m_points[0][cnt], m_points[0][i]);
            std::swap(m_points[1][cnt], m_points[1][i]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort face3 (tensor numbering)
    iend   = istart + nFaceInteriorPoints;
    repeat = true;
    while (repeat)
    {
        repeat = false;
        for (size_t i = istart; i < iend - 1; i++)
        {
            if (m_points[2][i] > m_points[2][i + 1])
            {
                std::swap(m_points[0][i + 1], m_points[0][i]);
                std::swap(m_points[1][i + 1], m_points[1][i]);
                std::swap(m_points[2][i + 1], m_points[2][i]);
                repeat = true;
            }
        }
    }
    offset = 0;
    npl    = GetNumPoints() - 3;
    while (npl > 1)
    {
        repeat = true;
        while (repeat)
        {
            repeat = false;
            for (size_t i = offset + istart; i < offset + istart + npl - 1; i++)
            {
                if (m_points[1][i] > m_points[1][i + 1])
                {
                    std::swap(m_points[0][i + 1], m_points[0][i]);
                    std::swap(m_points[1][i + 1], m_points[1][i]);
                    std::swap(m_points[2][i + 1], m_points[2][i]);
                    repeat = true;
                }
            }
        }
        offset += npl;
        npl--;
    }
 
    // group the points of face 4 together;
    istart = iend;
    for (size_t i = cnt = istart; i < nAllPoints; 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]);
            std::swap(m_points[2][cnt], m_points[2][i]);
            cnt++;
        }
    }
 
    // bubble sort face4 (tensor numbering)
    iend   = istart + nFaceInteriorPoints;
    repeat = true;
    while (repeat)
    {
        repeat = false;
        for (size_t i = istart; i < iend - 1; i++)
        {
            if (m_points[2][i] > m_points[2][i + 1])
            {
                std::swap(m_points[0][i + 1], m_points[0][i]);
                std::swap(m_points[1][i + 1], m_points[1][i]);
                std::swap(m_points[2][i + 1], m_points[2][i]);
                repeat = true;
            }
        }
    }
    offset = 0;
    npl    = GetNumPoints() - 3;
    while (npl > 1)
    {
        repeat = true;
        while (repeat)
        {
            repeat = false;
            for (size_t i = offset + istart; i < offset + istart + npl - 1; i++)
            {
                if (m_points[1][i] > m_points[1][i + 1])
                {
                    std::swap(m_points[0][i + 1], m_points[0][i]);
                    std::swap(m_points[1][i + 1], m_points[1][i]);
                    std::swap(m_points[2][i + 1], m_points[2][i]);
                    repeat = true;
                }
            }
        }
        offset += npl;
        npl--;
    }
}

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

Referenced by v_CalculatePoints().

v_CalculateDerivMatrix()

void Nektar::LibUtilities::NodalTetElec::v_CalculateDerivMatrix ( )

finalprivate

Definition at line 222 of file NodalTetElec.cpp.

{
    // Allocate the derivative matrix.
    PointsBaseType::v_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 >::m_derivmatrix, and m_util.

v_CalculatePoints()

void Nektar::LibUtilities::NodalTetElec::v_CalculatePoints ( )

finalprivatevirtual

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

Definition at line 46 of file NodalTetElec.cpp.

{
    // Allocate the storage for points
    Points<NekDouble>::v_CalculatePoints();
 
    size_t index = 0, isum = 0;
    const size_t offset = 5; // offset to match Datafile
    NekDouble b, c, d;
    size_t numPoints = GetNumPoints();
 
    // initialize values
    for (size_t i = 0; i < numPoints - 2; ++i)
    {
        index += NodalTetElecNPTS[i];
    }
 
    for (size_t i = 0; i < NodalTetElecNPTS[numPoints - 2]; ++i, ++index)
    {
        // 1 Point Symmetry: aaaa
        if (int(NodalTetElecData[index][0]))
        {
            b = NodalTetElecData[index][6];
            c = NodalTetElecData[index][7];
            d = NodalTetElecData[index][8];
 
            m_points[0][isum] = 2.0 * b - 1.0;
            m_points[1][isum] = 2.0 * c - 1.0;
            m_points[2][isum] = 2.0 * d - 1.0;
            isum++;
            continue;
        } // end symmetry 1
 
        // 4 Point symmetry: aaab or abbb
        if (int(NodalTetElecData[index][1]))
        {
            for (size_t j = 0; j < 4; ++j)
            {
                b = NodalTetElecData[index][offset + perm4_3d[j][1]];
                c = NodalTetElecData[index][offset + perm4_3d[j][2]];
                d = NodalTetElecData[index][offset + perm4_3d[j][3]];
 
                m_points[0][isum] = 2.0 * b - 1.0;
                m_points[1][isum] = 2.0 * c - 1.0;
                m_points[2][isum] = 2.0 * d - 1.0;
                isum++;
            } // end j
            continue;
        } // end symmetry 4
 
        // 6 Point symmetry: aabb
        if (int(NodalTetElecData[index][2]))
        {
            for (size_t j = 0; j < 6; ++j)
            {
                b = NodalTetElecData[index][offset + perm6_3d[j][1]];
                c = NodalTetElecData[index][offset + perm6_3d[j][2]];
                d = NodalTetElecData[index][offset + perm6_3d[j][3]];
 
                m_points[0][isum] = 2.0 * b - 1.0;
                m_points[1][isum] = 2.0 * c - 1.0;
                m_points[2][isum] = 2.0 * d - 1.0;
                isum++;
            } // end j
            continue;
        } // end symmetry6
 
        // 12 Point symmetry: case aabc
        if (int(NodalTetElecData[index][3]) == 1)
        {
            for (size_t j = 0; j < 12; ++j)
            {
                b = NodalTetElecData[index][offset + perm12A_3d[j][1]];
                c = NodalTetElecData[index][offset + perm12A_3d[j][2]];
                d = NodalTetElecData[index][offset + perm12A_3d[j][3]];
 
                m_points[0][isum] = 2.0 * b - 1.0;
                m_points[1][isum] = 2.0 * c - 1.0;
                m_points[2][isum] = 2.0 * d - 1.0;
                isum++;
            } // end j
            continue;
        } // end symmetry 12 aabc
 
        // 12 Point symmetry: case abcc
        if (int(NodalTetElecData[index][3]) == 2)
        {
            for (size_t j = 0; j < 12; ++j)
            {
                b = NodalTetElecData[index][offset + perm12B_3d[j][1]];
                c = NodalTetElecData[index][offset + perm12B_3d[j][2]];
                d = NodalTetElecData[index][offset + perm12B_3d[j][3]];
 
                m_points[0][isum] = 2.0 * b - 1.0;
                m_points[1][isum] = 2.0 * c - 1.0;
                m_points[2][isum] = 2.0 * d - 1.0;
                isum++;
            } // end j
            continue;
        } // end symmetry 12 abcc
 
        // 12 Point symmetry: case abbc
        if (int(NodalTetElecData[index][3]) == 3)
        {
            for (size_t j = 0; j < 12; ++j)
            {
                b = NodalTetElecData[index][offset + perm12C_3d[j][1]];
                c = NodalTetElecData[index][offset + perm12C_3d[j][2]];
                d = NodalTetElecData[index][offset + perm12C_3d[j][3]];
 
                m_points[0][isum] = 2.0 * b - 1.0;
                m_points[1][isum] = 2.0 * c - 1.0;
                m_points[2][isum] = 2.0 * d - 1.0;
                isum++;
            } // end j
            continue;
        } // end symmetry 12 abbc
 
        // 24 Point symmetry: case abcd
        if (int(NodalTetElecData[index][4]))
        {
            for (size_t j = 0; j < 24; ++j)
            {
                b = NodalTetElecData[index][offset + perm24_3d[j][1]];
                c = NodalTetElecData[index][offset + perm24_3d[j][2]];
                d = NodalTetElecData[index][offset + perm24_3d[j][3]];
 
                m_points[0][isum] = 2.0 * b - 1.0;
                m_points[1][isum] = 2.0 * c - 1.0;
                m_points[2][isum] = 2.0 * d - 1.0;
                isum++;
            } // end j
            continue;
        } // end symmetry24abcd
 
    } // end npts
 
    NodalPointReorder3d();
 
    ASSERTL1((static_cast<size_t>(isum) == m_pointsKey.GetTotNumPoints()),
             "sum not equal to npts");
 
    m_util = MemoryManager<NodalUtilTetrahedron>::AllocateSharedPtr(
        numPoints - 1, m_points[0], m_points[1], m_points[2]);
}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, Nektar::UnitTests::d(), Nektar::LibUtilities::Points< NekDouble >::GetNumPoints(), Nektar::LibUtilities::PointsKey::GetTotNumPoints(), Nektar::LibUtilities::Points< NekDouble >::m_points, Nektar::LibUtilities::Points< NekDouble >::m_pointsKey, m_util, NodalPointReorder3d(), Nektar::LibUtilities::NodalTetElecData, Nektar::LibUtilities::NodalTetElecNPTS, Nektar::LibUtilities::perm12A_3d, Nektar::LibUtilities::perm12B_3d, Nektar::LibUtilities::perm12C_3d, Nektar::LibUtilities::perm24_3d, Nektar::LibUtilities::perm4_3d, Nektar::LibUtilities::perm6_3d, and Nektar::LibUtilities::Points< DataT >::v_CalculatePoints().

v_CalculateWeights()

void Nektar::LibUtilities::NodalTetElec::v_CalculateWeights ( )

finalprivatevirtual

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

Definition at line 191 of file NodalTetElec.cpp.

{
    // Allocate the storage for points
    PointsBaseType::v_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 m_util, Nektar::LibUtilities::Points< NekDouble >::m_weights, Nektar::LibUtilities::Points< NekDouble >::v_CalculateWeights(), and Nektar::UnitTests::w().

v_GetI() [1/2]

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

inlineoverrideprotected

Definition at line 70 of file NodalTetElec.h.

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

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

v_GetI() [2/2]

const MatrixSharedPtrType Nektar::LibUtilities::NodalTetElec::v_GetI ( const PointsKey &  pkey )

inlineoverrideprotected

Definition at line 60 of file NodalTetElec.h.

    {
        ASSERTL0(pkey.GetPointsDim() == 3,
                 "NodalTetElec 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::Points< NekDouble >::GetI(), Nektar::LibUtilities::PointsKey::GetPointsDim(), Nektar::LibUtilities::PointsManager(), and Nektar::UnitTests::z().

Member Data Documentation

initPointsManager

bool Nektar::LibUtilities::NodalTetElec::initPointsManager

staticprivate

Initial value:

= {PointsManager().RegisterCreator(
    PointsKey(0, eNodalTetElec), NodalTetElec::Create)}

Definition at line 87 of file NodalTetElec.h.

m_util

std::shared_ptr<NodalUtilTetrahedron> Nektar::LibUtilities::NodalTetElec::m_util

private

Definition at line 89 of file NodalTetElec.h.

Referenced by CalculateInterpMatrix(), v_CalculateDerivMatrix(), v_CalculatePoints(), and v_CalculateWeights().