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 75 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 88 of file GeomFactors.cpp.

References CheckIfValid().

                                                                    :
            m_type(gtype),
            m_expDim(xmap->GetShapeDimension()),
            m_coordDim(coordim),
            m_valid(true),
            m_xmap(xmap),
            m_coords(coords)
        {
            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 108 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 122 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 716 of file GeomFactors.cpp.

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

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

        {
            ASSERTL1(src.num_elements() == tgt.num_elements(),
                     "Source matrix is of different size to destination"
                     "matrix for computing adjoint.");

            int n = src[0].num_elements();
            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;
                }
            }
        }

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 608 of file GeomFactors.cpp.

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().

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

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 169 of file GeomFactors.cpp.

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

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

        {
            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 we 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;
        }

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.

Definition at line 397 of file GeomFactors.cpp.

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

Referenced by GetDerivFactors().

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

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"

Returns

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

Definition at line 332 of file GeomFactors.cpp.

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

Referenced by GetGmat().

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

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 252 of file GeomFactors.cpp.

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

Referenced by GetJac(), and Nektar::SpatialDomains::operator==().

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

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 475 of file GeomFactors.cpp.

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

Referenced by GetMovingFrames().

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

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 764 of file GeomFactors.cpp.

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

Referenced by ComputeMovingFrames().

        {
            int nq = output[0].num_elements();

            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.num_elements() >= 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;
                }
            }
        }

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 328 of file GeomFactors.h.

References m_coordDim.

    {
        return 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 232 of file GeomFactors.h.

References ComputeDeriv().

Referenced by CheckIfValid().

    {
        return ComputeDeriv(tpoints);
    }

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 286 of file GeomFactors.h.

References ComputeDerivFactors(), and m_derivFactorCache.

    {
        auto x = m_derivFactorCache.find(keyTgt);

        if (x != m_derivFactorCache.end())
        {
            return x->second;
        }

        m_derivFactorCache[keyTgt] = ComputeDerivFactors(keyTgt);

        return m_derivFactorCache[keyTgt];

    }

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 270 of file GeomFactors.h.

References ComputeGmat().

    {
        return ComputeGmat(keyTgt);
    }

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 318 of file GeomFactors.h.

References m_type.

    {
        return 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 348 of file GeomFactors.h.

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

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

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 248 of file GeomFactors.h.

References ComputeJac(), and m_jacCache.

Referenced by GetHash().

    {
        auto x = m_jacCache.find(keyTgt);

        if (x != m_jacCache.end())
        {
            return x->second;
        }

        m_jacCache[keyTgt] = ComputeJac(keyTgt);

        return m_jacCache[keyTgt];

    }

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 302 of file GeomFactors.h.

References ComputeMovingFrames().

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

GetXmap()

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

inlineprotected

Return the Xmap;.

Definition at line 366 of file GeomFactors.h.

References m_xmap.

    {
        return 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 679 of file GeomFactors.cpp.

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

Referenced by ComputeDeriv(), and ComputePrincipleDirection().

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

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 338 of file GeomFactors.h.

References m_valid.

    {
        return 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 976 of file GeomFactors.cpp.

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

Referenced by ComputeMovingFrames().

        {
            ASSERTL0(v1.num_elements() == 3,
                     "Input 1 has dimension not equal to 3.");
            ASSERTL0(v2.num_elements() == 3,
                     "Input 2 has dimension not equal to 3.");
            ASSERTL0(v3.num_elements() == 3,
                     "Output vector has dimension not equal to 3.");

            int nq = v1[0].num_elements();
            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);
        }

VectorNormalise()

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

private

Definition at line 934 of file GeomFactors.cpp.

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

Referenced by ComputeMovingFrames().

        {
            int ndim = array.num_elements();
            ASSERTL0(ndim > 0, "Number of components must be > 0.");
            for (int i = 1; i < ndim; ++i)
            {
                ASSERTL0(array[i].num_elements() == array[0].num_elements(),
                         "Array size mismatch in coordinates.");
            }

            int nq        = array[0].num_elements();
            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);
            }
        }

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 131 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 139 of file GeomFactors.h.

Referenced by CheckIfValid(), ComputeDeriv(), ComputeDerivFactors(), ComputeGmat(), ComputeJac(), ComputeMovingFrames(), ComputePrincipleDirection(), GetCoordim(), GetHash(), and Nektar::SpatialDomains::operator==().

m_coords

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

protected

Stores coordinates of the geometry.

Definition at line 149 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 155 of file GeomFactors.h.

Referenced by GetDerivFactors().

m_expDim

int Nektar::SpatialDomains::GeomFactors::m_expDim

protected

Dimension of expansion.

Definition at line 137 of file GeomFactors.h.

Referenced by Adjoint(), CheckIfValid(), ComputeDeriv(), ComputeDerivFactors(), ComputeGmat(), ComputeJac(), ComputeMovingFrames(), ComputePrincipleDirection(), GetHash(), Interp(), and Nektar::SpatialDomains::operator==().

m_jacCache

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

protected

Jacobian vector cache.

Definition at line 152 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 144 of file GeomFactors.h.

m_type

GeomType Nektar::SpatialDomains::GeomFactors::m_type

protected

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

Definition at line 135 of file GeomFactors.h.

Referenced by CheckIfValid(), ComputeDerivFactors(), ComputeGmat(), ComputeJac(), ComputeMovingFrames(), GetGtype(), GetHash(), and Nektar::SpatialDomains::operator==().

m_valid

bool Nektar::SpatialDomains::GeomFactors::m_valid

protected

Validity of element (Jacobian positive)

Definition at line 141 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 147 of file GeomFactors.h.

Referenced by CheckIfValid(), ComputeDeriv(), ComputePrincipleDirection(), GetHash(), GetXmap(), and Nektar::SpatialDomains::operator==().