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

#include <Mapping.h>

Inheritance diagram for Nektar::GlobalMapping::Mapping:

Collaboration 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 (const 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 (const 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...

string	m_funcName
	Name of the function containing the coordinates. More...

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 69 of file Mapping.h.

Constructor & Destructor Documentation

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

inlinevirtual

Destructor.

Definition at line 73 of file Mapping.h.

73 {}

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

protected

Constructor.

Definition at line 55 of file Mapping.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::MultiRegions::e1D, Nektar::MultiRegions::e2D, Nektar::MultiRegions::e3D, Nektar::MultiRegions::e3DH1D, Nektar::MultiRegions::e3DH2D, m_fields, m_fld, and m_nConvectiveFields.

     : 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 = MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr
                                                         (pSession->GetComm());
 }

Member Function Documentation

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
outarray	Result of applying Christoffel symbols to

Definition at line 212 of file Mapping.h.

References v_ApplyChristoffelContravar().

Referenced by v_gradgradU(), and v_VelocityLaplacian().

         {
             v_ApplyChristoffelContravar( inarray, outarray);
         }

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
outarray	Result of applying Christoffel symbols to

Definition at line 230 of file Mapping.h.

References v_ApplyChristoffelCovar().

Referenced by v_gradgradU().

         {
             v_ApplyChristoffelCovar( inarray, outarray);
         }

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 546 of file Mapping.cpp.

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

Referenced by v_UpdateBCs().

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

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 486 of file Mapping.cpp.

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

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

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 576 of file Mapping.cpp.

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

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

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 516 of file Mapping.cpp.

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

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

GLOBAL_MAPPING_EXPORT void Nektar::GlobalMapping::Mapping::CurlCurlField	(	const 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
outarray	CurlCurl of
generalized	Flag defining if generalised or typical CurlCurl

Definition at line 325 of file Mapping.h.

References v_CurlCurlField().

         {
             v_CurlCurlField( inarray, outarray, generalized);
         }

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
outarray	Divergence of

Definition at line 267 of file Mapping.h.

References v_Divergence().

         {
             v_Divergence( inarray, outarray);
         }  

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 170 of file Mapping.h.

References v_DotGradJacobian().

         {
             v_DotGradJacobian( inarray, outarray);
         } 

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.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, m_fields, m_session, and Vmath::Zero().

Referenced by v_InitObject(), and v_UpdateMapping().

 {
     ASSERTL0(pSession->DefinesFunction(pFunctionName),
              "Function '" + pFunctionName + "' does not exist.");
 
     unsigned int nq = pFields[0]->GetNpoints();
     if (pArray.num_elements() != 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.num_elements(), vCoeffs, 1);
 
         LibUtilities::FieldIOSharedPtr fld =
             MemoryManager<LibUtilities::FieldIO>::AllocateSharedPtr
                                                 (m_session->GetComm());
         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_IterPerExp(vCoeffs, pArray);
     }
 }

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 381 of file Mapping.cpp.

References ASSERTL0.

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

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 134 of file Mapping.h.

References v_GetCartesianCoordinates().

Referenced by v_UpdateBCs().

         {
             v_GetCartesianCoordinates( out0, out1, out2);
         }

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 245 of file Mapping.h.

References v_GetCoordVelocity().

Referenced by v_UpdateBCs().

         {
             v_GetCoordVelocity( outarray);
         }

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 185 of file Mapping.h.

References v_GetInvMetricTensor().

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

         {
             v_GetInvMetricTensor( outarray);
         }

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.

References v_GetJacobian().

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

         {
             v_GetJacobian( outarray);
         } 

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

inline

Get the metric tensor $g_{ij}$ .

Definition at line 178 of file Mapping.h.

References v_GetMetricTensor().

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

         {
             v_GetMetricTensor( outarray);
         }  

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
outarray	Second order derivatives $u^{i}_{,jk}$

Definition at line 307 of file Mapping.h.

References v_gradgradU().

Referenced by v_CurlCurlField().

         {
             v_gradgradU( inarray, outarray);
         }

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

inline

Get flag defining if mapping has constant Jacobian.

Definition at line 365 of file Mapping.h.

References m_constantJacobian.

Referenced by v_DotGradJacobian().

         {
             return m_constantJacobian;
         }

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 76 of file Mapping.h.

References v_InitObject().

Referenced by ReplaceField().

         {
             v_InitObject( pFields, pMapping);
         }

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

inline

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

Definition at line 371 of file Mapping.h.

References m_isDefined.

         {
             return m_isDefined;
         }

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

inline

Get flag defining if mapping is defined by a function.

Definition at line 353 of file Mapping.h.

References m_fromFunction.

         {
             return m_fromFunction;
         } 

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

inline

Get flag defining if mapping is time-dependent.

Definition at line 341 of file Mapping.h.

References m_timeDependent.

Referenced by v_UpdateBCs().

         {
             return m_timeDependent;
         } 

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 264 of file Mapping.cpp.

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

Referenced by Nektar::Utilities::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().

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

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 607 of file Mapping.cpp.

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

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

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 301 of file Mapping.cpp.

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

 {
     // 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]->FwdTrans_IterPerExp(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]->FwdTrans_IterPerExp(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);
         }
     }
 }

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 638 of file Mapping.cpp.

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

