Base class for mapping to be applied to the coordinate system. More...

#include <Mapping.h>

Inheritance diagram for Nektar::GlobalMapping::Mapping:

Public Member Functions
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 Public Member Functions
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...

Protected Member Functions
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
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

Static Protected Attributes
static MappingSharedPtr	m_mappingPtr = MappingSharedPtr()

static bool	m_init = false

static bool	m_isDefined = false

Detailed Description

Base class for mapping to be applied to the coordinate system.

Definition at line 68 of file Mapping.h.

Constructor & Destructor Documentation

◆ ~Mapping()

virtual GLOBAL_MAPPING_EXPORT Nektar::GlobalMapping::Mapping::~Mapping ( )

inlinevirtual

Destructor.

Definition at line 72 of file Mapping.h.

73 {

74 }

◆ Mapping()

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

protected

Constructor.

Definition at line 59 of file Mapping.cpp.

     : m_session(pSession), m_fields(pFields)
 {
     switch (m_fields[0]->GetExpType())
     {
         case MultiRegions::e1D:
         {
             m_nConvectiveFields = 1;
         }
         break;
  
         case MultiRegions::e2D:
         {
             m_nConvectiveFields = 2;
         }
         break;
  
         case MultiRegions::e3D:
         case MultiRegions::e3DH1D:
         case MultiRegions::e3DH2D:
         {
             m_nConvectiveFields = 3;
         }
         break;
  
         default:
             ASSERTL0(0, "Dimension not supported");
             break;
     }
  
     m_fld = LibUtilities::FieldIO::CreateDefault(pSession);
 }

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::MultiRegions::e1D, Nektar::MultiRegions::e2D, Nektar::MultiRegions::e3D, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, m_fields, m_fld, and m_nConvectiveFields.

Member Function Documentation

◆ ApplyChristoffelContravar()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::ApplyChristoffelContravar	(	const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray
	)

inline

Apply the Christoffel symbols to a contravariant vector.

This function is used apply the Christoffel symbols \( \left( i,pk\right)\) to a contravariant vector \(u^p\), following the relation

\[ (out)^{i}_{k} = \left( i,pk\right)u^p \]

Parameters

inarray	Contravariant vector \(u^p\)
outarray	Result of applying Christoffel symbols to \(u^p\)

Definition at line 211 of file Mapping.h.

     {
         v_ApplyChristoffelContravar(inarray, outarray);
     }

References v_ApplyChristoffelContravar().

Referenced by v_gradgradU(), and v_VelocityLaplacian().

◆ ApplyChristoffelCovar()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::ApplyChristoffelCovar	(	const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray
	)

inline

Apply the Christoffel symbols to a covariant vector.

This function is used apply the Christoffel symbols \( \left( p,ik\right)\) to a covariant vector \(u_p\), following the relation

\[ (out)_{ik} = \left( p,ik\right)u_p \]

Parameters

inarray	Contravariant vector \(u_p\)
outarray	Result of applying Christoffel symbols to \(u_p\)

Definition at line 229 of file Mapping.h.

     {
         v_ApplyChristoffelCovar(inarray, outarray);
     }

References v_ApplyChristoffelCovar().

Referenced by v_gradgradU().

◆ ContravarFromCartesian()

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

Convert a contravariant vector to the transformed system.

This function converts a contravariant vector in Cartesian space \(\bar{v}^{i}\) to the corresponding \(v^{j}\) in transformed space using the relation

\[v^{j} = \frac{\partial x^j}{\partial \bar{x}^i}\bar{v}^{i}\]

Parameters

inarray	Components of the vector in Cartesian space ( \(\bar{v}^{i}\))
outarray	Components of the vector in transformed space ( \(v^{j}\))

Definition at line 543 of file Mapping.cpp.

 {
     if (inarray == outarray)
     {
         int physTot = m_fields[0]->GetTotPoints();
         int nvel    = m_nConvectiveFields;
  
         for (int i = 0; i < nvel; i++)
         {
             Vmath::Vcopy(physTot, inarray[i], 1, m_tmp[i], 1);
         }
         v_ContravarFromCartesian(m_tmp, outarray);
     }
     else
     {
         v_ContravarFromCartesian(inarray, outarray);
     }
 }

References m_fields, m_nConvectiveFields, m_tmp, v_ContravarFromCartesian(), and Vmath::Vcopy().

Referenced by v_UpdateBCs().

◆ ContravarToCartesian()

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

Convert a contravariant vector to the Cartesian system.

This function converts a contravariant vector in transformed space \(v^{j}\) to the corresponding \(\bar{v}^{i}\) in Cartesian (physical) space using the relation

\[\bar{v}^{i} = \frac{\partial \bar{x}^i}{\partial x^j}v^{j}\]

Parameters

inarray	Components of the vector in transformed space ( \(v^{j}\))
outarray	Components of the vector in Cartesian space ( \(\bar{v}^{i}\))

Definition at line 481 of file Mapping.cpp.

 {
     if (inarray == outarray)
     {
         int physTot = m_fields[0]->GetTotPoints();
         int nvel    = m_nConvectiveFields;
  
         for (int i = 0; i < nvel; i++)
         {
             Vmath::Vcopy(physTot, inarray[i], 1, m_tmp[i], 1);
         }
         v_ContravarToCartesian(m_tmp, outarray);
     }
     else
     {
         v_ContravarToCartesian(inarray, outarray);
     }
 }

References m_fields, m_nConvectiveFields, m_tmp, v_ContravarToCartesian(), and Vmath::Vcopy().

◆ CovarFromCartesian()

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

Convert a covariant vector to the transformed system.

This function converts a covariant vector in Cartesian space \(\bar{v}_{i}\) to the corresponding \(v_{j}\) in transformed space using the relation

\[\bar{v}_{j} = \frac{\partial \bar{x}^i}{\partial x^j}v_{i}\]

Parameters

inarray	Components of the vector in Cartesian space ( \(\bar{v}_{i}\))
outarray	Components of the vector in transformed space ( \(v_{j}\))

Definition at line 574 of file Mapping.cpp.

 {
     if (inarray == outarray)
     {
         int physTot = m_fields[0]->GetTotPoints();
         int nvel    = m_nConvectiveFields;
  
         for (int i = 0; i < nvel; i++)
         {
             Vmath::Vcopy(physTot, inarray[i], 1, m_tmp[i], 1);
         }
         v_CovarFromCartesian(m_tmp, outarray);
     }
     else
     {
         v_CovarFromCartesian(inarray, outarray);
     }
 }

References m_fields, m_nConvectiveFields, m_tmp, v_CovarFromCartesian(), and Vmath::Vcopy().

◆ CovarToCartesian()

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

Convert a covariant vector to the Cartesian system.

This function converts a covariant vector in transformed space \(v_{j}\) to the corresponding \(\bar{v}_{i}\) in Cartesian (physical) space using the relation

\[\bar{v}_{i} = \frac{\partial x^j}{\partial \bar{x}^i}v_{j}\]

Parameters

inarray	Components of the vector in transformed space ( \(v_{j}\))
outarray	Components of the vector in Cartesian space ( \(\bar{v}_{i}\))

Definition at line 512 of file Mapping.cpp.

 {
     if (inarray == outarray)
     {
         int physTot = m_fields[0]->GetTotPoints();
         int nvel    = m_nConvectiveFields;
  
         for (int i = 0; i < nvel; i++)
         {
             Vmath::Vcopy(physTot, inarray[i], 1, m_tmp[i], 1);
         }
         v_CovarToCartesian(m_tmp, outarray);
     }
     else
     {
         v_CovarToCartesian(inarray, outarray);
     }
 }

References m_fields, m_nConvectiveFields, m_tmp, v_CovarToCartesian(), and Vmath::Vcopy().

◆ CurlCurlField()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::CurlCurlField	(	Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const bool	generalized
	)

inline

CurlCurl calculated on the whole field.

This function can be used to compute both the generalised CurlCurl or the typical (Cartesian) CurlCurl, depending on the flag generalized

Parameters

inarray	Contravariant vector \(u^i\)
outarray	CurlCurl of \(u\)
generalized	Flag defining if generalised or typical CurlCurl

Definition at line 324 of file Mapping.h.

     {
         v_CurlCurlField(inarray, outarray, generalized);
     }

References v_CurlCurlField().

