Nektar::GlobalMapping::MappingXYofXY Class Reference

#include <MappingXYofXY.h>

Inheritance diagram for Nektar::GlobalMapping::MappingXYofXY:

Static Public Member Functions
static GLOBAL_MAPPING_EXPORT MappingSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pMapping)
	Creates an instance of this class. More...
Static Public Member Functions inherited from Nektar::GlobalMapping::Mapping
static GLOBAL_MAPPING_EXPORT MappingSharedPtr	Load (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
	Return a pointer to the mapping, creating it on first call. More...

Static Public Attributes
static std::string	className
	Name of the class. More...

Protected Member Functions
void	CalculateMetricTensor ()
void	CalculateChristoffel ()
	MappingXYofXY (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
GLOBAL_MAPPING_EXPORT void	v_InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pMapping) override
GLOBAL_MAPPING_EXPORT void	v_ContravarToCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
GLOBAL_MAPPING_EXPORT void	v_CovarToCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
GLOBAL_MAPPING_EXPORT void	v_ContravarFromCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
GLOBAL_MAPPING_EXPORT void	v_CovarFromCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
GLOBAL_MAPPING_EXPORT void	v_GetJacobian (Array< OneD, NekDouble > &outarray) override
GLOBAL_MAPPING_EXPORT void	v_GetMetricTensor (Array< OneD, Array< OneD, NekDouble > > &outarray) override
GLOBAL_MAPPING_EXPORT void	v_GetInvMetricTensor (Array< OneD, Array< OneD, NekDouble > > &outarray) override
GLOBAL_MAPPING_EXPORT void	v_ApplyChristoffelContravar (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
GLOBAL_MAPPING_EXPORT void	v_ApplyChristoffelCovar (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
GLOBAL_MAPPING_EXPORT void	v_UpdateGeomInfo () override
Protected Member Functions inherited from Nektar::GlobalMapping::Mapping
GLOBAL_MAPPING_EXPORT	Mapping (const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
	Constructor. More...
GLOBAL_MAPPING_EXPORT void	EvaluateFunction (Array< OneD, MultiRegions::ExpListSharedPtr > pFields, LibUtilities::SessionReaderSharedPtr pSession, std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, NekDouble pTime=NekDouble(0))
GLOBAL_MAPPING_EXPORT void	EvaluateTimeFunction (LibUtilities::SessionReaderSharedPtr pSession, std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, NekDouble pTime=NekDouble(0))
virtual GLOBAL_MAPPING_EXPORT void	v_InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pMapping)
virtual GLOBAL_MAPPING_EXPORT void	v_ContravarToCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)=0
virtual GLOBAL_MAPPING_EXPORT void	v_CovarToCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)=0
virtual GLOBAL_MAPPING_EXPORT void	v_ContravarFromCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)=0
virtual GLOBAL_MAPPING_EXPORT void	v_CovarFromCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)=0
virtual GLOBAL_MAPPING_EXPORT void	v_GetCartesianCoordinates (Array< OneD, NekDouble > &out0, Array< OneD, NekDouble > &out1, Array< OneD, NekDouble > &out2)
virtual GLOBAL_MAPPING_EXPORT void	v_GetCoordVelocity (Array< OneD, Array< OneD, NekDouble > > &outarray)
virtual GLOBAL_MAPPING_EXPORT void	v_GetJacobian (Array< OneD, NekDouble > &outarray)=0
virtual GLOBAL_MAPPING_EXPORT void	v_DotGradJacobian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &outarray)
virtual GLOBAL_MAPPING_EXPORT void	v_GetMetricTensor (Array< OneD, Array< OneD, NekDouble > > &outarray)=0
virtual GLOBAL_MAPPING_EXPORT void	v_GetInvMetricTensor (Array< OneD, Array< OneD, NekDouble > > &outarray)=0
virtual GLOBAL_MAPPING_EXPORT void	v_LowerIndex (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
virtual GLOBAL_MAPPING_EXPORT void	v_RaiseIndex (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
virtual GLOBAL_MAPPING_EXPORT void	v_ApplyChristoffelContravar (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)=0
virtual GLOBAL_MAPPING_EXPORT void	v_ApplyChristoffelCovar (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)=0
virtual GLOBAL_MAPPING_EXPORT void	v_Divergence (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &outarray)
virtual GLOBAL_MAPPING_EXPORT void	v_VelocityLaplacian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble alpha)
virtual GLOBAL_MAPPING_EXPORT void	v_gradgradU (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
virtual GLOBAL_MAPPING_EXPORT void	v_CurlCurlField (Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const bool generalized)
virtual GLOBAL_MAPPING_EXPORT void	v_UpdateMapping (const NekDouble time, const Array< OneD, Array< OneD, NekDouble > > &coords=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &coordsVel=NullNekDoubleArrayOfArray)
virtual GLOBAL_MAPPING_EXPORT void	v_UpdateGeomInfo ()=0
virtual GLOBAL_MAPPING_EXPORT void	v_UpdateBCs (const NekDouble time)

Protected Attributes
Array< OneD, Array< OneD, NekDouble > >	m_metricTensor
Array< OneD, Array< OneD, NekDouble > >	m_Christoffel
Protected Attributes inherited from Nektar::GlobalMapping::Mapping
LibUtilities::SessionReaderSharedPtr	m_session
	Session reader. More...
LibUtilities::FieldIOSharedPtr	m_fld
Array< OneD, MultiRegions::ExpListSharedPtr >	m_fields
Array< OneD, Array< OneD, NekDouble > >	m_coords
	Array with the Cartesian coordinates. More...
Array< OneD, Array< OneD, NekDouble > >	m_coordsVel
	Array with the velocity of the coordinates. More...
Array< OneD, Array< OneD, NekDouble > >	m_GeometricInfo
	Array with metric terms of the mapping. More...
int	m_nConvectiveFields
	Number of velocity components. More...
std::string	m_funcName
	Name of the function containing the coordinates. More...
std::string	m_velFuncName
	Name of the function containing the velocity of the coordinates. More...
bool	m_constantJacobian
	Flag defining if the Jacobian is constant. More...
bool	m_timeDependent
	Flag defining if the Mapping is time-dependent. More...
bool	m_fromFunction
	Flag defining if the Mapping is defined by a function. More...
Array< OneD, Array< OneD, NekDouble > >	m_wk1
Array< OneD, Array< OneD, NekDouble > >	m_wk2
Array< OneD, Array< OneD, NekDouble > >	m_tmp

Friends
class	MemoryManager< MappingXYofXY >

Additional Inherited Members
Public Member Functions inherited from Nektar::GlobalMapping::Mapping
virtual GLOBAL_MAPPING_EXPORT	~Mapping ()
	Destructor. More...
GLOBAL_MAPPING_EXPORT void	InitObject (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const TiXmlElement *pMapping)
	Initialise the mapping object. More...
GLOBAL_MAPPING_EXPORT void	ReplaceField (const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
	Replace the Expansion List used by the mapping. More...
GLOBAL_MAPPING_EXPORT void	Output (LibUtilities::FieldMetaDataMap &fieldMetaDataMap, const std::string &outname)
	Output function called when a chk or fld file is written. More...
GLOBAL_MAPPING_EXPORT void	ContravarToCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Convert a contravariant vector to the Cartesian system. More...
GLOBAL_MAPPING_EXPORT void	CovarToCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Convert a covariant vector to the Cartesian system. More...
GLOBAL_MAPPING_EXPORT void	ContravarFromCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Convert a contravariant vector to the transformed system. More...
GLOBAL_MAPPING_EXPORT void	CovarFromCartesian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Convert a covariant vector to the transformed system. More...
GLOBAL_MAPPING_EXPORT void	GetCartesianCoordinates (Array< OneD, NekDouble > &out0, Array< OneD, NekDouble > &out1, Array< OneD, NekDouble > &out2)
	Get the Cartesian coordinates in the field. More...
GLOBAL_MAPPING_EXPORT void	GetJacobian (Array< OneD, NekDouble > &outarray)
	Get the Jacobian of the transformation. More...
GLOBAL_MAPPING_EXPORT void	DotGradJacobian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &outarray)
	Calculate the dot product with the gradient of the Jacobian. More...
GLOBAL_MAPPING_EXPORT void	GetMetricTensor (Array< OneD, Array< OneD, NekDouble > > &outarray)
	Get the metric tensor \(g_{ij}\). More...
GLOBAL_MAPPING_EXPORT void	GetInvMetricTensor (Array< OneD, Array< OneD, NekDouble > > &outarray)
	Get the inverse of metric tensor \(g^{ij}\). More...
GLOBAL_MAPPING_EXPORT void	LowerIndex (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Lower index of vector: \(v_{i} = g_{ij}*v^{j}\). More...
GLOBAL_MAPPING_EXPORT void	RaiseIndex (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Raise index of vector: \(v^{i} = g^{ij}*v_{j}\). More...
GLOBAL_MAPPING_EXPORT void	ApplyChristoffelContravar (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Apply the Christoffel symbols to a contravariant vector. More...
GLOBAL_MAPPING_EXPORT void	ApplyChristoffelCovar (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Apply the Christoffel symbols to a covariant vector. More...
GLOBAL_MAPPING_EXPORT void	GetCoordVelocity (Array< OneD, Array< OneD, NekDouble > > &outarray)
	Obtain the velocity of the coordinates. More...
GLOBAL_MAPPING_EXPORT void	Divergence (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &outarray)
	Calculate the generalised divergence operator. More...
GLOBAL_MAPPING_EXPORT void	VelocityLaplacian (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble alpha=0.0)
	Generalised (correction to the) velocity Laplacian operator. More...
GLOBAL_MAPPING_EXPORT void	gradgradU (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Second order covariant derivatives of a contravariant vector. More...
GLOBAL_MAPPING_EXPORT void	CurlCurlField (Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const bool generalized)
	CurlCurl calculated on the whole field. More...
GLOBAL_MAPPING_EXPORT bool	IsTimeDependent ()
	Get flag defining if mapping is time-dependent. More...
GLOBAL_MAPPING_EXPORT void	SetTimeDependent (const bool value)
	Set flag defining if mapping is time-dependent. More...
GLOBAL_MAPPING_EXPORT bool	IsFromFunction ()
	Get flag defining if mapping is defined by a function. More...
GLOBAL_MAPPING_EXPORT void	SetFromFunction (const bool value)
	Set flag defining if mapping is defined by a function. More...
GLOBAL_MAPPING_EXPORT bool	HasConstantJacobian ()
	Get flag defining if mapping has constant Jacobian. More...
GLOBAL_MAPPING_EXPORT bool	IsDefined ()
	Get flag determining if the mapping was defined or is trivial. More...
GLOBAL_MAPPING_EXPORT void	UpdateBCs (const NekDouble time)
	Update the Dirichlet Boundary Conditions when using Mappings. More...
GLOBAL_MAPPING_EXPORT void	UpdateMapping (const NekDouble time, const Array< OneD, Array< OneD, NekDouble > > &coords=NullNekDoubleArrayOfArray, const Array< OneD, Array< OneD, NekDouble > > &coordsVel=NullNekDoubleArrayOfArray)
	Update the Mapping with new coordinates. More...
GLOBAL_MAPPING_EXPORT void	UpdateGeomInfo ()
	Recompute the metric terms of the Mapping. More...
Static Protected Attributes inherited from Nektar::GlobalMapping::Mapping
static MappingSharedPtr	m_mappingPtr = MappingSharedPtr()
static bool	m_init = false
static bool	m_isDefined = false

Detailed Description

This class implements a mapping defined by the transformation

\[ \bar{x} = \bar{x}(x,y) \]

\[ \bar{y} = \bar{y}(x,y) \]

\[ \bar{z} = z \]

where \((\bar{x},\bar{y},\bar{z})\) are the Cartesian (physical) coordinates and \((x,y,z)\) are the transformed (computational) coordinates.

Definition at line 49 of file MappingXYofXY.h.

Constructor & Destructor Documentation

MappingXYofXY()

Nektar::GlobalMapping::MappingXYofXY::MappingXYofXY ( const LibUtilities::SessionReaderSharedPtr &  pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields  )

protected

Definition at line 55 of file MappingXYofXY.cpp.

    : Mapping(pSession, pFields)
{
}

Member Function Documentation

CalculateChristoffel()

void Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel ( )

protected

Definition at line 400 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
    int nvel    = m_nConvectiveFields;
 
    Array<OneD, Array<OneD, NekDouble>> G(nvel * nvel);
    Array<OneD, Array<OneD, NekDouble>> G_inv(nvel * nvel);
    Array<OneD, Array<OneD, NekDouble>> gradG(2 * 2 * 2);
    Array<OneD, Array<OneD, NekDouble>> tmp(2 * 2 * 2);
    m_Christoffel = Array<OneD, Array<OneD, NekDouble>>(6);
    // Allocate memory
    for (int i = 0; i < gradG.size(); i++)
    {
        gradG[i] = Array<OneD, NekDouble>(physTot, 0.0);
        tmp[i]   = Array<OneD, NekDouble>(physTot, 0.0);
    }
    for (int i = 0; i < G.size(); i++)
    {
        G[i]     = Array<OneD, NekDouble>(physTot, 0.0);
        G_inv[i] = Array<OneD, NekDouble>(physTot, 0.0);
    }
 
    // Get the metric tensor and its inverse
    GetMetricTensor(G);
    GetInvMetricTensor(G_inv);
 
    bool waveSpace = m_fields[0]->GetWaveSpace();
    m_fields[0]->SetWaveSpace(false);
    // Calculate gradients of g
    //   consider only 2 dimensions, since the 3rd is trivial
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            for (int k = 0; k < 2; k++)
            {
                m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[k],
                                       G[i * nvel + j],
                                       gradG[i * 2 * 2 + j * 2 + k]);
            }
        }
    }
 
    // Calculate tmp[p,j,k] = 1/2( gradG[pj,k]+ gradG[pk,j]-gradG[jk,p])
    for (int p = 0; p < 2; p++)
    {
        for (int j = 0; j < 2; j++)
        {
            for (int k = 0; k < 2; k++)
            {
                Vmath::Vadd(physTot, gradG[p * 2 * 2 + j * 2 + k], 1,
                            gradG[p * 2 * 2 + k * 2 + j], 1,
                            tmp[p * 2 * 2 + j * 2 + k], 1);
                Vmath::Vsub(physTot, tmp[p * 2 * 2 + j * 2 + k], 1,
                            gradG[j * 2 * 2 + k * 2 + p], 1,
                            tmp[p * 2 * 2 + j * 2 + k], 1);
                Vmath::Smul(physTot, 0.5, tmp[p * 2 * 2 + j * 2 + k], 1,
                            tmp[p * 2 * 2 + j * 2 + k], 1);
            }
        }
    }
 
    // Calculate Christoffel symbols = g^ip tmp[p,j,k]
    int n = 0;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            for (int k = 0; k <= j; k++)
            {
                m_Christoffel[n] = Array<OneD, NekDouble>(physTot, 0.0);
                for (int p = 0; p < 2; p++)
                {
                    Vmath::Vvtvp(physTot, G_inv[i * nvel + p], 1,
                                 tmp[p * 2 * 2 + j * 2 + k], 1,
                                 m_Christoffel[n], 1, m_Christoffel[n], 1);
                }
                n = n + 1;
            }
        }
    }
 
    m_fields[0]->SetWaveSpace(waveSpace);
}

References Nektar::MultiRegions::DirCartesianMap, Nektar::GlobalMapping::Mapping::GetInvMetricTensor(), Nektar::GlobalMapping::Mapping::GetMetricTensor(), m_Christoffel, Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, CellMLToNektar.cellml_metadata::p, Vmath::Smul(), Vmath::Vadd(), Vmath::Vsub(), and Vmath::Vvtvp().

Referenced by v_UpdateGeomInfo().

CalculateMetricTensor()

void Nektar::GlobalMapping::MappingXYofXY::CalculateMetricTensor ( )

protected

Definition at line 374 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
    // Allocate memory
    m_metricTensor = Array<OneD, Array<OneD, NekDouble>>(3);
    for (int i = 0; i < m_metricTensor.size(); i++)
    {
        m_metricTensor[i] = Array<OneD, NekDouble>(physTot, 0.0);
    }
    // g_{1,1} = fx^2+gx^2
    Vmath::Vmul(physTot, m_GeometricInfo[0], 1, m_GeometricInfo[0], 1,
                m_metricTensor[0], 1);
    Vmath::Vvtvp(physTot, m_GeometricInfo[2], 1, m_GeometricInfo[2], 1,
                 m_metricTensor[0], 1, m_metricTensor[0], 1);
    // g_{2,2} = fy^2+gy^2
    Vmath::Vmul(physTot, m_GeometricInfo[1], 1, m_GeometricInfo[1], 1,
                m_metricTensor[1], 1);
    Vmath::Vvtvp(physTot, m_GeometricInfo[3], 1, m_GeometricInfo[3], 1,
                 m_metricTensor[1], 1, m_metricTensor[1], 1);
    // g_{1,2} = g_{2,1} = fy*fx+gx*gy
    Vmath::Vmul(physTot, m_GeometricInfo[0], 1, m_GeometricInfo[1], 1,
                m_metricTensor[2], 1);
    Vmath::Vvtvp(physTot, m_GeometricInfo[2], 1, m_GeometricInfo[3], 1,
                 m_metricTensor[2], 1, m_metricTensor[2], 1);
}

References Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_GeometricInfo, m_metricTensor, Vmath::Vmul(), and Vmath::Vvtvp().

Referenced by v_UpdateGeomInfo().

create()

static GLOBAL_MAPPING_EXPORT MappingSharedPtr Nektar::GlobalMapping::MappingXYofXY::create ( const LibUtilities::SessionReaderSharedPtr &  pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields, const TiXmlElement *  pMapping  )

inlinestatic

Creates an instance of this class.

Definition at line 56 of file MappingXYofXY.h.

    {
        MappingSharedPtr p =
            MemoryManager<MappingXYofXY>::AllocateSharedPtr(pSession, pFields);
        p->InitObject(pFields, pMapping);
        return p;
    }

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::GlobalMapping::MappingSharedPtr, and CellMLToNektar.cellml_metadata::p.

v_ApplyChristoffelContravar()

void Nektar::GlobalMapping::MappingXYofXY::v_ApplyChristoffelContravar ( const Array< OneD, Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray  )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 253 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
    int nvel    = m_nConvectiveFields;
 
    for (int i = 0; i < nvel; i++)
    {
        for (int j = 0; j < nvel; j++)
        {
            outarray[i * nvel + j] = Array<OneD, NekDouble>(physTot, 0.0);
        }
    }
 
    // Calculate non-zero terms
 
    // outarray(0,0) = U1 * m_Christoffel[0] + U2 * m_Christoffel[1]
    Vmath::Vmul(physTot, m_Christoffel[0], 1, inarray[0], 1,
                outarray[0 * nvel + 0], 1);
    Vmath::Vvtvp(physTot, m_Christoffel[1], 1, inarray[1], 1,
                 outarray[0 * nvel + 0], 1, outarray[0 * nvel + 0], 1);
 
    // outarray(0,1) = U1 * m_Christoffel[1] + U2 * m_Christoffel[2]
    Vmath::Vmul(physTot, m_Christoffel[1], 1, inarray[0], 1,
                outarray[0 * nvel + 1], 1);
    Vmath::Vvtvp(physTot, m_Christoffel[2], 1, inarray[1], 1,
                 outarray[0 * nvel + 1], 1, outarray[0 * nvel + 1], 1);
 
    // outarray(1,0) = U1 * m_Christoffel[3] + U2 * m_Christoffel[4]
    Vmath::Vmul(physTot, m_Christoffel[3], 1, inarray[0], 1,
                outarray[1 * nvel + 0], 1);
    Vmath::Vvtvp(physTot, m_Christoffel[4], 1, inarray[1], 1,
                 outarray[1 * nvel + 0], 1, outarray[1 * nvel + 0], 1);
 
    // outarray(1,1) = U1 * m_Christoffel[4] + U2 * m_Christoffel[5]
    Vmath::Vmul(physTot, m_Christoffel[4], 1, inarray[0], 1,
                outarray[1 * nvel + 1], 1);
    Vmath::Vvtvp(physTot, m_Christoffel[5], 1, inarray[1], 1,
                 outarray[1 * nvel + 1], 1, outarray[1 * nvel + 1], 1);
}