Referenced by v_CurlCurlField(), and v_VelocityLaplacian().

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

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 241 of file Mapping.cpp.

References InitObject(), m_fields, and m_session.

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

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 359 of file Mapping.h.

References m_fromFunction.

         {
             m_fromFunction = value;
         }

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

inline

Set flag defining if mapping is time-dependent.

Definition at line 347 of file Mapping.h.

References m_timeDependent.

         {
             m_timeDependent = value;
         }

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

inline

Update the Dirichlet Boundary Conditions when using Mappings.

Definition at line 381 of file Mapping.h.

References v_UpdateBCs().

         {
             v_UpdateBCs(time);
         }

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

inline

Recompute the metric terms of the Mapping.

Definition at line 397 of file Mapping.h.

References v_UpdateGeomInfo().

Referenced by v_InitObject(), and v_UpdateMapping().

         {
             v_UpdateGeomInfo();
         }

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 387 of file Mapping.h.

References v_UpdateMapping().

         {
             v_UpdateMapping( time, coords, coordsVel);
         }

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

Referenced by ApplyChristoffelContravar().

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

Referenced by ApplyChristoffelCovar().

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

Referenced by ContravarFromCartesian().

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

Referenced by ContravarToCartesian().

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

Referenced by CovarFromCartesian().

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

Referenced by CovarToCartesian().

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

protectedvirtual

Definition at line 1009 of file Mapping.cpp.

References Nektar::MultiRegions::DirCartesianMap, gradgradU(), m_fields, m_nConvectiveFields, m_tmp, RaiseIndex(), Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), and Vmath::Vsub().

Referenced by CurlCurlField().

 {
     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
     {
         switch(nvel)
         {
             case 2:
             {
                 Array<OneD,NekDouble> Vx(physTot);
                 Array<OneD,NekDouble> Uy(physTot);
                 Array<OneD,NekDouble> Dummy(physTot);
 
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], 
                                                         inarray[1], Vx);
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], 
                                                         inarray[0], Uy);
 
                 Vmath::Vsub(physTot, Vx, 1, Uy, 1, Dummy, 1);
 
                 m_fields[0]->PhysDeriv(Dummy,outarray[1],outarray[0]);
 
                 Vmath::Smul(physTot, -1.0, outarray[1], 1, outarray[1], 1);
             }
             break;
 
             case 3:
             {
                 // Declare variables
                 Array<OneD,NekDouble> Ux(physTot);
                 Array<OneD,NekDouble> Uy(physTot);
                 Array<OneD,NekDouble> Uz(physTot);
 
                 Array<OneD,NekDouble> Vx(physTot);
                 Array<OneD,NekDouble> Vy(physTot);
                 Array<OneD,NekDouble> Vz(physTot);
 
                 Array<OneD,NekDouble> Wx(physTot);
                 Array<OneD,NekDouble> Wy(physTot);
                 Array<OneD,NekDouble> Wz(physTot);
 
                 Array<OneD,NekDouble> Dummy1(physTot);
                 Array<OneD,NekDouble> Dummy2(physTot);
 
                 // Calculate gradient
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], 
                                                             inarray[0], Ux);
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], 
                                                             inarray[0], Uy);
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2], 
                                                             inarray[0], Uz);
 
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], 
                                                             inarray[1], Vx);
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], 
                                                             inarray[1], Vy);
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2], 
                                                             inarray[1], Vz);
 
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], 
                                                             inarray[2], Wx);
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], 
                                                             inarray[2], Wy);
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2], 
                                                             inarray[2], Wz);
 
                 // x-component
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1],
                                                             Vx, Dummy1); //Vxy
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1],
                                                             Uy, Dummy2); //Uyy
                 Vmath::Vsub(physTot, Dummy1, 1, Dummy2, 1, outarray[0], 1);
 
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
                                                             Uz, Dummy1); //Uzz
                 Vmath::Vsub(physTot, outarray[0],   1, Dummy1, 1, 
                                                         outarray[0], 1);
 
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0],
                                                             Wz, Dummy2); //Wxz
                 Vmath::Vadd(physTot, outarray[0],   1, Dummy2, 1, 
                                                         outarray[0], 1);
 
                 // y-component
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1],
                                                             Wz, Dummy1); //Wzy
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[2],
                                                             Vz, Dummy2); //Vzz       
                 Vmath::Vsub(physTot, Dummy1, 1, Dummy2, 1, outarray[1], 1);
 
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0],
                                                             Vx, Dummy1); //Vxx
                 Vmath::Vsub(physTot, outarray[1],   1, Dummy1, 1,  
                                                         outarray[1], 1);
 
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0],
                                                             Uy, Dummy2); //Uyx
                 Vmath::Vadd(physTot, outarray[1],   1, Dummy2, 1,  
                                                         outarray[1], 1);
 
                 // z-component
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0],
                                                             Uz, Dummy1); //Uxz
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1],
                                                             Wy, Dummy2); //Wyy       
                 Vmath::Vsub(physTot, Dummy1, 1, Dummy2, 1, outarray[2], 1);
 
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[0], 
                                                             Wx, Dummy1); //Wxx
                 Vmath::Vsub(physTot, outarray[2],   1, Dummy1, 1,  
                                                         outarray[2], 1);
 
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[1], 
                                                             Vz, Dummy2); //Vyz
                 Vmath::Vadd(physTot, outarray[2],   1, Dummy2, 1,  
                                                         outarray[2], 1);
             }
             break;
         }
     }
 
     // Restore value of wavespace 
     m_fields[0]->SetWaveSpace(wavespace);
 }

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