◆ Divergence()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::Divergence	(	const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

Calculate the generalised divergence operator.

This function is used to calculate the generalised divergence of a contravariant vector, defined as

\[ D = u^i_{,i} = \frac{1}{J}\frac{\partial(Ju^i)}{\partial x^i}\]

Parameters

inarray	Contravariant vector \(u^i\)
outarray	Divergence of \(u^i\)

Definition at line 266 of file Mapping.h.

     {
         v_Divergence(inarray, outarray);
     }

References v_Divergence().

◆ DotGradJacobian()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::DotGradJacobian	(	const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, NekDouble > &	outarray
	)

inline

Calculate the dot product with the gradient of the Jacobian.

This function calculates the dot product of an array against the gradient of the Jacobian of the Mapping.

Parameters

inarray	Input array
outarray	Output array

Definition at line 169 of file Mapping.h.

     {
         v_DotGradJacobian(inarray, outarray);
     }

References v_DotGradJacobian().

◆ EvaluateFunction()

void Nektar::GlobalMapping::Mapping::EvaluateFunction	(	Array< OneD, MultiRegions::ExpListSharedPtr >	pFields,
		LibUtilities::SessionReaderSharedPtr	pSession,
		std::string	pFieldName,
		Array< OneD, NekDouble > &	pArray,
		const std::string &	pFunctionName,
		NekDouble	pTime = `NekDouble(0)`
	)

protected

Definition at line 402 of file Mapping.cpp.

 {
     ASSERTL0(pSession->DefinesFunction(pFunctionName),
              "Function '" + pFunctionName + "' does not exist.");
  
     unsigned int nq = pFields[0]->GetNpoints();
     if (pArray.size() != nq)
     {
         pArray = Array<OneD, NekDouble>(nq);
     }
  
     LibUtilities::FunctionType vType;
     vType = pSession->GetFunctionType(pFunctionName, pFieldName);
     if (vType == LibUtilities::eFunctionTypeExpression)
     {
         Array<OneD, NekDouble> x0(nq);
         Array<OneD, NekDouble> x1(nq);
         Array<OneD, NekDouble> x2(nq);
  
         pFields[0]->GetCoords(x0, x1, x2);
         LibUtilities::EquationSharedPtr ffunc =
             pSession->GetFunction(pFunctionName, pFieldName);
  
         ffunc->Evaluate(x0, x1, x2, pTime, pArray);
     }
     else if (vType == LibUtilities::eFunctionTypeFile)
     {
         std::string filename =
             pSession->GetFunctionFilename(pFunctionName, pFieldName);
  
         std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
         std::vector<std::vector<NekDouble>> FieldData;
         Array<OneD, NekDouble> vCoeffs(pFields[0]->GetNcoeffs());
         Vmath::Zero(vCoeffs.size(), vCoeffs, 1);
  
         LibUtilities::FieldIOSharedPtr fld =
             LibUtilities::FieldIO::CreateForFile(pSession, filename);
         fld->Import(filename, FieldDef, FieldData);
  
         int idx = -1;
         for (int i = 0; i < FieldDef.size(); ++i)
         {
             for (int j = 0; j < FieldDef[i]->m_fields.size(); ++j)
             {
                 if (FieldDef[i]->m_fields[j] == pFieldName)
                 {
                     idx = j;
                 }
             }
  
             if (idx >= 0)
             {
                 pFields[0]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                                 FieldDef[i]->m_fields[idx],
                                                 vCoeffs);
             }
             else
             {
                 cout << "Field " + pFieldName + " not found." << endl;
             }
         }
         pFields[0]->BwdTrans(vCoeffs, pArray);
     }
 }

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, m_fields, and Vmath::Zero().

Referenced by v_InitObject(), and v_UpdateMapping().

◆ EvaluateTimeFunction()

void Nektar::GlobalMapping::Mapping::EvaluateTimeFunction	(	LibUtilities::SessionReaderSharedPtr	pSession,
		std::string	pFieldName,
		Array< OneD, NekDouble > &	pArray,
		const std::string &	pFunctionName,
		NekDouble	pTime = `NekDouble(0)`
	)

protected

Definition at line 384 of file Mapping.cpp.

 {
     ASSERTL0(pSession->DefinesFunction(pFunctionName),
              "Function '" + pFunctionName + "' does not exist.");
  
     LibUtilities::EquationSharedPtr ffunc =
         pSession->GetFunction(pFunctionName, pFieldName);
  
     Array<OneD, NekDouble> x0(1, 0.0);
     Array<OneD, NekDouble> x1(1, 0.0);
     Array<OneD, NekDouble> x2(1, 0.0);
  
     ffunc->Evaluate(x0, x1, x2, pTime, pArray);
 }

References ASSERTL0.

◆ GetCartesianCoordinates()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::GetCartesianCoordinates	(	Array< OneD, NekDouble > &	out0,
		Array< OneD, NekDouble > &	out1,
		Array< OneD, NekDouble > &	out2
	)

inline

Get the Cartesian coordinates in the field.

This function is used to obtain the Cartesian coordinates associated withthe Mapping

Parameters

out0	Coordinates in the x-direction
out1	Coordinates in the y-direction
out2	Coordinates in the z-direction

Definition at line 135 of file Mapping.h.

     {
         v_GetCartesianCoordinates(out0, out1, out2);
     }

References v_GetCartesianCoordinates().

Referenced by v_UpdateBCs().

◆ GetCoordVelocity()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::GetCoordVelocity ( Array< OneD, Array< OneD, NekDouble >> & outarray )

inline

Obtain the velocity of the coordinates.

This function is used to obtain the velocity of the coordinates associated with the Mapping

Parameters

outarray Velocity of the coordinates

Definition at line 244 of file Mapping.h.

     {
         v_GetCoordVelocity(outarray);
     }

References v_GetCoordVelocity().

Referenced by v_UpdateBCs().

◆ GetInvMetricTensor()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::GetInvMetricTensor ( Array< OneD, Array< OneD, NekDouble >> & outarray )

inline

Get the inverse of metric tensor \(g^{ij}\).

Definition at line 184 of file Mapping.h.

     {
         v_GetInvMetricTensor(outarray);
     }

References v_GetInvMetricTensor().

Referenced by Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel(), and v_RaiseIndex().

◆ GetJacobian()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::GetJacobian ( Array< OneD, NekDouble > & outarray )

inline

Get the Jacobian of the transformation.

This function is used to obtain the Jacobian of the Mapping.

Parameters

outarray Array containing the Jacobian

Definition at line 155 of file Mapping.h.

     {
         v_GetJacobian(outarray);
     }

References v_GetJacobian().

Referenced by v_Divergence(), v_DotGradJacobian(), and Nektar::GlobalMapping::MappingXYofXY::v_GetInvMetricTensor().

◆ GetMetricTensor()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::GetMetricTensor ( Array< OneD, Array< OneD, NekDouble >> & outarray )

inline

Get the metric tensor \(g_{ij}\).

Definition at line 177 of file Mapping.h.

     {
         v_GetMetricTensor(outarray);
     }

References v_GetMetricTensor().

Referenced by Nektar::GlobalMapping::MappingXYofXY::CalculateChristoffel(), and v_LowerIndex().

◆ gradgradU()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::gradgradU	(	const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray
	)

inline

Second order covariant derivatives of a contravariant vector.

This function computes the second order covariant derivatives of a contravariant vector, resulting in \(u^{i}_{,jk}\)

Parameters

inarray	Contravariant vector \(u^i\)
outarray	Second order derivatives \(u^{i}_{,jk}\)

Definition at line 306 of file Mapping.h.

     {
         v_gradgradU(inarray, outarray);
     }

References v_gradgradU().

Referenced by v_CurlCurlField().

◆ HasConstantJacobian()

GLOBAL_MAPPING_EXPORT bool Nektar::GlobalMapping::Mapping::HasConstantJacobian ( )

inline

Get flag defining if mapping has constant Jacobian.

Definition at line 362 of file Mapping.h.

     {
         return m_constantJacobian;
     }

References m_constantJacobian.

Referenced by v_DotGradJacobian().

◆ InitObject()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::InitObject	(	const Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const TiXmlElement *	pMapping
	)

inline

Initialise the mapping object.

Definition at line 77 of file Mapping.h.

     {
         v_InitObject(pFields, pMapping);
     }

References v_InitObject().

Referenced by ReplaceField().

◆ IsDefined()

GLOBAL_MAPPING_EXPORT bool Nektar::GlobalMapping::Mapping::IsDefined ( )

inline

Get flag determining if the mapping was defined or is trivial.

Definition at line 368 of file Mapping.h.

     {
         return m_isDefined;
     }

References m_isDefined.

◆ IsFromFunction()

GLOBAL_MAPPING_EXPORT bool Nektar::GlobalMapping::Mapping::IsFromFunction ( )

inline

Get flag defining if mapping is defined by a function.

Definition at line 350 of file Mapping.h.

     {
         return m_fromFunction;
     }

References m_fromFunction.

◆ IsTimeDependent()