References m_Christoffel, Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, Vmath::Vmul(), and Vmath::Vvtvp().

v_ApplyChristoffelCovar()

void Nektar::GlobalMapping::MappingXYofXY::v_ApplyChristoffelCovar ( const Array< OneD, Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray  )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 295 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
    int nvel    = m_nConvectiveFields;
 
    for (int i = 0; i < nvel; i++)
    {
        for (int j = 0; j < nvel; j++)
        {
            outarray[i * nvel + j] = Array<OneD, NekDouble>(physTot, 0.0);
        }
    }
 
    // Calculate non-zero terms
 
    // outarray(0,0) = U1 * m_Christoffel[0] + U2 * m_Christoffel[3]
    Vmath::Vmul(physTot, m_Christoffel[0], 1, inarray[0], 1,
                outarray[0 * nvel + 0], 1);
    Vmath::Vvtvp(physTot, m_Christoffel[3], 1, inarray[1], 1,
                 outarray[0 * nvel + 0], 1, outarray[0 * nvel + 0], 1);
 
    // outarray(0,1) = U1 * m_Christoffel[1] + U2 * m_Christoffel[4]
    Vmath::Vmul(physTot, m_Christoffel[1], 1, inarray[0], 1,
                outarray[0 * nvel + 1], 1);
    Vmath::Vvtvp(physTot, m_Christoffel[4], 1, inarray[1], 1,
                 outarray[0 * nvel + 1], 1, outarray[0 * nvel + 1], 1);
 
    // outarray(1,0) = U1 * m_Christoffel[1] + U2 * m_Christoffel[4]
    Vmath::Vmul(physTot, m_Christoffel[1], 1, inarray[0], 1,
                outarray[1 * nvel + 0], 1);
    Vmath::Vvtvp(physTot, m_Christoffel[4], 1, inarray[1], 1,
                 outarray[1 * nvel + 0], 1, outarray[1 * nvel + 0], 1);
 
    // outarray(1,1) = U1 * m_Christoffel[2] + U2 * m_Christoffel[5]
    Vmath::Vmul(physTot, m_Christoffel[2], 1, inarray[0], 1,
                outarray[1 * nvel + 1], 1);
    Vmath::Vvtvp(physTot, m_Christoffel[5], 1, inarray[1], 1,
                 outarray[1 * nvel + 1], 1, outarray[1 * nvel + 1], 1);
}

