Nektar::SpatialDomains::GeomFactors Class Reference

Calculation and storage of geometric factors associated with the mapping from StdRegions reference elements to a given LocalRegions physical element in the mesh. More...

#include <GeomFactors.h>

Public Member Functions
	GeomFactors (const GeomType gtype, const int coordim, const StdRegions::StdExpansionSharedPtr &xmap, const Array< OneD, Array< OneD, NekDouble > > &coords)
	Constructor for GeomFactors class. More...
	GeomFactors (const GeomFactors &S)
	Copy constructor. More...
	~GeomFactors ()
	Destructor. More...
DerivStorage	GetDeriv (const LibUtilities::PointsKeyVector &keyTgt)
	Return the derivative of the mapping with respect to the reference coordinates, \(\frac{\partial \chi_i}{\partial \xi_j}\). More...
const Array< OneD, const NekDouble >	GetJac (const LibUtilities::PointsKeyVector &keyTgt)
	Return the Jacobian of the mapping and cache the result. More...
const Array< TwoD, const NekDouble >	GetGmat (const LibUtilities::PointsKeyVector &keyTgt)
	Return the Laplacian coefficients \(g_{ij}\). More...
const Array< TwoD, const NekDouble >	GetDerivFactors (const LibUtilities::PointsKeyVector &keyTgt)
	Return the derivative of the reference coordinates with respect to the mapping, \(\frac{\partial \xi_i}{\partial \chi_j}\). More...