GLOBAL_MAPPING_EXPORT bool Nektar::GlobalMapping::Mapping::IsTimeDependent ( void )

inline

Get flag defining if mapping is time-dependent.

Definition at line 338 of file Mapping.h.

     {
         return m_timeDependent;
     }

References m_timeDependent.

Referenced by v_UpdateBCs().

◆ Load()

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

static

Return a pointer to the mapping, creating it on first call.

This function is responsible for loading the Mapping, guaranteeing that a single instance of this class exists. When it is first called, it creates a Mapping and returns a pointer to it. On subsequent calls, it just returns the pointer.

Parameters

pSession	Session reader object
pFields	Fields which will be used by the Mapping

Returns: Pointer to the Mapping

Definition at line 270 of file Mapping.cpp.

 {
     if (!m_init)
     {
         TiXmlElement *vMapping = NULL;
         string vType;
         if (pSession->DefinesElement("Nektar/Mapping"))
         {
             vMapping    = pSession->GetElement("Nektar/Mapping");
             vType       = vMapping->Attribute("TYPE");
             m_isDefined = true;
         }
         else
         {
             vType = "Translation";
         }
  
         m_mappingPtr = GetMappingFactory().CreateInstance(vType, pSession,
                                                           pFields, vMapping);
  
         m_init = true;
     }
  
     return m_mappingPtr;
 }

References Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::GlobalMapping::GetMappingFactory(), m_init, m_isDefined, and m_mappingPtr.

Referenced by Nektar::FieldUtils::ProcessMapping::GetMapping(), Nektar::MappingExtrapolate::MappingExtrapolate(), Nektar::SolverUtils::DriverAdaptive::v_Execute(), Nektar::SolverUtils::FilterAeroForces::v_Initialise(), Nektar::VCSMapping::v_InitObject(), Nektar::ForcingMovingBody::v_InitObject(), and Nektar::SolverUtils::EquationSystem::WriteFld().

◆ LowerIndex()

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

Lower index of vector: \(v_{i} = g_{ij}*v^{j}\).

This function lowers the index of the contravariant vector \(v^{i}\), transforming it into its associated covariant vector \(v_{j}\) according to the relation

\[v_{j} = g_{ij}v^{i}\]

where \(g_{ij}\) is the metric tensor.

Parameters

inarray	Components of the contravariant vector \(v^{i}\)
outarray	Components of the covariant vector \(v_{j}\)

Definition at line 605 of file Mapping.cpp.

 {
     if (inarray == outarray)
     {
         int physTot = m_fields[0]->GetTotPoints();
         int nvel    = m_nConvectiveFields;
  
         for (int i = 0; i < nvel; i++)
         {
             Vmath::Vcopy(physTot, inarray[i], 1, m_tmp[i], 1);
         }
         v_LowerIndex(m_tmp, outarray);
     }
     else
     {
         v_LowerIndex(inarray, outarray);
     }
 }

References m_fields, m_nConvectiveFields, m_tmp, v_LowerIndex(), and Vmath::Vcopy().

◆ Output()

void Nektar::GlobalMapping::Mapping::Output	(	LibUtilities::FieldMetaDataMap &	fieldMetaDataMap,
		const std::string &	outname
	)

Output function called when a chk or fld file is written.

This function should be called before writing a fld or chk file. It updates the metadata with information from the Mapping. Also, if the mapping is not defined by a function, it writes a .map file containing the coordinates and velocity of the coordinates.

Parameters

fieldMetaDataMap	Metadata of the output file
outname	Name of the output file

Definition at line 306 of file Mapping.cpp.

 {
     // Only do anything if mapping exists
     if (m_isDefined)
     {
         fieldMetaDataMap["MappingCartesianVel"] = std::string("False");
         if (m_fromFunction)
         {
             // Add metadata
             fieldMetaDataMap["MappingType"]       = std::string("Expression");
             fieldMetaDataMap["MappingExpression"] = m_funcName;
             if (m_timeDependent)
             {
                 fieldMetaDataMap["MappingVelExpression"] = m_velFuncName;
             }
         }
         else
         {
             int expdim           = m_fields[0]->GetGraph()->GetMeshDimension();
             string fieldNames[3] = {"x", "y", "z"};
             string velFieldNames[3] = {"vx", "vy", "vz"};
  
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef =
                 m_fields[0]->GetFieldDefinitions();
             std::vector<std::vector<NekDouble>> FieldData(FieldDef.size());
  
             int ncoeffs = m_fields[0]->GetNcoeffs();
             Array<OneD, NekDouble> fieldcoeffs(ncoeffs);
  
             bool wavespace = m_fields[0]->GetWaveSpace();
             m_fields[0]->SetWaveSpace(false);
             // copy coordinates Data into FieldData and set variable
             for (int j = 0; j < expdim; ++j)
             {
                 m_fields[0]->FwdTransLocalElmt(m_coords[j], fieldcoeffs);
  
                 for (int i = 0; i < FieldDef.size(); ++i)
                 {
                     // Could do a search here to find correct variable
                     FieldDef[i]->m_fields.push_back(fieldNames[j]);
                     m_fields[0]->AppendFieldData(FieldDef[i], FieldData[i],
                                                  fieldcoeffs);
                 }
             }
             if (m_timeDependent)
             {
                 // copy coordinates velocity Data into FieldData and set
                 // variable
                 for (int j = 0; j < expdim; ++j)
                 {
                     m_fields[0]->FwdTransLocalElmt(m_coordsVel[j], fieldcoeffs);
  
                     for (int i = 0; i < FieldDef.size(); ++i)
                     {
                         // Could do a search here to find correct variable
                         FieldDef[i]->m_fields.push_back(velFieldNames[j]);
                         m_fields[0]->AppendFieldData(FieldDef[i], FieldData[i],
                                                      fieldcoeffs);
                     }
                 }
             }
  
             std::string outfile = outname;
             outfile.erase(outfile.end() - 4, outfile.end());
             outfile += ".map";
  
             m_fld->Write(outfile, FieldDef, FieldData, fieldMetaDataMap);
  
             // Write metadata to orginal output
             fieldMetaDataMap["MappingType"] = std::string("File");
             fieldMetaDataMap["FileName"]    = outfile;
  
             m_fields[0]->SetWaveSpace(wavespace);
         }
     }
 }

References m_coords, m_coordsVel, m_fields, m_fld, m_fromFunction, m_funcName, m_isDefined, m_timeDependent, and m_velFuncName.

◆ RaiseIndex()

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

Raise index of vector: \(v^{i} = g^{ij}*v_{j}\).

This function raises the index of the covariant vector \(v_{j}\), transforming it into its associated contravariant vector \(v^{i}\) according to the relation

\[v^{i} = g^{ij}v_{j}\]

where \(g^{ij}\) is the inverse of the metric tensor.

Parameters

inarray	Components of the contravariant vector \(v^{i}\)
outarray	Components of the covariant vector \(v_{j}\)

Definition at line 635 of file Mapping.cpp.

 {
     if (inarray == outarray)
     {
         int physTot = m_fields[0]->GetTotPoints();
         int nvel    = m_nConvectiveFields;
  
         for (int i = 0; i < nvel; i++)
         {
             Vmath::Vcopy(physTot, inarray[i], 1, m_tmp[i], 1);
         }
         v_RaiseIndex(m_tmp, outarray);
     }
     else
     {
         v_RaiseIndex(inarray, outarray);
     }
 }

References m_fields, m_nConvectiveFields, m_tmp, v_RaiseIndex(), and Vmath::Vcopy().

Referenced by v_CurlCurlField(), and v_VelocityLaplacian().

◆ ReplaceField()

void Nektar::GlobalMapping::Mapping::ReplaceField ( const Array< OneD, MultiRegions::ExpListSharedPtr > & pFields )

Replace the Expansion List used by the mapping.

This function replaces the expansion list contained in m_fields, and then proceeds reinitialising the Mapping with this new field.

Parameters

pFields New field to be used by the Mapping

Definition at line 247 of file Mapping.cpp.

 {
     m_fields = pFields;
  
     TiXmlElement *vMapping = NULL;
  
     if (m_session->DefinesElement("Nektar/Mapping"))
     {
         vMapping = m_session->GetElement("Nektar/Mapping");
     }
     InitObject(pFields, vMapping);
 }

References InitObject(), m_fields, and m_session.

◆ SetFromFunction()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::SetFromFunction ( const bool value )

inline

Set flag defining if mapping is defined by a function.

Definition at line 356 of file Mapping.h.

     {
         m_fromFunction = value;
     }

References m_fromFunction.

◆ SetTimeDependent()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::SetTimeDependent ( const bool value )

inline