References m_Christoffel, Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, Vmath::Vmul(), and Vmath::Vvtvp().

v_ContravarFromCartesian()

void Nektar::GlobalMapping::MappingXYofXY::v_ContravarFromCartesian ( const Array< OneD, Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray  )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 126 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
    Array<OneD, NekDouble> wk(physTot, 0.0);
 
    // U1 = [gy*u1-fy*u2]/(fx*gy-gx*fy)
    Vmath::Vmul(physTot, inarray[1], 1, m_GeometricInfo[1], 1, outarray[0], 1);
    Vmath::Vvtvm(physTot, inarray[0], 1, m_GeometricInfo[3], 1, outarray[0], 1,
                 outarray[0], 1);
    Vmath::Vdiv(physTot, outarray[0], 1, m_GeometricInfo[4], 1, outarray[0], 1);
 
    // U2 = [fx*u2-gx*u1]/(fx*gy-gx*fy)
    Vmath::Vmul(physTot, inarray[0], 1, m_GeometricInfo[2], 1, outarray[1], 1);
    Vmath::Vvtvm(physTot, inarray[1], 1, m_GeometricInfo[0], 1, outarray[1], 1,
                 outarray[1], 1);
    Vmath::Vdiv(physTot, outarray[1], 1, m_GeometricInfo[4], 1, outarray[1], 1);
 
    // U3 = u3
    if (m_nConvectiveFields == 3)
    {
        Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
    }
}

References Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_GeometricInfo, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, Vmath::Vcopy(), Vmath::Vdiv(), Vmath::Vmul(), and Vmath::Vvtvm().

v_ContravarToCartesian()

void Nektar::GlobalMapping::MappingXYofXY::v_ContravarToCartesian ( const Array< OneD, Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray  )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 77 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
 
    // U1 = fx*u1 + fy*u2
    Vmath::Vmul(physTot, m_GeometricInfo[0], 1, inarray[0], 1, outarray[0], 1);
    Vmath::Vvtvp(physTot, m_GeometricInfo[1], 1, inarray[1], 1, outarray[0], 1,
                 outarray[0], 1);
 
    // U2 = gx*u1+gy*u2
    Vmath::Vmul(physTot, m_GeometricInfo[2], 1, inarray[0], 1, outarray[1], 1);
    Vmath::Vvtvp(physTot, m_GeometricInfo[3], 1, inarray[1], 1, outarray[1], 1,
                 outarray[1], 1);
 
    // U3 = u3
    if (m_nConvectiveFields == 3)
    {
        Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
    }
}

References Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_GeometricInfo, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vvtvp().

v_CovarFromCartesian()

void Nektar::GlobalMapping::MappingXYofXY::v_CovarFromCartesian ( const Array< OneD, Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray  )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 152 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
 
    // U1 = u1*fx +gx*u2
    Vmath::Vmul(physTot, m_GeometricInfo[0], 1, inarray[0], 1, outarray[0], 1);
    Vmath::Vvtvp(physTot, m_GeometricInfo[2], 1, inarray[1], 1, outarray[0], 1,
                 outarray[0], 1);
 
    // U2 = fy*u1 + gy*u2
    Vmath::Vmul(physTot, m_GeometricInfo[1], 1, inarray[0], 1, outarray[1], 1);
    Vmath::Vvtvp(physTot, m_GeometricInfo[3], 1, inarray[1], 1, outarray[1], 1,
                 outarray[1], 1);
 
    // U3 = u3
    if (m_nConvectiveFields == 3)
    {
        Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
    }
}

References Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_GeometricInfo, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vvtvp().

v_CovarToCartesian()

void Nektar::GlobalMapping::MappingXYofXY::v_CovarToCartesian ( const Array< OneD, Array< OneD, NekDouble > > &  inarray, Array< OneD, Array< OneD, NekDouble > > &  outarray  )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 100 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
    Array<OneD, NekDouble> wk(physTot, 0.0);
 
    // U1 = [gy*u1-gx*u2]/(fx*gy-gx*fy)
    Vmath::Vmul(physTot, inarray[1], 1, m_GeometricInfo[2], 1, outarray[0], 1);
    Vmath::Vvtvm(physTot, inarray[0], 1, m_GeometricInfo[3], 1, outarray[0], 1,
                 outarray[0], 1);
    Vmath::Vdiv(physTot, outarray[0], 1, m_GeometricInfo[4], 1, outarray[0], 1);
 
    // U2 = [fx*u2 - fy*u1]/(fx*gy-gx*fy)
    Vmath::Vmul(physTot, inarray[0], 1, m_GeometricInfo[1], 1, outarray[1], 1);
    Vmath::Vvtvm(physTot, inarray[1], 1, m_GeometricInfo[0], 1, outarray[1], 1,
                 outarray[1], 1);
    Vmath::Vdiv(physTot, outarray[1], 1, m_GeometricInfo[4], 1, outarray[1], 1);
 
    // U3 = u3
    if (m_nConvectiveFields == 3)
    {
        Vmath::Vcopy(physTot, inarray[2], 1, outarray[2], 1);
    }
}

References Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_GeometricInfo, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, Vmath::Vcopy(), Vmath::Vdiv(), Vmath::Vmul(), and Vmath::Vvtvm().

v_GetInvMetricTensor()

void Nektar::GlobalMapping::MappingXYofXY::v_GetInvMetricTensor ( Array< OneD, Array< OneD, NekDouble > > &  outarray )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 210 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
    int nvel    = m_nConvectiveFields;
 
    for (int i = 0; i < nvel * nvel; i++)
    {
        outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
    }
 
    // Get Jacobian
    Array<OneD, NekDouble> Jac(physTot, 0.0);
    GetJacobian(Jac);
 
    // Get Jacobian squared
    Array<OneD, NekDouble> wk(physTot, 0.0);
    Vmath::Vmul(physTot, Jac, 1, Jac, 1, wk, 1);
    // G^{1,1} = m_metricTensor[1]/Jac^2
    Vmath::Vcopy(physTot, m_metricTensor[1], 1, outarray[0 * nvel + 0], 1);
    Vmath::Vdiv(physTot, outarray[0 * nvel + 0], 1, wk, 1,
                outarray[0 * nvel + 0], 1);
 
    // G^{2,2} = m_metricTensor[0]/Jac^2
    Vmath::Vcopy(physTot, m_metricTensor[0], 1, outarray[1 * nvel + 1], 1);
    Vmath::Vdiv(physTot, outarray[1 * nvel + 1], 1, wk, 1,
                outarray[1 * nvel + 1], 1);
 
    // G^{1,2} = G^{2,1} = -m_metricTensor[2]/Jac^2
    Vmath::Vcopy(physTot, m_metricTensor[2], 1, outarray[0 * nvel + 1], 1);
    Vmath::Neg(physTot, outarray[0 * nvel + 1], 1);
    Vmath::Vdiv(physTot, outarray[0 * nvel + 1], 1, wk, 1,
                outarray[0 * nvel + 1], 1);
    Vmath::Vcopy(physTot, outarray[0 * nvel + 1], 1, outarray[1 * nvel + 0], 1);
 
    // G^{3,3}  = 1
    if (m_nConvectiveFields == 3)
    {
        Vmath::Sadd(physTot, 1.0, outarray[2 * nvel + 2], 1,
                    outarray[2 * nvel + 2], 1);
    }
}

References Nektar::GlobalMapping::Mapping::GetJacobian(), Nektar::GlobalMapping::Mapping::m_fields, m_metricTensor, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, Vmath::Neg(), Vmath::Sadd(), Vmath::Vcopy(), Vmath::Vdiv(), and Vmath::Vmul().

v_GetJacobian()

void Nektar::GlobalMapping::MappingXYofXY::v_GetJacobian ( Array< OneD, NekDouble > &  outarray )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 175 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
    Vmath::Vabs(physTot, m_GeometricInfo[4], 1, outarray, 1);
}

References Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_GeometricInfo, and Vmath::Vabs().

v_GetMetricTensor()

void Nektar::GlobalMapping::MappingXYofXY::v_GetMetricTensor ( Array< OneD, Array< OneD, NekDouble > > &  outarray )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 181 of file MappingXYofXY.cpp.

{
    int physTot = m_fields[0]->GetTotPoints();
    int nvel    = m_nConvectiveFields;
 
    for (int i = 0; i < nvel * nvel; i++)
    {
        outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
    }
 
    // g_{1,1} = m_metricTensor[0]
    Vmath::Vcopy(physTot, m_metricTensor[0], 1, outarray[0 * nvel + 0], 1);
 
    // g_{2,2} = m_metricTensor[1]
    Vmath::Vcopy(physTot, m_metricTensor[1], 1, outarray[1 * nvel + 1], 1);
 
    // g_{1,2}=g{2,1} = m_metricTensor[2]
    Vmath::Vcopy(physTot, m_metricTensor[2], 1, outarray[0 * nvel + 1], 1);
    Vmath::Vcopy(physTot, m_metricTensor[2], 1, outarray[1 * nvel + 0], 1);
 
    // g_{3,3}  = 1
    if (m_nConvectiveFields == 3)
    {
        Vmath::Sadd(physTot, 1.0, outarray[2 * nvel + 2], 1,
                    outarray[2 * nvel + 2], 1);
    }
}