void	GetMovingFrames (const LibUtilities::PointsKeyVector &keyTgt, const SpatialDomains::GeomMMF MMFdir, const Array< OneD, const NekDouble > &CircCentre, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Returns moving frames. More...
GeomType	GetGtype ()
	Returns whether the geometry is regular or deformed. More...
bool	IsValid () const
	Determine if element is valid and not self-intersecting. More...
int	GetCoordim () const
	Return the number of dimensions of the coordinate system. More...
size_t	GetHash ()
	Computes a hash of this GeomFactors element. More...

Protected Member Functions
StdRegions::StdExpansionSharedPtr &	GetXmap ()
	Return the Xmap;. More...

Protected Attributes
GeomType	m_type
	Type of geometry (e.g. eRegular, eDeformed, eMovingRegular). More...
int	m_expDim
	Dimension of expansion. More...
int	m_coordDim
	Dimension of coordinate system. More...
bool	m_valid
	Validity of element (Jacobian positive) More...
enum GeomMMF	m_MMFDir
	Principle tangent direction for MMF. More...
StdRegions::StdExpansionSharedPtr	m_xmap
	Stores information about the expansion. More...
Array< OneD, Array< OneD, NekDouble > >	m_coords
	Stores coordinates of the geometry. More...
std::map< LibUtilities::PointsKeyVector, Array< OneD, NekDouble > >	m_jacCache
	Jacobian vector cache. More...
std::map< LibUtilities::PointsKeyVector, Array< TwoD, NekDouble > >	m_derivFactorCache
	DerivFactors vector cache. More...

Private Member Functions
void	CheckIfValid ()
	Tests if the element is valid and not self-intersecting. More...
DerivStorage	ComputeDeriv (const LibUtilities::PointsKeyVector &keyTgt) const
Array< OneD, NekDouble >	ComputeJac (const LibUtilities::PointsKeyVector &keyTgt) const
	Return the Jacobian of the mapping and cache the result. More...
Array< TwoD, NekDouble >	ComputeGmat (const LibUtilities::PointsKeyVector &keyTgt) const
	Computes the Laplacian coefficients \(g_{ij}\). More...
Array< TwoD, NekDouble >	ComputeDerivFactors (const LibUtilities::PointsKeyVector &keyTgt) const
	Return the derivative of the reference coordinates with respect to the mapping, \(\frac{\partial \xi_i}{\partial \chi_j}\). More...
void	ComputeMovingFrames (const LibUtilities::PointsKeyVector &keyTgt, const SpatialDomains::GeomMMF MMFdir, const Array< OneD, const NekDouble > &CircCentre, Array< OneD, Array< OneD, NekDouble > > &movingframes)
void	Interp (const LibUtilities::PointsKeyVector &src_points, const Array< OneD, const NekDouble > &src, const LibUtilities::PointsKeyVector &tgt_points, Array< OneD, NekDouble > &tgt) const
	Perform interpolation of data between two point distributions. More...
void	Adjoint (const Array< TwoD, const NekDouble > &src, Array< TwoD, NekDouble > &tgt) const
	Compute the transpose of the cofactors matrix. More...
void	ComputePrincipleDirection (const LibUtilities::PointsKeyVector &keyTgt, const SpatialDomains::GeomMMF MMFdir, const Array< OneD, const NekDouble > &CircCentre, Array< OneD, Array< OneD, NekDouble > > &output)
void	VectorNormalise (Array< OneD, Array< OneD, NekDouble > > &array)
void	VectorCrossProd (const Array< OneD, const Array< OneD, NekDouble > > &v1, const Array< OneD, const Array< OneD, NekDouble > > &v2, Array< OneD, Array< OneD, NekDouble > > &v3)
	Computes the vector cross-product in 3D of v1 and v2, storing the result in v3. More...

Friends
bool	operator== (const GeomFactors &lhs, const GeomFactors &rhs)
	Tests if two GeomFactors classes are equal. More...

Detailed Description

Calculation and storage of geometric factors associated with the mapping from StdRegions reference elements to a given LocalRegions physical element in the mesh.

This class stores the various geometric factors associated with a specific element, necessary for fundamental integration and differentiation operations as well as edge and surface normals.

Initially, these algorithms are provided with a mapping from the reference region element to the physical element. Practically, this is represented using a corresponding reference region element for each coordinate component. Note that for straight-sided elements, these elements will be of linear order. Curved elements are represented using higher-order coordinate mappings. This geometric order is in contrast to the order of the spectral/hp expansion order on the element.

For application of the chain rule during differentiation we require the partial derivatives

\[\frac{\partial \xi_i}{\partial \chi_j}\]

evaluated at the physical points of the expansion basis. We also construct the inverse metric tensor \(g^{ij}\) which, in the case of a domain embedded in a higher-dimensional space, supports the conversion of covariant quantities to contravariant quantities. When the expansion dimension is equal to the coordinate dimension the Jacobian of the mapping \(\chi_j\) is a square matrix and consequently the required terms are the entries of the inverse of the Jacobian. However, in general this is not the case, so we therefore implement the construction of these terms following the derivation in Cantwell, et. al. [CaYaKiPeSh13]. Given the coordinate maps \(\chi_i\), this comprises of five steps

1. Compute the terms of the Jacobian \(\frac{\partial \chi_i}{\partial \xi_j}\).
2. Compute the metric tensor \(g_{ij}=\mathbf{t}_{(i)}\cdot\mathbf{t}_{(j)}\).
3. Compute the square of the Jacobian determinant \(g=|\mathbf{g}|\).
4. Compute the inverse metric tensor \(g^{ij}\).
5. Compute the terms \(\frac{\partial \xi_i}{\partial \chi_j}\).

Definition at line 71 of file GeomFactors.h.

Constructor & Destructor Documentation

GeomFactors() [1/2]

Nektar::SpatialDomains::GeomFactors::GeomFactors	(	const GeomType	gtype,
		const int	coordim,
		const StdRegions::StdExpansionSharedPtr &	xmap,
		const Array< OneD, Array< OneD, NekDouble > > &	coords
	)

Constructor for GeomFactors class.

Parameters

gtype	Specified whether the geometry is regular or deformed.
coordim	Specifies the dimension of the coordinate system.
Coords	Coordinate maps of the element.

Definition at line 86 of file GeomFactors.cpp.

    : m_type(gtype), m_expDim(xmap->GetShapeDimension()), m_coordDim(coordim),
      m_valid(true), m_xmap(xmap), m_coords(coords)
{
    CheckIfValid();
}

References CheckIfValid().

GeomFactors() [2/2]

Nektar::SpatialDomains::GeomFactors::GeomFactors

(

const GeomFactors &

S

)

Copy constructor.

Parameters

S	An instance of a GeomFactors class from which to construct a new instance.

Definition at line 99 of file GeomFactors.cpp.

    : m_type(S.m_type), m_expDim(S.m_expDim), m_coordDim(S.m_coordDim),
      m_valid(S.m_valid), m_xmap(S.m_xmap), m_coords(S.m_coords)
{
}

~GeomFactors()

Nektar::SpatialDomains::GeomFactors::~GeomFactors

(

)

Destructor.

Definition at line 108 of file GeomFactors.cpp.

{
}

Member Function Documentation

Adjoint()

void Nektar::SpatialDomains::GeomFactors::Adjoint ( const Array< TwoD, const NekDouble > &  src, Array< TwoD, NekDouble > &  tgt  ) const

private

Compute the transpose of the cofactors matrix.

Input and output arrays are of dimension (m_expDim*m_expDim) x num_points. The first index of the input and output arrays are ordered row-by-row.

Parameters

src	Input data array.
tgt	Storage for adjoint matrix data.

Definition at line 675 of file GeomFactors.cpp.

{
    ASSERTL1(src.size() == tgt.size(),
             "Source matrix is of different size to destination"
             "matrix for computing adjoint.");
 
    int n = src[0].size();
    switch (m_expDim)
    {
        case 1:
            Vmath::Fill(n, 1.0, &tgt[0][0], 1);
            break;
        case 2:
            Vmath::Vcopy(n, &src[3][0], 1, &tgt[0][0], 1);
            Vmath::Smul(n, -1.0, &src[1][0], 1, &tgt[1][0], 1);
            Vmath::Smul(n, -1.0, &src[2][0], 1, &tgt[2][0], 1);
            Vmath::Vcopy(n, &src[0][0], 1, &tgt[3][0], 1);
            break;
        case 3:
        {
            int a, b, c, d, e, i, j;
 
            // Compute g^{ij} by computing Cofactors(g_ij)^T
            for (i = 0; i < m_expDim; ++i)
            {
                for (j = 0; j < m_expDim; ++j)
                {
                    a = ((i + 1) % m_expDim) * m_expDim + ((j + 1) % m_expDim);
                    b = ((i + 1) % m_expDim) * m_expDim + ((j + 2) % m_expDim);
                    c = ((i + 2) % m_expDim) * m_expDim + ((j + 1) % m_expDim);
                    d = ((i + 2) % m_expDim) * m_expDim + ((j + 2) % m_expDim);
                    e = j * m_expDim + i;
                    Vmath::Vvtvvtm(n, &src[a][0], 1, &src[d][0], 1, &src[b][0],
                                   1, &src[c][0], 1, &tgt[e][0], 1);
                }
            }
            break;
        }
    }
}

References ASSERTL1, Nektar::UnitTests::d(), Vmath::Fill(), m_expDim, Vmath::Smul(), Vmath::Vcopy(), and Vmath::Vvtvvtm().

Referenced by ComputeDerivFactors(), ComputeGmat(), and ComputeJac().

CheckIfValid()

void Nektar::SpatialDomains::GeomFactors::CheckIfValid ( )

private

Tests if the element is valid and not self-intersecting.

Constructs the Jacobian as per Spencer's book p158 and tests if negative.

Definition at line 577 of file GeomFactors.cpp.

{
    // Jacobian test only makes sense when expdim = coorddim
    // If one-dimensional then element is valid.
    if (m_coordDim != m_expDim || m_expDim == 1)
    {
        m_valid = true;
        return;
    }
 
    LibUtilities::PointsKeyVector p(m_expDim);
    int nqtot = 1;
    for (int i = 0; i < m_expDim; ++i)
    {
        p[i] = m_xmap->GetBasis(i)->GetPointsKey();
        nqtot *= p[i].GetNumPoints();
    }
    int pts = (m_type == eRegular || m_type == eMovingRegular) ? 1 : nqtot;
    Array<OneD, NekDouble> jac(pts, 0.0);
 
    DerivStorage deriv = GetDeriv(p);
 
    switch (m_expDim)
    {
        case 2:
        {
            Vmath::Vvtvvtm(pts, &deriv[0][0][0], 1, &deriv[1][1][0], 1,
                           &deriv[1][0][0], 1, &deriv[0][1][0], 1, &jac[0], 1);
            break;
        }
        case 3:
        {
            Array<OneD, NekDouble> tmp(pts, 0.0);
 
            Vmath::Vvtvvtm(pts, &deriv[1][1][0], 1, &deriv[2][2][0], 1,
                           &deriv[2][1][0], 1, &deriv[1][2][0], 1, &tmp[0], 1);
            Vmath::Vvtvp(pts, &deriv[0][0][0], 1, &tmp[0], 1, &jac[0], 1,
                         &jac[0], 1);
 
            Vmath::Vvtvvtm(pts, &deriv[2][1][0], 1, &deriv[0][2][0], 1,
                           &deriv[0][1][0], 1, &deriv[2][2][0], 1, &tmp[0], 1);
            Vmath::Vvtvp(pts, &deriv[1][0][0], 1, &tmp[0], 1, &jac[0], 1,
                         &jac[0], 1);
 
            Vmath::Vvtvvtm(pts, &deriv[0][1][0], 1, &deriv[1][2][0], 1,
                           &deriv[1][1][0], 1, &deriv[0][2][0], 1, &tmp[0], 1);
            Vmath::Vvtvp(pts, &deriv[2][0][0], 1, &tmp[0], 1, &jac[0], 1,
                         &jac[0], 1);
 
            break;
        }
    }
 
    if (Vmath::Vmin(pts, &jac[0], 1) < 0)
    {
        m_valid = false;
    }
}

References Nektar::SpatialDomains::eMovingRegular, Nektar::SpatialDomains::eRegular, GetDeriv(), m_coordDim, m_expDim, m_type, m_valid, m_xmap, CellMLToNektar.cellml_metadata::p, Vmath::Vmin(), Vmath::Vvtvp(), and Vmath::Vvtvvtm().

Referenced by GeomFactors().

ComputeDeriv()

DerivStorage Nektar::SpatialDomains::GeomFactors::ComputeDeriv ( const LibUtilities::PointsKeyVector &  keyTgt ) const

private

Derivatives are computed at the geometry point distributions and interpolated to the target point distributions.

Parameters

tpoints

Target point distributions.

Returns

Derivative of coordinate map evaluated at target point distributions.

Definition at line 153 of file GeomFactors.cpp.

{
    ASSERTL1(keyTgt.size() == m_expDim,
             "Dimension of target point distribution does not match "
             "expansion dimension.");
 
    int i = 0, j = 0;
    int nqtot_map      = 1;
    int nqtot_tbasis   = 1;
    DerivStorage deriv = DerivStorage(m_expDim);
    DerivStorage d_map = DerivStorage(m_expDim);
    LibUtilities::PointsKeyVector map_points(m_expDim);
 
    // Allocate storage and compute number of points
    for (i = 0; i < m_expDim; ++i)
    {
        map_points[i] = m_xmap->GetBasis(i)->GetPointsKey();
        nqtot_map *= map_points[i].GetNumPoints();
        nqtot_tbasis *= keyTgt[i].GetNumPoints();
        deriv[i] = Array<OneD, Array<OneD, NekDouble>>(m_coordDim);
        d_map[i] = Array<OneD, Array<OneD, NekDouble>>(m_coordDim);
    }
 
    // Calculate local derivatives
    for (i = 0; i < m_coordDim; ++i)
    {
        Array<OneD, NekDouble> tmp(nqtot_map);
        // Transform from coefficient space to physical space
        m_xmap->BwdTrans(m_coords[i], tmp);
 
        // Allocate storage and take the derivative (calculated at the
        // points as specified in 'Coords')
        for (j = 0; j < m_expDim; ++j)
        {
            d_map[j][i] = Array<OneD, NekDouble>(nqtot_map);
            deriv[j][i] = Array<OneD, NekDouble>(nqtot_tbasis);
            m_xmap->StdPhysDeriv(j, tmp, d_map[j][i]);
        }
    }
 
    for (i = 0; i < m_coordDim; ++i)
    {
        // Interpolate the derivatives:
        // - from the points as defined in the mapping ('Coords')
        // - to the points at which we want to know the metrics
        //   ('tbasis')
        bool same = true;
        for (j = 0; j < m_expDim; ++j)
        {
            same = same && (map_points[j] == keyTgt[j]);
        }
        if (same)
        {
            for (j = 0; j < m_expDim; ++j)
            {
                deriv[j][i] = d_map[j][i];
            }
        }
        else
        {
            for (j = 0; j < m_expDim; ++j)
            {
                Interp(map_points, d_map[j][i], keyTgt, deriv[j][i]);
            }
        }
    }
 
    return deriv;
}

References ASSERTL1, Interp(), m_coordDim, m_coords, m_expDim, and m_xmap.

Referenced by ComputeDerivFactors(), ComputeGmat(), ComputeJac(), ComputeMovingFrames(), and GetDeriv().

ComputeDerivFactors()

Array< TwoD, NekDouble > Nektar::SpatialDomains::GeomFactors::ComputeDerivFactors ( const LibUtilities::PointsKeyVector &  keyTgt ) const

private

Return the derivative of the reference coordinates with respect to the mapping, \(\frac{\partial \xi_i}{\partial \chi_j}\).

Parameters

keyTgt

Target point distributions.

Returns

Derivative factors evaluated at the target point distributions. A 1D example: /f$ Jac =(\partial x/ \partial \xi) /f$ ; /f$ factor = 1/Jac = (\partial \xi/ \partial x) /f$

Definition at line 376 of file GeomFactors.cpp.

{
    ASSERTL1(keyTgt.size() == m_expDim,
             "Dimension of target point distribution does not match "
             "expansion dimension.");
 
    int i = 0, j = 0, k = 0, l = 0;
    int ptsTgt = 1;
 
    if (m_type == eDeformed)
    {
        // Allocate storage and compute number of points
        for (i = 0; i < m_expDim; ++i)
        {
            ptsTgt *= keyTgt[i].GetNumPoints();
        }
    }
 
    // Get derivative at geometry points
    DerivStorage deriv = ComputeDeriv(keyTgt);
 
    Array<TwoD, NekDouble> tmp(m_expDim * m_expDim, ptsTgt, 0.0);
    Array<TwoD, NekDouble> gmat(m_expDim * m_expDim, ptsTgt, 0.0);
    Array<OneD, NekDouble> jac(ptsTgt, 0.0);
    Array<TwoD, NekDouble> factors(m_expDim * m_coordDim, ptsTgt, 0.0);
 
    // Compute g_{ij} as t_i \cdot t_j and store in tmp
    for (i = 0, l = 0; i < m_expDim; ++i)
    {
        for (j = 0; j < m_expDim; ++j, ++l)
        {
            for (k = 0; k < m_coordDim; ++k)
            {
                Vmath::Vvtvp(ptsTgt, &deriv[i][k][0], 1, &deriv[j][k][0], 1,
                             &tmp[l][0], 1, &tmp[l][0], 1);
            }
        }
    }
 
    Adjoint(tmp, gmat);
 
    // Compute g = det(g_{ij}) (= Jacobian squared) and store
    // temporarily in m_jac.
    for (i = 0; i < m_expDim; ++i)
    {
        Vmath::Vvtvp(ptsTgt, &tmp[i][0], 1, &gmat[i * m_expDim][0], 1, &jac[0],
                     1, &jac[0], 1);
    }
 
    for (i = 0; i < m_expDim * m_expDim; ++i)
    {
        Vmath::Vdiv(ptsTgt, &gmat[i][0], 1, &jac[0], 1, &gmat[i][0], 1);
    }
 
    // Compute the Jacobian = sqrt(g)
    Vmath::Vsqrt(ptsTgt, &jac[0], 1, &jac[0], 1);
 
    // Compute the derivative factors
    for (k = 0, l = 0; k < m_coordDim; ++k)
    {
        for (j = 0; j < m_expDim; ++j, ++l)
        {
            for (i = 0; i < m_expDim; ++i)
            {
                Vmath::Vvtvp(ptsTgt, &deriv[i][k][0], 1,
                             &gmat[m_expDim * i + j][0], 1, &factors[l][0], 1,
                             &factors[l][0], 1);
            }
        }
    }
 
    return factors;
}

References Adjoint(), ASSERTL1, ComputeDeriv(), Nektar::SpatialDomains::eDeformed, Nektar::VarcoeffHashingTest::factors, m_coordDim, m_expDim, m_type, Vmath::Vdiv(), Vmath::Vsqrt(), and Vmath::Vvtvp().

Referenced by GetDerivFactors().

ComputeGmat()

Array< TwoD, NekDouble > Nektar::SpatialDomains::GeomFactors::ComputeGmat ( const LibUtilities::PointsKeyVector &  keyTgt ) const

private

Computes the Laplacian coefficients \(g_{ij}\).

This routine returns a two-dimensional array of values specifying the inverse metric terms associated with the coordinate mapping of the corresponding reference region to the physical element. These terms correspond to the \(g^{ij}\) terms in [CaYaKiPeSh13] and, in the case of an embedded manifold, map covariant quantities to contravariant quantities. The leading index of the array is the index of the term in the tensor numbered as

\[\left(\begin{array}{ccc} 0 & 1 & 2 \\ 1 & 3 & 4 \\ 2 & 4 & 5 \end{array}\right)\]

. The second dimension is either of size 1 in the case of elements having GeomType eRegular, or of size equal to the number of quadrature points for eDeformed elements.

See also

[Wikipedia "Covariance and Contravariance of Vectors"] (http://en.wikipedia.org/wiki/Covariance_and_contravariance_of_vectors)

Returns

Two-dimensional array containing the inverse metric tensor of the coordinate mapping.

Definition at line 312 of file GeomFactors.cpp.

{
    ASSERTL1(keyTgt.size() == m_expDim,
             "Dimension of target point distribution does not match "
             "expansion dimension.");
 
    int i = 0, j = 0, k = 0, l = 0;
    int ptsTgt = 1;
 
    if (m_type == eDeformed)
    {
        // Allocate storage and compute number of points
        for (i = 0; i < m_expDim; ++i)
        {
            ptsTgt *= keyTgt[i].GetNumPoints();
        }
    }
 
    // Get derivative at geometry points
    DerivStorage deriv = ComputeDeriv(keyTgt);
 
    Array<TwoD, NekDouble> tmp(m_expDim * m_expDim, ptsTgt, 0.0);
    Array<TwoD, NekDouble> gmat(m_expDim * m_expDim, ptsTgt, 0.0);
    Array<OneD, NekDouble> jac(ptsTgt, 0.0);
 
    // Compute g_{ij} as t_i \cdot t_j and store in tmp
    for (i = 0, l = 0; i < m_expDim; ++i)
    {
        for (j = 0; j < m_expDim; ++j, ++l)
        {
            for (k = 0; k < m_coordDim; ++k)
            {
                Vmath::Vvtvp(ptsTgt, &deriv[i][k][0], 1, &deriv[j][k][0], 1,
                             &tmp[l][0], 1, &tmp[l][0], 1);
            }
        }
    }
 
    Adjoint(tmp, gmat);
 
    // Compute g = det(g_{ij}) (= Jacobian squared) and store
    // temporarily in m_jac.
    for (i = 0; i < m_expDim; ++i)
    {
        Vmath::Vvtvp(ptsTgt, &tmp[i][0], 1, &gmat[i * m_expDim][0], 1, &jac[0],
                     1, &jac[0], 1);
    }
 
    for (i = 0; i < m_expDim * m_expDim; ++i)
    {
        Vmath::Vdiv(ptsTgt, &gmat[i][0], 1, &jac[0], 1, &gmat[i][0], 1);
    }
 
    return gmat;
}

References Adjoint(), ASSERTL1, ComputeDeriv(), Nektar::SpatialDomains::eDeformed, m_coordDim, m_expDim, m_type, Vmath::Vdiv(), and Vmath::Vvtvp().

Referenced by GetGmat().

ComputeJac()

Array< OneD, NekDouble > Nektar::SpatialDomains::GeomFactors::ComputeJac ( const LibUtilities::PointsKeyVector &  keyTgt ) const

private

Return the Jacobian of the mapping and cache the result.

This routine returns an array of values specifying the Jacobian of the mapping at quadrature points in the element. The array is either of size 1 in the case of elements having GeomType eRegular, or of size equal to the number of quadrature points for eDeformed elements.

Returns

Array containing the Jacobian of the coordinate mapping at the quadrature points of the element.

See also

GeomType

Definition at line 235 of file GeomFactors.cpp.

{
    ASSERTL1(keyTgt.size() == m_expDim,
             "Dimension of target point distribution does not match "
             "expansion dimension.");
 
    int i = 0, j = 0, k = 0, l = 0;
    int ptsTgt = 1;
 
    if (m_type == eDeformed)
    {
        // Allocate storage and compute number of points
        for (i = 0; i < m_expDim; ++i)
        {
            ptsTgt *= keyTgt[i].GetNumPoints();
        }
    }
 
    // Get derivative at geometry points
    DerivStorage deriv = ComputeDeriv(keyTgt);
 
    Array<TwoD, NekDouble> tmp(m_expDim * m_expDim, ptsTgt, 0.0);
    Array<TwoD, NekDouble> gmat(m_expDim * m_expDim, ptsTgt, 0.0);
    Array<OneD, NekDouble> jac(ptsTgt, 0.0);
 
    // Compute g_{ij} as t_i \cdot t_j and store in tmp
    for (i = 0, l = 0; i < m_expDim; ++i)
    {
        for (j = 0; j < m_expDim; ++j, ++l)
        {
            for (k = 0; k < m_coordDim; ++k)
            {
                Vmath::Vvtvp(ptsTgt, &deriv[i][k][0], 1, &deriv[j][k][0], 1,
                             &tmp[l][0], 1, &tmp[l][0], 1);
            }
        }
    }
 
    Adjoint(tmp, gmat);
 
    // Compute g = det(g_{ij}) (= Jacobian squared) and store
    // temporarily in m_jac.
    for (i = 0; i < m_expDim; ++i)
    {
        Vmath::Vvtvp(ptsTgt, &tmp[i][0], 1, &gmat[i * m_expDim][0], 1, &jac[0],
                     1, &jac[0], 1);
    }
 
    // Compute the Jacobian = sqrt(g)
    Vmath::Vsqrt(ptsTgt, &jac[0], 1, &jac[0], 1);
 
    return jac;
}

References Adjoint(), ASSERTL1, ComputeDeriv(), Nektar::SpatialDomains::eDeformed, m_coordDim, m_expDim, m_type, Vmath::Vsqrt(), and Vmath::Vvtvp().

Referenced by GetJac().

ComputeMovingFrames()

void Nektar::SpatialDomains::GeomFactors::ComputeMovingFrames ( const LibUtilities::PointsKeyVector &  keyTgt, const SpatialDomains::GeomMMF  MMFdir, const Array< OneD, const NekDouble > &  CircCentre, Array< OneD, Array< OneD, NekDouble > > &  movingframes  )

private

Definition at line 451 of file GeomFactors.cpp.

{
    ASSERTL1(keyTgt.size() == m_expDim,
             "Dimension of target point distribution does not match "
             "expansion dimension.");
 
    int i = 0, k = 0;
    int ptsTgt = 1;
    int nq     = 1;
 
    for (i = 0; i < m_expDim; ++i)
    {
        nq *= keyTgt[i].GetNumPoints();
    }
 
    if (m_type == eDeformed)
    {
        // Allocate storage and compute number of points
        for (i = 0; i < m_expDim; ++i)
        {
            ptsTgt *= keyTgt[i].GetNumPoints();
        }
    }
 
    // Get derivative at geometry points
    DerivStorage deriv = ComputeDeriv(keyTgt);
 
    // number of moving frames is requited to be 3, even for surfaces
    int MFdim = 3;
 
    Array<OneD, Array<OneD, Array<OneD, NekDouble>>> MFtmp(MFdim);
 
    // Compute g_{ij} as t_i \cdot t_j and store in tmp
    for (i = 0; i < MFdim; ++i)
    {
        MFtmp[i] = Array<OneD, Array<OneD, NekDouble>>(m_coordDim);
        for (k = 0; k < m_coordDim; ++k)
        {
            MFtmp[i][k] = Array<OneD, NekDouble>(nq);
        }
    }
 
    // Compute g_{ij} as t_i \cdot t_j and store in tmp
    for (i = 0; i < MFdim - 1; ++i)
    {
        for (k = 0; k < m_coordDim; ++k)
        {
            if (m_type == eDeformed)
            {
                Vmath::Vcopy(ptsTgt, &deriv[i][k][0], 1, &MFtmp[i][k][0], 1);
            }
            else
            {
                Vmath::Fill(nq, deriv[i][k][0], MFtmp[i][k], 1);
            }
        }
    }
 
    // Direction of MF1 is preserved: MF2 is considered in the same
    // tangent plane as MF1. MF3 is computed by cross product of MF1
    // and MF2. MF2 is consequently computed as the cross product of
    // MF3 and MF1.
    Array<OneD, Array<OneD, NekDouble>> PrincipleDir(m_coordDim);
    for (k = 0; k < m_coordDim; k++)
    {
        PrincipleDir[k] = Array<OneD, NekDouble>(nq);
    }
 
    if (!(MMFdir == eLOCAL))
    {
        ComputePrincipleDirection(keyTgt, MMFdir, factors, PrincipleDir);
    }
 
    // MF3 = MF1 \times MF2
    VectorCrossProd(MFtmp[0], MFtmp[1], MFtmp[2]);
 
    // Normalizing MF3
    VectorNormalise(MFtmp[2]);
 
    if (!(MMFdir == eLOCAL))
    {
        Array<OneD, NekDouble> temp(nq, 0.0);
 
        // Reorient MF1 along the PrincipleDir
        for (i = 0; i < m_coordDim; ++i)
        {
            Vmath::Vvtvp(nq, MFtmp[2][i], 1, PrincipleDir[i], 1, temp, 1, temp,
                         1);
        }
        Vmath::Neg(nq, temp, 1);
 
        // u2 = v2 - < u1 , v2 > ( u1 / < u1, u1 > )
        for (i = 0; i < m_coordDim; ++i)
        {
            Vmath::Vvtvp(nq, temp, 1, MFtmp[2][i], 1, PrincipleDir[i], 1,
                         MFtmp[0][i], 1);
        }
    }
 
    // Normalizing MF1
    VectorNormalise(MFtmp[0]);
 
    // MF2 = MF3 \times MF1
    VectorCrossProd(MFtmp[2], MFtmp[0], MFtmp[1]);
 
    // Normalizing MF2
    VectorNormalise(MFtmp[1]);
 
    for (i = 0; i < MFdim; ++i)
    {
        for (k = 0; k < m_coordDim; ++k)
        {
            Vmath::Vcopy(nq, &MFtmp[i][k][0], 1,
                         &movingframes[i * m_coordDim + k][0], 1);
        }
    }
}

References ASSERTL1, ComputeDeriv(), ComputePrincipleDirection(), Nektar::SpatialDomains::eDeformed, Nektar::SpatialDomains::eLOCAL, Nektar::VarcoeffHashingTest::factors, Vmath::Fill(), m_coordDim, m_expDim, m_type, Vmath::Neg(), Vmath::Vcopy(), VectorCrossProd(), VectorNormalise(), and Vmath::Vvtvp().

Referenced by GetMovingFrames().

ComputePrincipleDirection()

void Nektar::SpatialDomains::GeomFactors::ComputePrincipleDirection ( const LibUtilities::PointsKeyVector &  keyTgt, const SpatialDomains::GeomMMF  MMFdir, const Array< OneD, const NekDouble > &  CircCentre, Array< OneD, Array< OneD, NekDouble > > &  output  )

private

Definition at line 720 of file GeomFactors.cpp.

{
    int nq = output[0].size();
 
    output = Array<OneD, Array<OneD, NekDouble>>(m_coordDim);
    for (int i = 0; i < m_coordDim; ++i)
    {
        output[i] = Array<OneD, NekDouble>(nq, 0.0);
    }
 
    // Construction of Connection
    switch (MMFdir)
    {
        // projection to x-axis
        case eTangentX:
        {
            Vmath::Fill(nq, 1.0, output[0], 1);
            break;
        }
        case eTangentY:
        {
            Vmath::Fill(nq, 1.0, output[1], 1);
            break;
        }
        case eTangentXY:
        {
            Vmath::Fill(nq, sqrt(2.0), output[0], 1);
            Vmath::Fill(nq, sqrt(2.0), output[1], 1);
            break;
        }
        case eTangentZ:
        {
            Vmath::Fill(nq, 1.0, output[2], 1);
            break;
        }
        case eTangentCircular:
        {
            // Tangent direction depends on spatial location.
            Array<OneD, Array<OneD, NekDouble>> x(m_coordDim);
            for (int k = 0; k < m_coordDim; k++)
            {
                x[k] = Array<OneD, NekDouble>(nq);
            }
 
            // m_coords are StdExpansions which store the mapping
            // between the std element and the local element. Bwd
            // transforming the std element minimum basis gives a
            // minimum physical basis for geometry. Need to then
            // interpolate this up to the quadrature basis.
            int nqtot_map = 1;
            LibUtilities::PointsKeyVector map_points(m_expDim);
            for (int i = 0; i < m_expDim; ++i)
            {
                map_points[i] = m_xmap->GetBasis(i)->GetPointsKey();
                nqtot_map *= map_points[i].GetNumPoints();
            }
            Array<OneD, NekDouble> tmp(nqtot_map);
            for (int k = 0; k < m_coordDim; k++)
            {
                m_xmap->BwdTrans(m_coords[k], tmp);
                Interp(map_points, tmp, keyTgt, x[k]);
            }
 
            // circular around the center of the domain
            NekDouble radius, xc = 0.0, yc = 0.0, xdis, ydis;
            NekDouble la, lb;
 
            ASSERTL1(factors.size() >= 4, "factors is too short.");
 
            la = factors[0];
            lb = factors[1];
            xc = factors[2];
            yc = factors[3];
 
            for (int i = 0; i < nq; i++)
            {
                xdis   = x[0][i] - xc;
                ydis   = x[1][i] - yc;
                radius = sqrt(xdis * xdis / la / la + ydis * ydis / lb / lb);
                output[0][i] = ydis / radius;
                output[1][i] = -1.0 * xdis / radius;
            }
            break;
        }
        case eTangentIrregular:
        {
            // Tangent direction depends on spatial location.
            Array<OneD, Array<OneD, NekDouble>> x(m_coordDim);
            for (int k = 0; k < m_coordDim; k++)
            {
                x[k] = Array<OneD, NekDouble>(nq);
            }
 
            int nqtot_map = 1;
            LibUtilities::PointsKeyVector map_points(m_expDim);
            for (int i = 0; i < m_expDim; ++i)
            {
                map_points[i] = m_xmap->GetBasis(i)->GetPointsKey();
                nqtot_map *= map_points[i].GetNumPoints();
            }
            Array<OneD, NekDouble> tmp(nqtot_map);
            for (int k = 0; k < m_coordDim; k++)
            {
                m_xmap->BwdTrans(m_coords[k], tmp);
                Interp(map_points, tmp, keyTgt, x[k]);
            }
 
            // circular around the center of the domain
            NekDouble xtan, ytan, mag;
            for (int i = 0; i < nq; i++)
            {
                xtan         = -1.0 * (x[1][i] * x[1][i] * x[1][i] + x[1][i]);
                ytan         = 2.0 * x[0][i];
                mag          = sqrt(xtan * xtan + ytan * ytan);
                output[0][i] = xtan / mag;
                output[1][i] = ytan / mag;
            }
            break;
        }
        case eTangentNonconvex:
        {
            // Tangent direction depends on spatial location.
            Array<OneD, Array<OneD, NekDouble>> x(m_coordDim);
            for (int k = 0; k < m_coordDim; k++)
            {
                x[k] = Array<OneD, NekDouble>(nq);
            }
 
            int nqtot_map = 1;
            LibUtilities::PointsKeyVector map_points(m_expDim);
            for (int i = 0; i < m_expDim; ++i)
            {
                map_points[i] = m_xmap->GetBasis(i)->GetPointsKey();
                nqtot_map *= map_points[i].GetNumPoints();
            }
            Array<OneD, NekDouble> tmp(nqtot_map);
            for (int k = 0; k < m_coordDim; k++)
            {
                m_xmap->BwdTrans(m_coords[k], tmp);
                Interp(map_points, tmp, keyTgt, x[k]);
            }
 
            // circular around the center of the domain
            NekDouble xtan, ytan, mag;
            for (int i = 0; i < nq; i++)
            {
                xtan         = -2.0 * x[1][i] * x[1][i] * x[1][i] + x[1][i];
                ytan         = sqrt(3.0) * x[0][i];
                mag          = sqrt(xtan * xtan + ytan * ytan);
                output[0][i] = xtan / mag;
                output[1][i] = ytan / mag;
            }
            break;
        }
        default:
        {
            break;
        }
    }
}

References ASSERTL1, Nektar::SpatialDomains::eTangentCircular, Nektar::SpatialDomains::eTangentIrregular, Nektar::SpatialDomains::eTangentNonconvex, Nektar::SpatialDomains::eTangentX, Nektar::SpatialDomains::eTangentXY, Nektar::SpatialDomains::eTangentY, Nektar::SpatialDomains::eTangentZ, Nektar::VarcoeffHashingTest::factors, Vmath::Fill(), Interp(), m_coordDim, m_coords, m_expDim, m_xmap, and tinysimd::sqrt().

Referenced by ComputeMovingFrames().

GetCoordim()

int Nektar::SpatialDomains::GeomFactors::GetCoordim ( ) const

inline

Return the number of dimensions of the coordinate system.

This is greater than or equal to the expansion dimension.

Returns

The dimension of the coordinate system.

Definition at line 307 of file GeomFactors.h.

{
    return m_coordDim;
}

References m_coordDim.

GetDeriv()

DerivStorage Nektar::SpatialDomains::GeomFactors::GetDeriv ( const LibUtilities::PointsKeyVector &  tpoints )

inline

Return the derivative of the mapping with respect to the reference coordinates, \(\frac{\partial \chi_i}{\partial \xi_j}\).

Parameters

tpoints

Target point distributions.

Returns

Derivative evaluated at target point distributions.

See also

GeomFactors::ComputeDeriv

Definition at line 216 of file GeomFactors.h.

{
    return ComputeDeriv(tpoints);
}

References ComputeDeriv().

Referenced by CheckIfValid().

GetDerivFactors()

const Array< TwoD, const NekDouble > Nektar::SpatialDomains::GeomFactors::GetDerivFactors ( const LibUtilities::PointsKeyVector &  keyTgt )

inline

Return the derivative of the reference coordinates with respect to the mapping, \(\frac{\partial \xi_i}{\partial \chi_j}\).

Returns cached value if available, otherwise computes derivative factors and stores result in cache.

Parameters

keyTgt

Target point distributions.

Returns

Derivative factors evaluated at target point distributions.

See also

GeomFactors::ComputeDerivFactors

Definition at line 267 of file GeomFactors.h.

{
    auto x = m_derivFactorCache.find(keyTgt);
 
    if (x != m_derivFactorCache.end())
    {
        return x->second;
    }
 
    m_derivFactorCache[keyTgt] = ComputeDerivFactors(keyTgt);
 
    return m_derivFactorCache[keyTgt];
}

References ComputeDerivFactors(), and m_derivFactorCache.

GetGmat()

const Array< TwoD, const NekDouble > Nektar::SpatialDomains::GeomFactors::GetGmat ( const LibUtilities::PointsKeyVector &  keyTgt )

inline

Return the Laplacian coefficients \(g_{ij}\).

Parameters

keyTgt

Target point distributions.

Returns

Inverse metric tensor evaluated at target point distributions.

See also

GeomFactors::ComputeGmat

Definition at line 252 of file GeomFactors.h.

{
    return ComputeGmat(keyTgt);
}

References ComputeGmat().

GetGtype()

GeomType Nektar::SpatialDomains::GeomFactors::GetGtype ( )

inline

Returns whether the geometry is regular or deformed.

A geometric shape is considered regular if it has constant geometric information, and deformed if this information changes throughout the shape.

Returns

The type of geometry.

See also

GeomType

Definition at line 298 of file GeomFactors.h.

{
    return m_type;
}

References m_type.

GetHash()

size_t Nektar::SpatialDomains::GeomFactors::GetHash ( )

inline

Computes a hash of this GeomFactors element.

The hash is computed from the geometry type, expansion dimension, coordinate dimension and Jacobian.

Returns

Hash of this GeomFactors object.

Definition at line 327 of file GeomFactors.h.

{
    LibUtilities::PointsKeyVector ptsKeys  = m_xmap->GetPointsKeys();
    const Array<OneD, const NekDouble> jac = GetJac(ptsKeys);
 
    size_t hash = 0;
    hash_combine(hash, (int)m_type, m_expDim, m_coordDim);
    if (m_type == eDeformed)
    {
        hash_range(hash, jac.begin(), jac.end());
    }
    else
    {
        hash_combine(hash, jac[0]);
    }
    return hash;
}

References Nektar::SpatialDomains::eDeformed, GetJac(), Nektar::hash_combine(), Nektar::hash_range(), m_coordDim, m_expDim, m_type, and m_xmap.

GetJac()

const Array< OneD, const NekDouble > Nektar::SpatialDomains::GeomFactors::GetJac ( const LibUtilities::PointsKeyVector &  keyTgt )

inline

Return the Jacobian of the mapping and cache the result.

Returns cached value if available, otherwise computes Jacobian and stores result in cache.

Parameters

keyTgt

Target point distributions.

Returns

Jacobian evaluated at target point distributions.

See also

GeomFactors::ComputeJac

Definition at line 231 of file GeomFactors.h.

{
    auto x = m_jacCache.find(keyTgt);
 
    if (x != m_jacCache.end())
    {
        return x->second;
    }
 
    m_jacCache[keyTgt] = ComputeJac(keyTgt);
 
    return m_jacCache[keyTgt];
}

References ComputeJac(), and m_jacCache.

Referenced by GetHash().

GetMovingFrames()

void Nektar::SpatialDomains::GeomFactors::GetMovingFrames ( const LibUtilities::PointsKeyVector &  keyTgt, const SpatialDomains::GeomMMF  MMFdir, const Array< OneD, const NekDouble > &  CircCentre, Array< OneD, Array< OneD, NekDouble > > &  outarray  )

inline

Returns moving frames.

Definition at line 282 of file GeomFactors.h.

{
    ComputeMovingFrames(keyTgt, MMFdir, CircCentre, outarray);
}

References ComputeMovingFrames().

GetXmap()

StdRegions::StdExpansionSharedPtr & Nektar::SpatialDomains::GeomFactors::GetXmap ( void  )

inlineprotected

Return the Xmap;.

Definition at line 345 of file GeomFactors.h.

{
    return m_xmap;
}

References m_xmap.

Interp()

void Nektar::SpatialDomains::GeomFactors::Interp ( const LibUtilities::PointsKeyVector &  src_points, const Array< OneD, const NekDouble > &  src, const LibUtilities::PointsKeyVector &  tgt_points, Array< OneD, NekDouble > &  tgt  ) const

private

Perform interpolation of data between two point distributions.

Parameters

map_points	Source data point distribution.
src	Source data to be interpolated.
tpoints	Target data point distribution.
tgt	Target data storage.

Definition at line 642 of file GeomFactors.cpp.

{
    ASSERTL1(src_points.size() == tgt_points.size(),
             "Dimension of target point distribution does not match "
             "expansion dimension.");
 
    switch (m_expDim)
    {
        case 1:
            LibUtilities::Interp1D(src_points[0], src, tgt_points[0], tgt);
            break;
        case 2:
            LibUtilities::Interp2D(src_points[0], src_points[1], src,
                                   tgt_points[0], tgt_points[1], tgt);
            break;
        case 3:
            LibUtilities::Interp3D(src_points[0], src_points[1], src_points[2],
                                   src, tgt_points[0], tgt_points[1],
                                   tgt_points[2], tgt);
            break;
    }
}

References ASSERTL1, Nektar::LibUtilities::Interp1D(), Nektar::LibUtilities::Interp2D(), Nektar::LibUtilities::Interp3D(), and m_expDim.

Referenced by ComputeDeriv(), and ComputePrincipleDirection().

IsValid()

bool Nektar::SpatialDomains::GeomFactors::IsValid ( ) const

inline

Determine if element is valid and not self-intersecting.

The validity test is performed by testing if the Jacobian is negative at any point in the shape.

Returns

True if the element is not self-intersecting.

Definition at line 317 of file GeomFactors.h.

{
    return m_valid;
}

References m_valid.

VectorCrossProd()

void Nektar::SpatialDomains::GeomFactors::VectorCrossProd ( const Array< OneD, const Array< OneD, NekDouble > > &  v1, const Array< OneD, const Array< OneD, NekDouble > > &  v2, Array< OneD, Array< OneD, NekDouble > > &  v3  )

private

Computes the vector cross-product in 3D of v1 and v2, storing the result in v3.

Parameters

v1	First input vector.
v2	Second input vector.
v3	Output vector computed to be orthogonal to both v1 and v2.

Definition at line 925 of file GeomFactors.cpp.

{
    ASSERTL0(v1.size() == 3, "Input 1 has dimension not equal to 3.");
    ASSERTL0(v2.size() == 3, "Input 2 has dimension not equal to 3.");
    ASSERTL0(v3.size() == 3, "Output vector has dimension not equal to 3.");
 
    int nq = v1[0].size();
    Array<OneD, NekDouble> temp(nq);
 
    Vmath::Vmul(nq, v1[2], 1, v2[1], 1, temp, 1);
    Vmath::Vvtvm(nq, v1[1], 1, v2[2], 1, temp, 1, v3[0], 1);
 
    Vmath::Vmul(nq, v1[0], 1, v2[2], 1, temp, 1);
    Vmath::Vvtvm(nq, v1[2], 1, v2[0], 1, temp, 1, v3[1], 1);
 
    Vmath::Vmul(nq, v1[1], 1, v2[0], 1, temp, 1);
    Vmath::Vvtvm(nq, v1[0], 1, v2[1], 1, temp, 1, v3[2], 1);
}

References ASSERTL0, Vmath::Vmul(), and Vmath::Vvtvm().

Referenced by ComputeMovingFrames().

VectorNormalise()

void Nektar::SpatialDomains::GeomFactors::VectorNormalise ( Array< OneD, Array< OneD, NekDouble > > &  array )

private

Definition at line 888 of file GeomFactors.cpp.

{
    int ndim = array.size();
    ASSERTL0(ndim > 0, "Number of components must be > 0.");
    for (int i = 1; i < ndim; ++i)
    {
        ASSERTL0(array[i].size() == array[0].size(),
                 "Array size mismatch in coordinates.");
    }
 
    int nq = array[0].size();
    Array<OneD, NekDouble> norm(nq, 0.0);
 
    // Compute the norm of each vector.
    for (int i = 0; i < ndim; ++i)
    {
        Vmath::Vvtvp(nq, array[i], 1, array[i], 1, norm, 1, norm, 1);
    }
 
    Vmath::Vsqrt(nq, norm, 1, norm, 1);
 
    // Normalise the vectors by the norm
    for (int i = 0; i < ndim; ++i)
    {
        Vmath::Vdiv(nq, array[i], 1, norm, 1, array[i], 1);
    }
}

References ASSERTL0, Vmath::Vdiv(), Vmath::Vsqrt(), and Vmath::Vvtvp().

Referenced by ComputeMovingFrames().

Friends And Related Function Documentation

operator==

bool operator== ( const GeomFactors &  lhs, const GeomFactors &  rhs  )

friend

Tests if two GeomFactors classes are equal.

Member data equivalence is tested in the following order: shape type, expansion dimension, coordinate dimension and coordinates.

Definition at line 116 of file GeomFactors.cpp.

{
    if (!(lhs.m_type == rhs.m_type))
    {
        return false;
    }
 
    if (!(lhs.m_expDim == rhs.m_expDim))
    {
        return false;
    }
 
    if (!(lhs.m_coordDim == rhs.m_coordDim))
    {
        return false;
    }
 
    const Array<OneD, const NekDouble> jac_lhs =
        lhs.ComputeJac(lhs.m_xmap->GetPointsKeys());
    const Array<OneD, const NekDouble> jac_rhs =
        rhs.ComputeJac(rhs.m_xmap->GetPointsKeys());
    if (!(jac_lhs == jac_rhs))
    {
        return false;
    }
 
    return true;
}

Member Data Documentation

m_coordDim

int Nektar::SpatialDomains::GeomFactors::m_coordDim

protected

Dimension of coordinate system.

Definition at line 131 of file GeomFactors.h.

Referenced by CheckIfValid(), ComputeDeriv(), ComputeDerivFactors(), ComputeGmat(), ComputeJac(), ComputeMovingFrames(), ComputePrincipleDirection(), GetCoordim(), and GetHash().

m_coords

Array<OneD, Array<OneD, NekDouble> > Nektar::SpatialDomains::GeomFactors::m_coords

protected

Stores coordinates of the geometry.

Definition at line 141 of file GeomFactors.h.

Referenced by ComputeDeriv(), and ComputePrincipleDirection().

m_derivFactorCache

std::map<LibUtilities::PointsKeyVector, Array<TwoD, NekDouble> > Nektar::SpatialDomains::GeomFactors::m_derivFactorCache

protected

DerivFactors vector cache.

Definition at line 146 of file GeomFactors.h.

Referenced by GetDerivFactors().

m_expDim

int Nektar::SpatialDomains::GeomFactors::m_expDim

protected

Dimension of expansion.

Definition at line 129 of file GeomFactors.h.

Referenced by Adjoint(), CheckIfValid(), ComputeDeriv(), ComputeDerivFactors(), ComputeGmat(), ComputeJac(), ComputeMovingFrames(), ComputePrincipleDirection(), GetHash(), and Interp().

m_jacCache

std::map<LibUtilities::PointsKeyVector, Array<OneD, NekDouble> > Nektar::SpatialDomains::GeomFactors::m_jacCache

protected

Jacobian vector cache.

Definition at line 143 of file GeomFactors.h.

Referenced by GetJac().

m_MMFDir

enum GeomMMF Nektar::SpatialDomains::GeomFactors::m_MMFDir

protected

Principle tangent direction for MMF.

Definition at line 136 of file GeomFactors.h.

m_type

GeomType Nektar::SpatialDomains::GeomFactors::m_type

protected

Type of geometry (e.g. eRegular, eDeformed, eMovingRegular).

Definition at line 127 of file GeomFactors.h.

Referenced by CheckIfValid(), ComputeDerivFactors(), ComputeGmat(), ComputeJac(), ComputeMovingFrames(), GetGtype(), and GetHash().

m_valid

bool Nektar::SpatialDomains::GeomFactors::m_valid

protected

Validity of element (Jacobian positive)

Definition at line 133 of file GeomFactors.h.

Referenced by CheckIfValid(), and IsValid().

m_xmap

StdRegions::StdExpansionSharedPtr Nektar::SpatialDomains::GeomFactors::m_xmap

protected

Stores information about the expansion.

Definition at line 139 of file GeomFactors.h.

Referenced by CheckIfValid(), ComputeDeriv(), ComputePrincipleDirection(), GetHash(), and GetXmap().