Set flag defining if mapping is time-dependent.

Definition at line 344 of file Mapping.h.

     {
         m_timeDependent = value;
     }

References m_timeDependent.

◆ UpdateBCs()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::UpdateBCs ( const NekDouble time )

inline

Update the Dirichlet Boundary Conditions when using Mappings.

Definition at line 378 of file Mapping.h.

     {
         v_UpdateBCs(time);
     }

References v_UpdateBCs().

◆ UpdateGeomInfo()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::UpdateGeomInfo ( )

inline

Recompute the metric terms of the Mapping.

Definition at line 395 of file Mapping.h.

     {
         v_UpdateGeomInfo();
     }

References v_UpdateGeomInfo().

Referenced by v_InitObject(), and v_UpdateMapping().

◆ UpdateMapping()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::UpdateMapping	(	const NekDouble	time,
		const Array< OneD, Array< OneD, NekDouble >> &	coords = `NullNekDoubleArrayOfArray`,
		const Array< OneD, Array< OneD, NekDouble >> &	coordsVel = `NullNekDoubleArrayOfArray`
	)

inline

Update the Mapping with new coordinates.

Definition at line 384 of file Mapping.h.

     {
         v_UpdateMapping(time, coords, coordsVel);
     }

References v_UpdateMapping().

◆ v_ApplyChristoffelContravar()

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

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by ApplyChristoffelContravar().

◆ v_ApplyChristoffelCovar()

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

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by ApplyChristoffelCovar().

◆ v_ContravarFromCartesian()

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

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by ContravarFromCartesian().

◆ v_ContravarToCartesian()

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

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by ContravarToCartesian().

◆ v_CovarFromCartesian()

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

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by CovarFromCartesian().

◆ v_CovarToCartesian()

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

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by CovarToCartesian().

◆ v_CurlCurlField()

void Nektar::GlobalMapping::Mapping::v_CurlCurlField	(	Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const bool	generalized
	)

protectedvirtual

Definition at line 989 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
     int nvel    = m_nConvectiveFields;
  
     // Set wavespace to false and store current value
     bool wavespace = m_fields[0]->GetWaveSpace();
     m_fields[0]->SetWaveSpace(false);
  
     // For implicit treatment of viscous terms, we want the generalized
     //   curlcurl and for explicit treatment, we want the cartesian one.
     if (generalized)
     {
         // Get the second derivatives u^i_{,jk}
         Array<OneD, Array<OneD, NekDouble>> tmp(nvel);
         Array<OneD, Array<OneD, NekDouble>> ddU(nvel * nvel * nvel);
         gradgradU(inarray, ddU);
  
         // Raise index to obtain A^{ip}_{k} = g^pj u^i_{,jk}
         for (int i = 0; i < nvel; ++i)
         {
             for (int k = 0; k < nvel; ++k)
             {
                 // Copy to wk
                 for (int j = 0; j < nvel; ++j)
                 {
                     tmp[j] = ddU[i * nvel * nvel + j * nvel + k];
                 }
                 RaiseIndex(tmp, m_tmp);
                 for (int p = 0; p < nvel; ++p)
                 {
                     Vmath::Vcopy(physTot, m_tmp[p], 1,
                                  ddU[i * nvel * nvel + p * nvel + k], 1);
                 }
             }
         }
         // The curlcurl is g^ji u^k_{kj} - g^jk u^i_kj = A^{ki}_k - A^{ik}_k
         for (int i = 0; i < nvel; ++i)
         {
             outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
             for (int k = 0; k < nvel; ++k)
             {
                 Vmath::Vadd(physTot, outarray[i], 1,
                             ddU[k * nvel * nvel + i * nvel + k], 1, outarray[i],
                             1);
                 Vmath::Vsub(physTot, outarray[i], 1,
                             ddU[i * nvel * nvel + k * nvel + k], 1, outarray[i],
                             1);
             }
         }
     }
     else
     {
         m_fields[0]->CurlCurl(inarray, outarray);
     }
  
     // Restore value of wavespace
     m_fields[0]->SetWaveSpace(wavespace);
 }

References gradgradU(), m_fields, m_nConvectiveFields, m_tmp, CellMLToNektar.cellml_metadata::p, RaiseIndex(), Vmath::Vadd(), Vmath::Vcopy(), and Vmath::Vsub().

Referenced by CurlCurlField().

◆ v_Divergence()

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

protectedvirtual

Definition at line 752 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
     Array<OneD, NekDouble> wk(physTot, 0.0);
  
     Vmath::Zero(physTot, outarray, 1);
  
     // Set wavespace to false and store current value
     bool wavespace = m_fields[0]->GetWaveSpace();
     m_fields[0]->SetWaveSpace(false);
  
     // Get Mapping Jacobian
     Array<OneD, NekDouble> Jac(physTot, 0.0);
     GetJacobian(Jac);
  
     for (int i = 0; i < m_nConvectiveFields; ++i)
     {
         Vmath::Vmul(physTot, Jac, 1, inarray[i], 1, wk, 1); // J*Ui
         m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[i], wk,
                                wk); // (J*Ui)_i
         Vmath::Vadd(physTot, wk, 1, outarray, 1, outarray, 1);
     }
     Vmath::Vdiv(physTot, outarray, 1, Jac, 1, outarray, 1); // 1/J*(J*Ui)_i
  
     m_fields[0]->SetWaveSpace(wavespace);
 }

References Nektar::MultiRegions::DirCartesianMap, GetJacobian(), m_fields, m_nConvectiveFields, Vmath::Vadd(), Vmath::Vdiv(), Vmath::Vmul(), and Vmath::Zero().

Referenced by Divergence().

◆ v_DotGradJacobian()

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

protectedvirtual

Reimplemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, and Nektar::GlobalMapping::MappingTranslation.

Definition at line 681 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
  
     outarray = Array<OneD, NekDouble>(physTot, 0.0);
     if (!HasConstantJacobian())
     {
         // Set wavespace to false and store current value
         bool wavespace = m_fields[0]->GetWaveSpace();
         m_fields[0]->SetWaveSpace(false);
  
         // Get Mapping Jacobian
         Array<OneD, NekDouble> Jac(physTot, 0.0);
         GetJacobian(Jac);
  
         // Calculate inarray . grad(Jac)
         Array<OneD, NekDouble> wk(physTot, 0.0);
         for (int i = 0; i < m_nConvectiveFields; ++i)
         {
             m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[i], Jac, wk);
             Vmath::Vvtvp(physTot, inarray[i], 1, wk, 1, outarray, 1, outarray,
                          1);
         }
         m_fields[0]->SetWaveSpace(wavespace);
     }
 }

References Nektar::MultiRegions::DirCartesianMap, GetJacobian(), HasConstantJacobian(), m_fields, m_nConvectiveFields, and Vmath::Vvtvp().

Referenced by DotGradJacobian().

◆ v_GetCartesianCoordinates()

void Nektar::GlobalMapping::Mapping::v_GetCartesianCoordinates	(	Array< OneD, NekDouble > &	out0,
		Array< OneD, NekDouble > &	out1,
		Array< OneD, NekDouble > &	out2
	)

protectedvirtual

Definition at line 655 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
  
     out0 = Array<OneD, NekDouble>(physTot, 0.0);
     out1 = Array<OneD, NekDouble>(physTot, 0.0);
     out2 = Array<OneD, NekDouble>(physTot, 0.0);
  
     Vmath::Vcopy(physTot, m_coords[0], 1, out0, 1);
     Vmath::Vcopy(physTot, m_coords[1], 1, out1, 1);
     Vmath::Vcopy(physTot, m_coords[2], 1, out2, 1);
 }

References m_coords, m_fields, and Vmath::Vcopy().

Referenced by GetCartesianCoordinates().

◆ v_GetCoordVelocity()

void Nektar::GlobalMapping::Mapping::v_GetCoordVelocity ( Array< OneD, Array< OneD, NekDouble >> & outarray )

protectedvirtual

Definition at line 670 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
  
     for (int i = 0; i < m_nConvectiveFields; ++i)
     {
         outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
         Vmath::Vcopy(physTot, m_coordsVel[i], 1, outarray[i], 1);
     }
 }

References m_coordsVel, m_fields, m_nConvectiveFields, and Vmath::Vcopy().

Referenced by GetCoordVelocity().

◆ v_GetInvMetricTensor()

virtual GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::v_GetInvMetricTensor ( Array< OneD, Array< OneD, NekDouble >> & outarray )

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by GetInvMetricTensor().

◆ v_GetJacobian()

virtual GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::v_GetJacobian ( Array< OneD, NekDouble > & outarray )

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by GetJacobian().

◆ v_GetMetricTensor()