References Nektar::GlobalMapping::Mapping::m_fields, m_metricTensor, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, Vmath::Sadd(), and Vmath::Vcopy().

v_InitObject()

void Nektar::GlobalMapping::MappingXYofXY::v_InitObject ( const Array< OneD, MultiRegions::ExpListSharedPtr > &  pFields, const TiXmlElement *  pMapping  )

overrideprotectedvirtual

This function initialises the Mapping object. It computes the coordinates and velocity coordinates, initialises the workspace variables, and calls UpdateGeomInfo, which will perform the calculations specific for each type of Mapping.

Parameters

pFields	ExpList array used in the mapping
pMapping	xml element describing the mapping

Reimplemented from Nektar::GlobalMapping::Mapping.

Definition at line 65 of file MappingXYofXY.cpp.

{
    Mapping::v_InitObject(pFields, pMapping);
 
    m_constantJacobian = false;
 
    ASSERTL0(m_nConvectiveFields >= 2,
             "Mapping X = X(x,y), Y = Y(x,y) needs 2 velocity components.");
}

References ASSERTL0, Nektar::GlobalMapping::Mapping::m_constantJacobian, Nektar::GlobalMapping::Mapping::m_nConvectiveFields, and Nektar::GlobalMapping::Mapping::v_InitObject().

v_UpdateGeomInfo()

void Nektar::GlobalMapping::MappingXYofXY::v_UpdateGeomInfo ( )

overrideprotectedvirtual

Implements Nektar::GlobalMapping::Mapping.

Definition at line 337 of file MappingXYofXY.cpp.

{
    int phystot = m_fields[0]->GetTotPoints();
    // Allocation of geometry memory
    m_GeometricInfo = Array<OneD, Array<OneD, NekDouble>>(5);
    for (int i = 0; i < m_GeometricInfo.size(); i++)
    {
        m_GeometricInfo[i] = Array<OneD, NekDouble>(phystot, 0.0);
    }
 
    bool waveSpace = m_fields[0]->GetWaveSpace();
    m_fields[0]->SetWaveSpace(false);
 
    // Calculate derivatives of x transformation --> m_GeometricInfo 0-1
    m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], m_coords[0],
                           m_GeometricInfo[0]);
    m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], m_coords[0],
                           m_GeometricInfo[1]);
 
    // Calculate derivatives of y transformation m_GeometricInfo 2-3
    m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], m_coords[1],
                           m_GeometricInfo[2]);
    m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], m_coords[1],
                           m_GeometricInfo[3]);
 
    // Calculate fx*gy-gx*fy --> m_GeometricInfo4
    Vmath::Vmul(phystot, m_GeometricInfo[1], 1, m_GeometricInfo[2], 1,
                m_GeometricInfo[4], 1);
    Vmath::Vvtvm(phystot, m_GeometricInfo[0], 1, m_GeometricInfo[3], 1,
                 m_GeometricInfo[4], 1, m_GeometricInfo[4], 1);
    //
    CalculateMetricTensor();
    CalculateChristoffel();
 
    m_fields[0]->SetWaveSpace(waveSpace);
}

References CalculateChristoffel(), CalculateMetricTensor(), Nektar::MultiRegions::DirCartesianMap, Nektar::GlobalMapping::Mapping::m_coords, Nektar::GlobalMapping::Mapping::m_fields, Nektar::GlobalMapping::Mapping::m_GeometricInfo, Vmath::Vmul(), and Vmath::Vvtvm().

Friends And Related Function Documentation

MemoryManager< MappingXYofXY >

friend class MemoryManager< MappingXYofXY >

friend

Definition at line 1 of file MappingXYofXY.h.

Member Data Documentation

className

std::string Nektar::GlobalMapping::MappingXYofXY::className

static

Initial value:

=
    GetMappingFactory().RegisterCreatorFunction("XYofXY", MappingXYofXY::create,
                                                "X = X(x,y), Y = Y(x,y)")

Name of the class.

Definition at line 68 of file MappingXYofXY.h.

m_Christoffel

Array<OneD, Array<OneD, NekDouble> > Nektar::GlobalMapping::MappingXYofXY::m_Christoffel

protected

Definition at line 78 of file MappingXYofXY.h.

Referenced by CalculateChristoffel(), v_ApplyChristoffelContravar(), and v_ApplyChristoffelCovar().

m_metricTensor

Array<OneD, Array<OneD, NekDouble> > Nektar::GlobalMapping::MappingXYofXY::m_metricTensor

protected

Definition at line 77 of file MappingXYofXY.h.

Referenced by CalculateMetricTensor(), v_GetInvMetricTensor(), and v_GetMetricTensor().