protectedvirtual

Definition at line 763 of file Mapping.cpp.

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

Referenced by Divergence().

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

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

protectedvirtual

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

Definition at line 687 of file Mapping.cpp.

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

Referenced by DotGradJacobian().

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

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

protectedvirtual

Definition at line 659 of file Mapping.cpp.

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

Referenced by GetCartesianCoordinates().

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

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

protectedvirtual

Definition at line 675 of file Mapping.cpp.

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

Referenced by GetCoordVelocity().

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

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

protectedpure virtual

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

Referenced by GetInvMetricTensor().

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

protectedpure virtual

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

Referenced by GetJacobian().

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

protectedpure virtual

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

Referenced by GetMetricTensor().

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

protectedvirtual

Definition at line 899 of file Mapping.cpp.

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

Referenced by gradgradU().

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

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

Definition at line 98 of file Mapping.cpp.

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

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

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

protectedvirtual

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

Definition at line 717 of file Mapping.cpp.

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

Referenced by LowerIndex().

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

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

protectedvirtual

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

Definition at line 740 of file Mapping.cpp.

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

Referenced by RaiseIndex().

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

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

protectedvirtual

Casting the bnd exp to the specific case

Definition at line 1185 of file Mapping.cpp.

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

 {
     int physTot = m_fields[0]->GetTotPoints();
     int nvel = m_nConvectiveFields;
     int nfields = m_fields.num_elements();
     int nbnds    = m_fields[0]->GetBndConditions().num_elements();
 
     // Declare variables
     Array<OneD, int> BCtoElmtID;
     Array<OneD, int> BCtoTraceID;
     Array<OneD, const SpatialDomains::BoundaryConditionShPtr> BndConds;
     Array<OneD, MultiRegions::ExpListSharedPtr>  BndExp;
     StdRegions::StdExpansionSharedPtr elmt;
     StdRegions::StdExpansionSharedPtr Bc;
 
     Array<OneD, NekDouble>  ElmtVal(physTot, 0.0);
     Array<OneD, NekDouble>  BndVal(physTot, 0.0);
     Array<OneD, NekDouble>  coordVelElmt(physTot, 0.0);
     Array<OneD, NekDouble>  coordVelBnd(physTot, 0.0);
     Array<OneD, NekDouble>  Vals(physTot, 0.0);
 
     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 =
                     boost::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();
 
             // Loop boundary conditions again to get correct
             //    values for cnt
             int cnt = 0;
             for(int m = 0 ; m < nbnds; ++m)
             {
                 int exp_size = BndExp[m]->GetExpSize();
                 if (m==n && isDirichlet[i])
                 {
                     for (int j = 0; j < exp_size; ++j, cnt++)
                     {
                         m_fields[i]->GetBoundaryToElmtMap(BCtoElmtID,
                                                           BCtoTraceID);
                         /// Casting the bnd exp to the specific case
                         Bc =  boost::dynamic_pointer_cast<
                                 StdRegions::StdExpansion> 
                                 (BndExp[n]->GetExp(j));
                         // Get element expansion
                         elmt = m_fields[i]->GetExp(BCtoElmtID[cnt]);
                         // Get values on the element
                         ElmtVal  = values[i] + 
                                    m_fields[i]->GetPhys_Offset(
                                                     BCtoElmtID[cnt]);
                         // Get values on boundary
                         elmt->GetTracePhysVals(BCtoTraceID[cnt], 
                                                    Bc, ElmtVal, BndVal);
 
                         // Pointer to value that should be updated
                         Vals = BndExp[n]->UpdatePhys()
                                     + BndExp[n]->GetPhys_Offset(j);
 
                         // Copy result
                         Vmath::Vcopy(Bc->GetTotPoints(), 
                                                 BndVal, 1, Vals, 1);
 
                         // Apply MovingBody correction
                         if (  (i<nvel) && 
                               BndConds[n]->GetUserDefined() == 
                               "MovingBody" )
                         {
                             // get coordVel in the element
                             coordVelElmt  = coordVel[i] + 
                                             m_fields[i]->GetPhys_Offset(
                                                 BCtoElmtID[cnt]);
 
                             // Get values on boundary
                             elmt->GetTracePhysVals(
                                         BCtoTraceID[cnt], Bc,
                                         coordVelElmt, coordVelBnd);
 
                             // Apply correction
                             Vmath::Vadd(Bc->GetTotPoints(), 
                                                 coordVelBnd, 1, 
                                                 Vals, 1, Vals, 1);
                         }
                     }
                 }
                 else // setting if m!=n
                 {
                     cnt += exp_size;
                 }
             }
         }
     }
 
     // Finally, perform FwdTrans in all fields
     for (int i = 0; i < m_fields.num_elements(); ++i)
     {
         // Get boundary condition information
         BndConds   = m_fields[i]->GetBndConditions();
         BndExp     = m_fields[i]->GetBndCondExpansions();
         for(int n = 0 ; n < BndConds.num_elements(); ++n)
         {   
             if ( BndConds[n]->GetBoundaryConditionType() == 
                     SpatialDomains::eDirichlet)
             {
                 BndExp[n]->FwdTrans_BndConstrained(BndExp[n]->GetPhys(),
                                             BndExp[n]->UpdateCoeffs());
                 if (m_fields[i]->GetExpType() == MultiRegions::e3DH1D)
                 {
                     BndExp[n]->HomogeneousFwdTrans(BndExp[n]->GetCoeffs(),
                                             BndExp[n]->UpdateCoeffs());
                 }
             }
         }
     }
 }

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