virtual GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::v_GetMetricTensor ( Array< OneD, Array< OneD, NekDouble >> & outarray )

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by GetMetricTensor().

◆ v_gradgradU()

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

protectedvirtual

Definition at line 881 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
     int nvel    = m_nConvectiveFields;
  
     // Declare variables
     outarray = Array<OneD, Array<OneD, NekDouble>>(nvel * nvel * nvel);
     Array<OneD, Array<OneD, NekDouble>> tmp(nvel);
     for (int i = 0; i < nvel * nvel * nvel; i++)
     {
         outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
     }
  
     // Set wavespace to false and store current value
     bool wavespace = m_fields[0]->GetWaveSpace();
     m_fields[0]->SetWaveSpace(false);
  
     // Calculate vector gradient u^i_(,j) = du^i/dx^j + {i,pj}*u^p
     ApplyChristoffelContravar(inarray, m_wk1);
     for (int i = 0; i < nvel; i++)
     {
         if (nvel == 2)
         {
             m_fields[0]->PhysDeriv(inarray[i], m_wk2[i * nvel + 0],
                                    m_wk2[i * nvel + 1]);
         }
         else
         {
             m_fields[0]->PhysDeriv(inarray[i], m_wk2[i * nvel + 0],
                                    m_wk2[i * nvel + 1], m_wk2[i * nvel + 2]);
         }
         for (int j = 0; j < nvel; j++)
         {
             Vmath::Vadd(physTot, m_wk1[i * nvel + j], 1, m_wk2[i * nvel + j], 1,
                         m_wk1[i * nvel + j], 1);
         }
     }
  
     //
     // Calculate (u^i_,j),k
     //
  
     // Step 1 : d(u^i_,j))/d(x^k)
     for (int i = 0; i < nvel; i++)
     {
         for (int j = 0; j < nvel; j++)
         {
             if (nvel == 2)
             {
                 m_fields[0]->PhysDeriv(
                     m_wk1[i * nvel + j],
                     outarray[i * nvel * nvel + j * nvel + 0],
                     outarray[i * nvel * nvel + j * nvel + 1]);
             }
             else
             {
                 m_fields[0]->PhysDeriv(
                     m_wk1[i * nvel + j],
                     outarray[i * nvel * nvel + j * nvel + 0],
                     outarray[i * nvel * nvel + j * nvel + 1],
                     outarray[i * nvel * nvel + j * nvel + 2]);
             }
         }
     }
  
     // Step 2: d(u^i_,j)/d(x^k) - {p,jk}*u^i_,p
     for (int i = 0; i < nvel; i++)
     {
         for (int p = 0; p < nvel; p++)
         {
             tmp[p] = m_wk1[i * nvel + p];
         }
         ApplyChristoffelCovar(tmp, m_wk2);
         for (int j = 0; j < nvel; j++)
         {
             for (int k = 0; k < nvel; k++)
             {
                 Vmath::Vsub(physTot, outarray[i * nvel * nvel + j * nvel + k],
                             1, m_wk2[j * nvel + k], 1,
                             outarray[i * nvel * nvel + j * nvel + k], 1);
             }
         }
     }
  
     // Step 3: d(u^i_,j)/d(x^k) - {p,jk}*u^i_,p + {i,pk} u^p_,j
     for (int j = 0; j < nvel; j++)
     {
         for (int p = 0; p < nvel; p++)
         {
             tmp[p] = m_wk1[p * nvel + j];
         }
         ApplyChristoffelContravar(tmp, m_wk2);
         for (int i = 0; i < nvel; i++)
         {
             for (int k = 0; k < nvel; k++)
             {
                 Vmath::Vadd(physTot, outarray[i * nvel * nvel + j * nvel + k],
                             1, m_wk2[i * nvel + k], 1,
                             outarray[i * nvel * nvel + j * nvel + k], 1);
             }
         }
     }
  
     // Restore value of wavespace
     m_fields[0]->SetWaveSpace(wavespace);
 }

References ApplyChristoffelContravar(), ApplyChristoffelCovar(), m_fields, m_nConvectiveFields, m_wk1, m_wk2, CellMLToNektar.cellml_metadata::p, Vmath::Vadd(), and Vmath::Vsub().

Referenced by gradgradU().

◆ v_InitObject()

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

protectedvirtual

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 in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Definition at line 101 of file Mapping.cpp.

 {
     boost::ignore_unused(pFields);
  
     int phystot    = m_fields[0]->GetTotPoints();
     m_fromFunction = true;
     // Initialise variables
     m_coords    = Array<OneD, Array<OneD, NekDouble>>(3);
     m_coordsVel = Array<OneD, Array<OneD, NekDouble>>(3);
     Array<OneD, Array<OneD, NekDouble>> coords(3);
     for (int i = 0; i < 3; i++)
     {
         m_coords[i]    = Array<OneD, NekDouble>(phystot);
         m_coordsVel[i] = Array<OneD, NekDouble>(phystot);
         coords[i]      = Array<OneD, NekDouble>(phystot);
     }
  
     // Check if mapping is defined as time-dependent
     const TiXmlElement *timeDep = pMapping->FirstChildElement("TIMEDEPENDENT");
     if (timeDep)
     {
         string sTimeDep = timeDep->GetText();
         m_timeDependent = (boost::iequals(sTimeDep, "true")) ||
                           (boost::iequals(sTimeDep, "yes"));
     }
     else
     {
         m_timeDependent = false;
     }
  
     // Load coordinates
     string fieldNames[3]             = {"x", "y", "z"};
     const TiXmlElement *funcNameElmt = pMapping->FirstChildElement("COORDS");
     if (funcNameElmt)
     {
         m_funcName = funcNameElmt->GetText();
         ASSERTL0(m_session->DefinesFunction(m_funcName),
                  "Function '" + m_funcName + "' not defined.");
  
         // Get coordinates in the domain
         m_fields[0]->GetCoords(coords[0], coords[1], coords[2]);
  
         std::string s_FieldStr;
         // Check if function from session file defines each component
         //      and evaluate them, otherwise use trivial transformation
         for (int i = 0; i < 3; i++)
         {
             s_FieldStr = fieldNames[i];
             if (m_session->DefinesFunction(m_funcName, s_FieldStr))
             {
                 EvaluateFunction(m_fields, m_session, s_FieldStr, m_coords[i],
                                  m_funcName);
                 if (i == 2 && m_fields[0]->GetExpType() == MultiRegions::e3DH1D)
                 {
                     ASSERTL0(
                         false,
                         "3DH1D does not support mapping in the z-direction.");
                 }
             }
             else
             {
                 // This coordinate is not defined, so use (x^i)' = x^i
                 Vmath::Vcopy(phystot, coords[i], 1, m_coords[i], 1);
             }
         }
     }
     else
     {
         m_fields[0]->GetCoords(coords[0], coords[1], coords[2]);
         for (int i = 0; i < 3; i++)
         {
             // Use (x^i)' = x^i as default. This can be useful if we
             //    have a time-dependent mapping, and then only the
             //    initial mapping will be trivial
             Vmath::Vcopy(phystot, coords[i], 1, m_coords[i], 1);
         }
     }
  
     // Load coordinate velocity if they are defined,
     //      otherwise use zero to make it general
     string velFieldNames[3]             = {"vx", "vy", "vz"};
     const TiXmlElement *velFuncNameElmt = pMapping->FirstChildElement("VEL");
     if (velFuncNameElmt)
     {
         m_velFuncName = velFuncNameElmt->GetText();
         ASSERTL0(m_session->DefinesFunction(m_velFuncName),
                  "Function '" + m_velFuncName + "' not defined.");
  
         std::string s_FieldStr;
         // Check if function from session file defines each component
         //      and evaluate them, otherwise use 0
         for (int i = 0; i < 3; i++)
         {
             s_FieldStr = velFieldNames[i];
             if (m_session->DefinesFunction(m_velFuncName, s_FieldStr))
             {
                 EvaluateFunction(m_fields, m_session, s_FieldStr,
                                  m_coordsVel[i], m_velFuncName);
                 if (i == 2 && m_fields[0]->GetExpType() == MultiRegions::e3DH1D)
                 {
                     ASSERTL0(
                         false,
                         "3DH1D does not support mapping in the z-direction.");
                 }
             }
             else
             {
                 // This coordinate velocity is not defined, so use 0
                 Vmath::Zero(phystot, m_coordsVel[i], 1);
             }
         }
     }
     else
     {
         for (int i = 0; i < 3; i++)
         {
             Vmath::Zero(phystot, m_coordsVel[i], 1);
         }
     }
  
     // Initialise workspace variables
     int nvel = m_nConvectiveFields;
     m_wk1    = Array<OneD, Array<OneD, NekDouble>>(nvel * nvel);
     m_wk2    = Array<OneD, Array<OneD, NekDouble>>(nvel * nvel);
     m_tmp    = Array<OneD, Array<OneD, NekDouble>>(nvel);
     for (int i = 0; i < nvel; i++)
     {
         m_tmp[i] = Array<OneD, NekDouble>(phystot, 0.0);
         for (int j = 0; j < nvel; j++)
         {
             m_wk1[i * nvel + j] = Array<OneD, NekDouble>(phystot, 0.0);
             m_wk2[i * nvel + j] = Array<OneD, NekDouble>(phystot, 0.0);
         }
     }
  
     // Calculate information required by the particular mapping
     UpdateGeomInfo();
 }

References ASSERTL0, Nektar::MultiRegions::e3DH1D, EvaluateFunction(), m_coords, m_coordsVel, m_fields, m_fromFunction, m_funcName, m_nConvectiveFields, m_session, m_timeDependent, m_tmp, m_velFuncName, m_wk1, m_wk2, UpdateGeomInfo(), Vmath::Vcopy(), and Vmath::Zero().

Referenced by InitObject(), Nektar::GlobalMapping::MappingGeneral::v_InitObject(), Nektar::GlobalMapping::MappingTranslation::v_InitObject(), Nektar::GlobalMapping::MappingXofXZ::v_InitObject(), Nektar::GlobalMapping::MappingXofZ::v_InitObject(), Nektar::GlobalMapping::MappingXYofXY::v_InitObject(), and Nektar::GlobalMapping::MappingXYofZ::v_InitObject().

◆ v_LowerIndex()

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

protectedvirtual

Reimplemented in Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, and Nektar::GlobalMapping::MappingTranslation.

Definition at line 710 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
     int nvel    = m_nConvectiveFields;
  
     Array<OneD, Array<OneD, NekDouble>> g(nvel * nvel);
  
     GetMetricTensor(g);
  
     for (int i = 0; i < nvel; i++)
     {
         outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
         for (int j = 0; j < nvel; j++)
         {
             Vmath::Vvtvp(physTot, g[i * nvel + j], 1, inarray[j], 1,
                          outarray[i], 1, outarray[i], 1);
         }
     }
 }

References GetMetricTensor(), m_fields, m_nConvectiveFields, and Vmath::Vvtvp().

Referenced by LowerIndex().

◆ v_RaiseIndex()

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

protectedvirtual

Reimplemented in Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, and Nektar::GlobalMapping::MappingTranslation.

Definition at line 731 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
     int nvel    = m_nConvectiveFields;
  
     Array<OneD, Array<OneD, NekDouble>> g(nvel * nvel);
  
     GetInvMetricTensor(g);
  
     for (int i = 0; i < nvel; i++)
     {
         outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
         for (int j = 0; j < nvel; j++)
         {
             Vmath::Vvtvp(physTot, g[i * nvel + j], 1, inarray[j], 1,
                          outarray[i], 1, outarray[i], 1);
         }
     }
 }

References GetInvMetricTensor(), m_fields, m_nConvectiveFields, and Vmath::Vvtvp().

Referenced by RaiseIndex().

◆ v_UpdateBCs()

void Nektar::GlobalMapping::Mapping::v_UpdateBCs ( const NekDouble time )

protectedvirtual

Definition at line 1051 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
     int nvel    = m_nConvectiveFields;
     int nfields = m_fields.size();
     int nbnds   = m_fields[0]->GetBndConditions().size();
  
     // Declare variables
     Array<OneD, const SpatialDomains::BoundaryConditionShPtr> BndConds;
     Array<OneD, MultiRegions::ExpListSharedPtr> BndExp;
  
     Array<OneD, bool> isDirichlet(nfields);
  
     Array<OneD, Array<OneD, NekDouble>> values(nfields);
     for (int i = 0; i < nfields; i++)
     {
         values[i] = Array<OneD, NekDouble>(physTot, 0.0);
     }
  
     Array<OneD, Array<OneD, NekDouble>> tmp(nvel);
     Array<OneD, Array<OneD, NekDouble>> tmp2(nvel);
     Array<OneD, Array<OneD, NekDouble>> coordVel(nvel);
     for (int i = 0; i < nvel; i++)
     {
         tmp[i]      = Array<OneD, NekDouble>(physTot, 0.0);
         tmp2[i]     = Array<OneD, NekDouble>(physTot, 0.0);
         coordVel[i] = Array<OneD, NekDouble>(physTot, 0.0);
     }
  
     // Get coordinates velocity in transformed system (for MovingBody regions)
     GetCoordVelocity(tmp);
     ContravarFromCartesian(tmp, coordVel);
  
     // Get  Cartesian coordinates for evaluating boundary conditions
     Array<OneD, Array<OneD, NekDouble>> coords(3);
     for (int dir = 0; dir < 3; dir++)
     {
         coords[dir] = Array<OneD, NekDouble>(physTot, 0.0);
     }
     GetCartesianCoordinates(coords[0], coords[1], coords[2]);
  
     // Loop boundary conditions looking for Dirichlet bc's
     for (int n = 0; n < nbnds; ++n)
     {
         // Evaluate original Dirichlet boundary conditions in whole domain
         for (int i = 0; i < nfields; ++i)
         {
             BndConds = m_fields[i]->GetBndConditions();
             BndExp   = m_fields[i]->GetBndCondExpansions();
             if (BndConds[n]->GetBoundaryConditionType() ==
                 SpatialDomains::eDirichlet)
             {
                 isDirichlet[i] = true;
                 // If we have the a velocity component
                 //      check if all vel bc's are also Dirichlet
                 if (i < nvel)
                 {
                     for (int j = 0; j < nvel; ++j)
                     {
                         ASSERTL0(m_fields[j]
                                          ->GetBndConditions()[n]
                                          ->GetBoundaryConditionType() ==
                                      SpatialDomains::eDirichlet,
                                  "Mapping only supported when all velocity "
                                  "components have the same type of boundary "
                                  "conditions");
                     }
                 }
                 // Check if bc is time-dependent
                 ASSERTL0(!BndConds[n]->IsTimeDependent(),
                          "Time-dependent Dirichlet boundary conditions not "
                          "supported with mapping yet.");
  
                 // Get boundary condition
                 LibUtilities::Equation condition =
                     std::static_pointer_cast<
                         SpatialDomains::DirichletBoundaryCondition>(BndConds[n])
                         ->m_dirichletCondition;
                 // Evaluate
                 condition.Evaluate(coords[0], coords[1], coords[2], time,
                                    values[i]);
             }
             else
             {
                 isDirichlet[i] = false;
             }
         }
         // Convert velocity vector to transformed system
         if (isDirichlet[0])
         {
             for (int i = 0; i < nvel; ++i)
             {
                 Vmath::Vcopy(physTot, values[i], 1, tmp[i], 1);
             }
             ContravarFromCartesian(tmp, tmp2);
             for (int i = 0; i < nvel; ++i)
             {
                 Vmath::Vcopy(physTot, tmp2[i], 1, values[i], 1);
             }
         }
  
         // Now, project result to boundary
         for (int i = 0; i < nfields; ++i)
         {
             BndConds = m_fields[i]->GetBndConditions();
             BndExp   = m_fields[i]->GetBndCondExpansions();
  
             if (BndConds[n]->GetUserDefined() == "" ||
                 BndConds[n]->GetUserDefined() == "MovingBody")
             {
                 m_fields[i]->ExtractPhysToBnd(n, values[i],
                                               BndExp[n]->UpdatePhys());
  
                 // Apply MovingBody correction
                 if ((i < nvel) && BndConds[n]->GetUserDefined() == "MovingBody")
                 {
                     // Get coordinate velocity on boundary
                     Array<OneD, NekDouble> coordVelBnd(
                         BndExp[n]->GetTotPoints());
                     m_fields[i]->ExtractPhysToBnd(n, coordVel[i], coordVelBnd);
  
                     // Apply correction
                     Vmath::Vadd(BndExp[n]->GetTotPoints(), coordVelBnd, 1,
                                 BndExp[n]->UpdatePhys(), 1,
                                 BndExp[n]->UpdatePhys(), 1);
                 }
             }
         }
     }
  
     // Finally, perform FwdTrans in all fields
     for (int i = 0; i < m_fields.size(); ++i)
     {
         // Get boundary condition information
         BndConds = m_fields[i]->GetBndConditions();
         BndExp   = m_fields[i]->GetBndCondExpansions();
  
         for (int n = 0; n < BndConds.size(); ++n)
         {
             if (BndConds[n]->GetBoundaryConditionType() ==
                 SpatialDomains::eDirichlet)
             {
                 if (BndConds[n]->GetUserDefined() == "" ||
                     BndConds[n]->GetUserDefined() == "MovingBody")
                 {
                     if (m_fields[i]->GetExpType() == MultiRegions::e3DH1D)
                     {
                         BndExp[n]->SetWaveSpace(false);
                     }
  
                     BndExp[n]->FwdTransBndConstrained(
                         BndExp[n]->GetPhys(), BndExp[n]->UpdateCoeffs());
                 }
             }
         }
     }
 }