protectedpure virtual

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

Referenced by UpdateGeomInfo().

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 1386 of file Mapping.cpp.

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

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

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 792 of file Mapping.cpp.

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

Referenced by VelocityLaplacian().

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

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
outarray	Result of the operation
alpha	The constant $\alpha$

Definition at line 290 of file Mapping.h.

References v_VelocityLaplacian().

         {
             v_VelocityLaplacian( inarray, outarray, alpha);
         } 

Member Data Documentation

bool Nektar::GlobalMapping::Mapping::m_constantJacobian

protected

Flag defining if the Jacobian is constant.

Definition at line 427 of file Mapping.h.

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

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

protected

Array with the Cartesian coordinates.

Definition at line 411 of file Mapping.h.

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

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

protected

Array with the velocity of the coordinates.

Definition at line 413 of file Mapping.h.

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

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

protected

Definition at line 409 of file Mapping.h.

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

protected

Definition at line 407 of file Mapping.h.

Referenced by Mapping(), and Output().

bool Nektar::GlobalMapping::Mapping::m_fromFunction

protected

Flag defining if the Mapping is defined by a function.

Definition at line 431 of file Mapping.h.

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

string Nektar::GlobalMapping::Mapping::m_funcName

protected

Name of the function containing the coordinates.

Definition at line 420 of file Mapping.h.

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

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

protected

Array with metric terms of the mapping.

Definition at line 415 of file Mapping.h.

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

staticprotected

Definition at line 435 of file Mapping.h.

Referenced by Load().

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

staticprotected

Definition at line 436 of file Mapping.h.

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

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

staticprotected

Definition at line 434 of file Mapping.h.

Referenced by Load().

int Nektar::GlobalMapping::Mapping::m_nConvectiveFields

protected

Number of velocity components.

Definition at line 417 of file Mapping.h.

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

protected

Session reader.

Definition at line 405 of file Mapping.h.

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

bool Nektar::GlobalMapping::Mapping::m_timeDependent

protected

Flag defining if the Mapping is time-dependent.

Definition at line 429 of file Mapping.h.

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

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

protected

Definition at line 441 of file Mapping.h.

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

string Nektar::GlobalMapping::Mapping::m_velFuncName

protected

Name of the function containing the velocity of the coordinates.

Definition at line 422 of file Mapping.h.

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

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

protected

Definition at line 439 of file Mapping.h.

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

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

protected

Definition at line 440 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

Member Function Documentation

Member Data Documentation