References ASSERTL0, ContravarFromCartesian(), Nektar::MultiRegions::e3DH1D, Nektar::SpatialDomains::eDirichlet, Nektar::LibUtilities::Equation::Evaluate(), GetCartesianCoordinates(), GetCoordVelocity(), IsTimeDependent(), m_fields, m_nConvectiveFields, Vmath::Vadd(), and Vmath::Vcopy().

Referenced by UpdateBCs().

◆ v_UpdateGeomInfo()

virtual GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::v_UpdateGeomInfo ( )

protectedpure virtual

Implemented in Nektar::GlobalMapping::MappingXYofZ, Nektar::GlobalMapping::MappingXYofXY, Nektar::GlobalMapping::MappingXofZ, Nektar::GlobalMapping::MappingXofXZ, Nektar::GlobalMapping::MappingTranslation, and Nektar::GlobalMapping::MappingGeneral.

Referenced by UpdateGeomInfo().

◆ v_UpdateMapping()

void Nektar::GlobalMapping::Mapping::v_UpdateMapping	(	const NekDouble	time,
		const Array< OneD, Array< OneD, NekDouble >> &	coords = `NullNekDoubleArrayOfArray`,
		const Array< OneD, Array< OneD, NekDouble >> &	coordsVel = `NullNekDoubleArrayOfArray`
	)

protectedvirtual

Definition at line 1209 of file Mapping.cpp.

 {
     if (m_fromFunction)
     {
         std::string s_FieldStr;
         string fieldNames[3]    = {"x", "y", "z"};
         string velFieldNames[3] = {"vx", "vy", "vz"};
         // Check if function from session file defines each component
         //      and evaluate them, otherwise there is no need to update
         //          coords
         for (int i = 0; i < 3; i++)
         {
             s_FieldStr = fieldNames[i];
             if (m_session->DefinesFunction(m_funcName, s_FieldStr))
             {
                 EvaluateFunction(m_fields, m_session, s_FieldStr, m_coords[i],
                                  m_funcName, time);
                 if (i == 2 && m_fields[0]->GetExpType() == MultiRegions::e3DH1D)
                 {
                     ASSERTL0(
                         false,
                         "3DH1D does not support mapping in the z-direction.");
                 }
             }
             s_FieldStr = velFieldNames[i];
             if (m_session->DefinesFunction(m_velFuncName, s_FieldStr))
             {
                 EvaluateFunction(m_fields, m_session, s_FieldStr,
                                  m_coordsVel[i], m_velFuncName, time);
                 if (i == 2 && m_fields[0]->GetExpType() == MultiRegions::e3DH1D)
                 {
                     ASSERTL0(
                         false,
                         "3DH1D does not support mapping in the z-direction.");
                 }
             }
         }
     }
     else
     {
         int physTot = m_fields[0]->GetTotPoints();
         int nvel    = m_nConvectiveFields;
         // Copy coordinates
         for (int i = 0; i < 3; i++)
         {
             Vmath::Vcopy(physTot, coords[i], 1, m_coords[i], 1);
         }
  
         for (int i = 0; i < nvel; i++)
         {
             Vmath::Vcopy(physTot, coordsVel[i], 1, m_coordsVel[i], 1);
         }
     }
  
     // Update the information required by the specific mapping
     UpdateGeomInfo();
 }

References ASSERTL0, Nektar::MultiRegions::e3DH1D, EvaluateFunction(), m_coords, m_coordsVel, m_fields, m_fromFunction, m_funcName, m_nConvectiveFields, m_session, m_velFuncName, UpdateGeomInfo(), and Vmath::Vcopy().

Referenced by UpdateMapping().

◆ v_VelocityLaplacian()

void Nektar::GlobalMapping::Mapping::v_VelocityLaplacian	(	const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const NekDouble	alpha
	)

protectedvirtual

Definition at line 780 of file Mapping.cpp.

 {
     int physTot = m_fields[0]->GetTotPoints();
     int nvel    = m_nConvectiveFields;
  
     Array<OneD, Array<OneD, NekDouble>> tmp(nvel);
  
     // Set wavespace to false and store current value
     bool wavespace = m_fields[0]->GetWaveSpace();
     m_fields[0]->SetWaveSpace(false);
  
     // Calculate vector gradient wk2 = u^i_(,k) = du^i/dx^k + {i,jk}*u^j
     ApplyChristoffelContravar(inarray, m_wk1);
     for (int i = 0; i < nvel; i++)
     {
         if (nvel == 2)
         {
             m_fields[0]->PhysDeriv(inarray[i], m_wk2[i * nvel + 0],
                                    m_wk2[i * nvel + 1]);
         }
         else
         {
             m_fields[0]->PhysDeriv(inarray[i], m_wk2[i * nvel + 0],
                                    m_wk2[i * nvel + 1], m_wk2[i * nvel + 2]);
         }
         for (int k = 0; k < nvel; k++)
         {
             Vmath::Vadd(physTot, m_wk1[i * nvel + k], 1, m_wk2[i * nvel + k], 1,
                         m_wk1[i * nvel + k], 1);
         }
     }
     // Calculate wk1 = A^(ij) = g^(jk)*u^i_(,k)
     for (int i = 0; i < nvel; i++)
     {
         for (int k = 0; k < nvel; k++)
         {
             tmp[k] = m_wk1[i * nvel + k];
         }
         RaiseIndex(tmp, m_tmp);
         for (int j = 0; j < nvel; j++)
         {
             Vmath::Vcopy(physTot, m_tmp[j], 1, m_wk1[i * nvel + j], 1);
         }
     }
     //
     // Calculate L(U)^i = (A^(ij))_(,j) - alpha*d^2(u^i)/dx^jdx^j
     //
  
     // Step 1 :
     //      d(A^(ij) - alpha*du^i/dx^j)/d(x^j)
     for (int i = 0; i < nvel; i++)
     {
         outarray[i] = Array<OneD, NekDouble>(physTot, 0.0);
         for (int j = 0; j < nvel; j++)
         {
             Vmath::Smul(physTot, alpha, m_wk2[i * nvel + j], 1, m_tmp[0], 1);
             Vmath::Vsub(physTot, m_wk1[i * nvel + j], 1, m_tmp[0], 1, m_tmp[0],
                         1);
  
             m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[j], m_tmp[0],
                                    m_tmp[1]);
             Vmath::Vadd(physTot, outarray[i], 1, m_tmp[1], 1, outarray[i], 1);
         }
     }
  
     // Step 2: d(A^(ij))/d(x^j) + {j,pj}*A^(ip)
     for (int i = 0; i < nvel; i++)
     {
         for (int p = 0; p < nvel; p++)
         {
             tmp[p] = m_wk1[i * nvel + p];
         }
         ApplyChristoffelContravar(tmp, m_wk2);
         for (int j = 0; j < nvel; j++)
         {
             Vmath::Vadd(physTot, outarray[i], 1, m_wk2[j * nvel + j], 1,
                         outarray[i], 1);
         }
     }
  
     // Step 3: d(A^(ij))/d(x^j) + {j,pj}*A^(ip) + {i,pj} A^(pj)
     for (int j = 0; j < nvel; j++)
     {
         for (int p = 0; p < nvel; p++)
         {
             tmp[p] = m_wk1[p * nvel + j];
         }
         ApplyChristoffelContravar(tmp, m_wk2);
         for (int i = 0; i < nvel; i++)
         {
             Vmath::Vadd(physTot, outarray[i], 1, m_wk2[i * nvel + j], 1,
                         outarray[i], 1);
         }
     }
  
     // Restore value of wavespace
     m_fields[0]->SetWaveSpace(wavespace);
 }

References ApplyChristoffelContravar(), Nektar::MultiRegions::DirCartesianMap, m_fields, m_nConvectiveFields, m_tmp, m_wk1, m_wk2, CellMLToNektar.cellml_metadata::p, RaiseIndex(), Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), and Vmath::Vsub().

Referenced by VelocityLaplacian().

◆ VelocityLaplacian()

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::VelocityLaplacian	(	const Array< OneD, Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const NekDouble	alpha = `0.0`
	)

inline

Generalised (correction to the) velocity Laplacian operator.

This function is used to calculate a correction defined as the difference between the generalised Laplacian and the original Laplacian multiplied by a constant \(\alpha\), resulting in

\[ L^i = g^{jk}u^{i}_{,jk} - \alpha \frac{\partial^2 x^i} {\partial x^j \partial x^j}\]

By default, \(\alpha\) is zero, resulting in the generalised Laplacian.

Parameters

inarray	Contravariant vector \(u^i\)
outarray	Result of the operation
alpha	The constant \(\alpha\)

Definition at line 289 of file Mapping.h.

     {
         v_VelocityLaplacian(inarray, outarray, alpha);
     }

References v_VelocityLaplacian().

Member Data Documentation

◆ m_constantJacobian

bool Nektar::GlobalMapping::Mapping::m_constantJacobian

protected

Flag defining if the Jacobian is constant.

Definition at line 423 of file Mapping.h.

Referenced by HasConstantJacobian(), Nektar::GlobalMapping::MappingGeneral::v_InitObject(), Nektar::GlobalMapping::MappingTranslation::v_InitObject(), Nektar::GlobalMapping::MappingXofXZ::v_InitObject(), Nektar::GlobalMapping::MappingXofZ::v_InitObject(), Nektar::GlobalMapping::MappingXYofXY::v_InitObject(), and Nektar::GlobalMapping::MappingXYofZ::v_InitObject().

◆ m_coords

Array<OneD, Array<OneD, NekDouble> > Nektar::GlobalMapping::Mapping::m_coords

protected

Array with the Cartesian coordinates.

Definition at line 408 of file Mapping.h.

Referenced by Nektar::GlobalMapping::MappingGeneral::CalculateMetricTerms(), Output(), v_GetCartesianCoordinates(), v_InitObject(), Nektar::GlobalMapping::MappingTranslation::v_InitObject(), Nektar::GlobalMapping::MappingXofXZ::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXofZ::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXYofXY::v_UpdateGeomInfo(), Nektar::GlobalMapping::MappingXYofZ::v_UpdateGeomInfo(), and v_UpdateMapping().

◆ m_coordsVel

Array<OneD, Array<OneD, NekDouble> > Nektar::GlobalMapping::Mapping::m_coordsVel

protected

Array with the velocity of the coordinates.

Definition at line 410 of file Mapping.h.

Referenced by Output(), v_GetCoordVelocity(), v_InitObject(), Nektar::GlobalMapping::MappingTranslation::v_InitObject(), and v_UpdateMapping().

◆ m_fields

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::GlobalMapping::Mapping::m_fields

protected

Definition at line 406 of file Mapping.h.

◆ m_fld

LibUtilities::FieldIOSharedPtr Nektar::GlobalMapping::Mapping::m_fld

protected

Definition at line 404 of file Mapping.h.

Referenced by Mapping(), and Output().

◆ m_fromFunction

bool Nektar::GlobalMapping::Mapping::m_fromFunction

protected

Flag defining if the Mapping is defined by a function.

Definition at line 427 of file Mapping.h.

Referenced by IsFromFunction(), Output(), SetFromFunction(), v_InitObject(), and v_UpdateMapping().

◆ m_funcName

std::string Nektar::GlobalMapping::Mapping::m_funcName

protected

Name of the function containing the coordinates.

Definition at line 417 of file Mapping.h.

Referenced by Output(), v_InitObject(), and v_UpdateMapping().

◆ m_GeometricInfo

Array<OneD, Array<OneD, NekDouble> > Nektar::GlobalMapping::Mapping::m_GeometricInfo

protected

Array with metric terms of the mapping.

Definition at line 412 of file Mapping.h.

◆ m_init

bool Nektar::GlobalMapping::Mapping::m_init = false

staticprotected

Definition at line 431 of file Mapping.h.

Referenced by Load().

◆ m_isDefined

bool Nektar::GlobalMapping::Mapping::m_isDefined = false

staticprotected

Definition at line 432 of file Mapping.h.

Referenced by IsDefined(), Load(), and Output().

◆ m_mappingPtr

MappingSharedPtr Nektar::GlobalMapping::Mapping::m_mappingPtr = MappingSharedPtr()

staticprotected

Definition at line 430 of file Mapping.h.

Referenced by Load().

◆ m_nConvectiveFields

int Nektar::GlobalMapping::Mapping::m_nConvectiveFields

protected

Number of velocity components.

Definition at line 414 of file Mapping.h.

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::GlobalMapping::Mapping::m_session

protected

Session reader.

Definition at line 402 of file Mapping.h.

Referenced by ReplaceField(), v_InitObject(), Nektar::GlobalMapping::MappingTranslation::v_InitObject(), and v_UpdateMapping().

◆ m_timeDependent

bool Nektar::GlobalMapping::Mapping::m_timeDependent

protected

Flag defining if the Mapping is time-dependent.

Definition at line 425 of file Mapping.h.

Referenced by IsTimeDependent(), Output(), SetTimeDependent(), v_InitObject(), and Nektar::GlobalMapping::MappingTranslation::v_InitObject().

◆ m_tmp

Array<OneD, Array<OneD, NekDouble> > Nektar::GlobalMapping::Mapping::m_tmp

protected

Definition at line 437 of file Mapping.h.

Referenced by ContravarFromCartesian(), ContravarToCartesian(), CovarFromCartesian(), CovarToCartesian(), LowerIndex(), RaiseIndex(), v_CurlCurlField(), v_InitObject(), Nektar::GlobalMapping::MappingTranslation::v_InitObject(), and v_VelocityLaplacian().

◆ m_velFuncName

std::string Nektar::GlobalMapping::Mapping::m_velFuncName

protected

Name of the function containing the velocity of the coordinates.

Definition at line 419 of file Mapping.h.

Referenced by Output(), v_InitObject(), and v_UpdateMapping().

◆ m_wk1

Array<OneD, Array<OneD, NekDouble> > Nektar::GlobalMapping::Mapping::m_wk1

protected

Definition at line 435 of file Mapping.h.

Referenced by v_gradgradU(), v_InitObject(), and v_VelocityLaplacian().

◆ m_wk2

Array<OneD, Array<OneD, NekDouble> > Nektar::GlobalMapping::Mapping::m_wk2

protected

Definition at line 436 of file Mapping.h.

Referenced by v_gradgradU(), v_InitObject(), and v_VelocityLaplacian().

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ~Mapping()

◆ Mapping()

Member Function Documentation

◆ ApplyChristoffelContravar()

◆ ApplyChristoffelCovar()

◆ ContravarFromCartesian()

◆ ContravarToCartesian()

◆ CovarFromCartesian()

◆ CovarToCartesian()

◆ CurlCurlField()

◆ Divergence()

◆ DotGradJacobian()

◆ EvaluateFunction()

◆ EvaluateTimeFunction()

◆ GetCartesianCoordinates()

◆ GetCoordVelocity()

◆ GetInvMetricTensor()

◆ GetJacobian()

◆ GetMetricTensor()

◆ gradgradU()

◆ HasConstantJacobian()

◆ InitObject()

◆ IsDefined()

◆ IsFromFunction()

◆ IsTimeDependent()

◆ Load()

◆ LowerIndex()

◆ Output()

◆ RaiseIndex()

◆ ReplaceField()

◆ SetFromFunction()

◆ SetTimeDependent()

◆ UpdateBCs()

◆ UpdateGeomInfo()

◆ UpdateMapping()

◆ v_ApplyChristoffelContravar()

◆ v_ApplyChristoffelCovar()

◆ v_ContravarFromCartesian()

◆ v_ContravarToCartesian()

◆ v_CovarFromCartesian()

◆ v_CovarToCartesian()

◆ v_CurlCurlField()

◆ v_Divergence()

◆ v_DotGradJacobian()

◆ v_GetCartesianCoordinates()

◆ v_GetCoordVelocity()

◆ v_GetInvMetricTensor()

◆ v_GetJacobian()

◆ v_GetMetricTensor()

◆ v_gradgradU()

◆ v_InitObject()

◆ v_LowerIndex()

◆ v_RaiseIndex()

◆ v_UpdateBCs()

◆ v_UpdateGeomInfo()

◆ v_UpdateMapping()

◆ v_VelocityLaplacian()

◆ VelocityLaplacian()

Member Data Documentation

◆ m_constantJacobian

◆ m_coords

◆ m_coordsVel

◆ m_fields

◆ m_fld

◆ m_fromFunction

◆ m_funcName

◆ m_GeometricInfo

◆ m_init

◆ m_isDefined

◆ m_mappingPtr

◆ m_nConvectiveFields

◆ m_session

◆ m_timeDependent