A base class for describing how to solve specific equations. More...

#include <EquationSystem.h>

Inheritance diagram for Nektar::SolverUtils::EquationSystem:

Collaboration diagram for Nektar::SolverUtils::EquationSystem:

Public Member Functions
virtual SOLVER_UTILS_EXPORT	~EquationSystem ()
	Destructor. More...

SOLVER_UTILS_EXPORT void	SetUpTraceNormals (void)

SOLVER_UTILS_EXPORT void	InitObject ()
	Initialises the members of this object. More...

SOLVER_UTILS_EXPORT void	DoInitialise ()
	Perform any initialisation necessary before solving the problem. More...

SOLVER_UTILS_EXPORT void	DoSolve ()
	Solve the problem. More...

SOLVER_UTILS_EXPORT void	TransCoeffToPhys ()
	Transform from coefficient to physical space. More...

SOLVER_UTILS_EXPORT void	TransPhysToCoeff ()
	Transform from physical to coefficient space. More...

SOLVER_UTILS_EXPORT void	Output ()
	Perform output operations after solve. More...

SOLVER_UTILS_EXPORT NekDouble	LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
	Linf error computation. More...

SOLVER_UTILS_EXPORT std::string	GetSessionName ()
	Get Session name. More...

template<class T >
boost::shared_ptr< T >	as ()

SOLVER_UTILS_EXPORT void	ResetSessionName (std::string newname)
	Reset Session name. More...

SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr	GetSession ()
	Get Session name. More...

SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr	GetPressure ()
	Get pressure field if available. More...

SOLVER_UTILS_EXPORT void	PrintSummary (std::ostream &out)
	Print a summary of parameters and solver characteristics. More...

SOLVER_UTILS_EXPORT void	SetLambda (NekDouble lambda)
	Set parameter m_lambda. More...

SOLVER_UTILS_EXPORT void	EvaluateFunction (Array< OneD, Array< OneD, NekDouble > > &pArray, std::string pFunctionName, const NekDouble pTime=0.0, const int domain=0)
	Evaluates a function as specified in the session file. More...

SOLVER_UTILS_EXPORT void	EvaluateFunction (std::vector< std::string > pFieldNames, Array< OneD, Array< OneD, NekDouble > > &pFields, const std::string &pName, const NekDouble &pTime=0.0, const int domain=0)
	Populate given fields with the function from session. More...

SOLVER_UTILS_EXPORT void	EvaluateFunction (std::vector< std::string > pFieldNames, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const std::string &pName, const NekDouble &pTime=0.0, const int domain=0)
	Populate given fields with the function from session. More...

SOLVER_UTILS_EXPORT void	EvaluateFunction (std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, const NekDouble &pTime=0.0, const int domain=0)

SOLVER_UTILS_EXPORT std::string	DescribeFunction (std::string pFieldName, const std::string &pFunctionName, const int domain)
	Provide a description of a function for a given field name. More...

SOLVER_UTILS_EXPORT void	InitialiseBaseFlow (Array< OneD, Array< OneD, NekDouble > > &base)
	Perform initialisation of the base flow. More...

SOLVER_UTILS_EXPORT void	SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
	Initialise the data in the dependent fields. More...

SOLVER_UTILS_EXPORT void	EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
	Evaluates an exact solution. More...

SOLVER_UTILS_EXPORT NekDouble	L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
	Compute the L2 error between fields and a given exact solution. More...

SOLVER_UTILS_EXPORT NekDouble	L2Error (unsigned int field, bool Normalised=false)
	Compute the L2 error of the fields. More...

SOLVER_UTILS_EXPORT Array < OneD, NekDouble >	ErrorExtraPoints (unsigned int field)
	Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...

SOLVER_UTILS_EXPORT void	WeakAdvectionGreensDivergenceForm (const Array< OneD, Array< OneD, NekDouble > > &F, Array< OneD, NekDouble > &outarray)
	Compute the inner product $(\nabla \phi \cdot F)$ . More...

SOLVER_UTILS_EXPORT void	WeakAdvectionDivergenceForm (const Array< OneD, Array< OneD, NekDouble > > &F, Array< OneD, NekDouble > &outarray)
	Compute the inner product $(\phi, \nabla \cdot F)$ . More...

SOLVER_UTILS_EXPORT void	WeakAdvectionNonConservativeForm (const Array< OneD, Array< OneD, NekDouble > > &V, const Array< OneD, const NekDouble > &u, Array< OneD, NekDouble > &outarray, bool UseContCoeffs=false)
	Compute the inner product $(\phi, V\cdot \nabla u)$ . More...

f SOLVER_UTILS_EXPORT void	AdvectionNonConservativeForm (const Array< OneD, Array< OneD, NekDouble > > &V, const Array< OneD, const NekDouble > &u, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wk=NullNekDouble1DArray)
	Compute the non-conservative advection. More...

SOLVER_UTILS_EXPORT void	WeakDGAdvection (const Array< OneD, Array< OneD, NekDouble > > &InField, Array< OneD, Array< OneD, NekDouble > > &OutField, bool NumericalFluxIncludesNormal=true, bool InFieldIsInPhysSpace=false, int nvariables=0)
	Calculate the weak discontinuous Galerkin advection. More...

SOLVER_UTILS_EXPORT void	WeakDGDiffusion (const Array< OneD, Array< OneD, NekDouble > > &InField, Array< OneD, Array< OneD, NekDouble > > &OutField, bool NumericalFluxIncludesNormal=true, bool InFieldIsInPhysSpace=false)
	Calculate weak DG Diffusion in the LDG form. More...

SOLVER_UTILS_EXPORT void	Checkpoint_Output (const int n)
	Write checkpoint file of m_fields. More...

SOLVER_UTILS_EXPORT void	Checkpoint_Output (const int n, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
	Write checkpoint file of custom data fields. More...

SOLVER_UTILS_EXPORT void	Checkpoint_BaseFlow (const int n)
	Write base flow file of m_fields. More...

SOLVER_UTILS_EXPORT void	WriteFld (const std::string &outname)
	Write field data to the given filename. More...

SOLVER_UTILS_EXPORT void	WriteFld (const std::string &outname, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
	Write input fields to the given filename. More...

SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
	Input field data from the given file. More...

SOLVER_UTILS_EXPORT void	ImportFldToMultiDomains (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int ndomains)
	Input field data from the given file to multiple domains. More...

SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, std::vector< std::string > &fieldStr, Array< OneD, Array< OneD, NekDouble > > &coeffs)
	Output a field. Input field data into array from the given file. More...

SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, MultiRegions::ExpListSharedPtr &pField, std::string &pFieldName)
	Output a field. Input field data into ExpList from the given file. More...

SOLVER_UTILS_EXPORT void	ScanForHistoryPoints ()
	Builds map of which element holds each history point. More...

SOLVER_UTILS_EXPORT void	WriteHistoryData (std::ostream &out)
	Probe each history point and write to file. More...

SOLVER_UTILS_EXPORT void	SessionSummary (SummaryList &vSummary)
	Write out a session summary. More...

SOLVER_UTILS_EXPORT Array < OneD, MultiRegions::ExpListSharedPtr > &	UpdateFields ()

SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMap &	UpdateFieldMetaDataMap ()
	Get hold of FieldInfoMap so it can be updated. More...

SOLVER_UTILS_EXPORT NekDouble	GetFinalTime ()
	Return final time. More...

SOLVER_UTILS_EXPORT int	GetNcoeffs ()

SOLVER_UTILS_EXPORT int	GetNcoeffs (const int eid)

SOLVER_UTILS_EXPORT int	GetNumExpModes ()

SOLVER_UTILS_EXPORT const Array< OneD, int >	GetNumExpModesPerExp ()

SOLVER_UTILS_EXPORT int	GetNvariables ()

SOLVER_UTILS_EXPORT const std::string	GetVariable (unsigned int i)

SOLVER_UTILS_EXPORT int	GetTraceTotPoints ()

SOLVER_UTILS_EXPORT int	GetTraceNpoints ()

SOLVER_UTILS_EXPORT int	GetExpSize ()

SOLVER_UTILS_EXPORT int	GetPhys_Offset (int n)

SOLVER_UTILS_EXPORT int	GetCoeff_Offset (int n)

SOLVER_UTILS_EXPORT int	GetTotPoints ()

SOLVER_UTILS_EXPORT int	GetTotPoints (int n)

SOLVER_UTILS_EXPORT int	GetNpoints ()

SOLVER_UTILS_EXPORT int	GetNumElmVelocity ()

SOLVER_UTILS_EXPORT int	GetSteps ()

SOLVER_UTILS_EXPORT NekDouble	GetTimeStep ()

SOLVER_UTILS_EXPORT void	CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)

SOLVER_UTILS_EXPORT void	CopyToPhysField (const int i, Array< OneD, NekDouble > &output)

SOLVER_UTILS_EXPORT void	SetSteps (const int steps)

SOLVER_UTILS_EXPORT void	ZeroPhysFields ()

SOLVER_UTILS_EXPORT void	FwdTransFields ()

SOLVER_UTILS_EXPORT void	GetFluxVector (const int i, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)

SOLVER_UTILS_EXPORT void	GetFluxVector (const int i, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &fluxX, Array< OneD, Array< OneD, NekDouble > > &fluxY)

SOLVER_UTILS_EXPORT void	GetFluxVector (const int i, const int j, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)

SOLVER_UTILS_EXPORT void	NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numflux)

SOLVER_UTILS_EXPORT void	NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxX, Array< OneD, Array< OneD, NekDouble > > &numfluxY)

SOLVER_UTILS_EXPORT void	NumFluxforScalar (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &uflux)

SOLVER_UTILS_EXPORT void	NumFluxforVector (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &qfield, Array< OneD, Array< OneD, NekDouble > > &qflux)

SOLVER_UTILS_EXPORT void	SetModifiedBasis (const bool modbasis)

SOLVER_UTILS_EXPORT int	NoCaseStringCompare (const std::string &s1, const std::string &s2)
	Perform a case-insensitive string comparison. More...

SOLVER_UTILS_EXPORT int	GetCheckpointNumber ()

SOLVER_UTILS_EXPORT void	SetCheckpointNumber (int num)

SOLVER_UTILS_EXPORT int	GetCheckpointSteps ()

SOLVER_UTILS_EXPORT void	SetCheckpointSteps (int num)

SOLVER_UTILS_EXPORT void	SetTime (const NekDouble time)

SOLVER_UTILS_EXPORT void	SetInitialStep (const int step)

SOLVER_UTILS_EXPORT void	SetBoundaryConditions (NekDouble time)
	Evaluates the boundary conditions at the given time. More...

virtual SOLVER_UTILS_EXPORT bool	v_NegatedOp ()
	Virtual function to identify if operator is negated in DoSolve. More...

Protected Types
enum	HomogeneousType { eHomogeneous1D, eHomogeneous2D, eHomogeneous3D, eNotHomogeneous }
	Parameter for homogeneous expansions. More...

Protected Member Functions
SOLVER_UTILS_EXPORT	EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession)
	Initialises EquationSystem class members. More...

int	nocase_cmp (const std::string &s1, const std::string &s2)

virtual SOLVER_UTILS_EXPORT void	v_InitObject ()
	Initialisation object for EquationSystem. More...

virtual SOLVER_UTILS_EXPORT void	v_DoInitialise ()
	Virtual function for initialisation implementation. More...

virtual SOLVER_UTILS_EXPORT void	v_DoSolve ()
	Virtual function for solve implementation. More...

virtual SOLVER_UTILS_EXPORT NekDouble	v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
	Virtual function for the L_inf error computation between fields and a given exact solution. More...

virtual SOLVER_UTILS_EXPORT NekDouble	v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
	Virtual function for the L_2 error computation between fields and a given exact solution. More...

virtual SOLVER_UTILS_EXPORT void	v_TransCoeffToPhys ()
	Virtual function for transformation to physical space. More...

virtual SOLVER_UTILS_EXPORT void	v_TransPhysToCoeff ()
	Virtual function for transformation to coefficient space. More...

virtual SOLVER_UTILS_EXPORT void	v_GenerateSummary (SummaryList &l)
	Virtual function for generating summary information. More...

virtual SOLVER_UTILS_EXPORT void	v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)

virtual SOLVER_UTILS_EXPORT void	v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)

SOLVER_UTILS_EXPORT void	EvaluateFunctionExp (std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, const NekDouble &pTime=0.0, const int domain=0)

SOLVER_UTILS_EXPORT void	EvaluateFunctionFld (std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, const NekDouble &pTime=0.0, const int domain=0)

SOLVER_UTILS_EXPORT void	EvaluateFunctionPts (std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, const NekDouble &pTime=0.0, const int domain=0)

SOLVER_UTILS_EXPORT void	LoadPts (std::string funcFilename, std::string filename, Nektar::LibUtilities::PtsFieldSharedPtr &outPts)

SOLVER_UTILS_EXPORT void	SetUpBaseFields (SpatialDomains::MeshGraphSharedPtr &mesh)

SOLVER_UTILS_EXPORT void	ImportFldBase (std::string pInfile, SpatialDomains::MeshGraphSharedPtr pGraph)

virtual SOLVER_UTILS_EXPORT void	v_Output (void)

virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr	v_GetPressure (void)

virtual SOLVER_UTILS_EXPORT void	v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)

Protected Attributes
LibUtilities::CommSharedPtr	m_comm
	Communicator. More...

LibUtilities::SessionReaderSharedPtr	m_session
	The session reader. More...

LibUtilities::FieldIOSharedPtr	m_fld
	Field input/output. More...

std::map< std::string, FieldUtils::Interpolator >	m_interpolators
	Map of interpolator objects. More...

std::map< std::string, std::pair< std::string, LibUtilities::PtsFieldSharedPtr > >	m_loadedPtsFields
	pts fields we already read from disk: {funcFilename: (filename, ptsfield)} More...

std::map< std::string, std::pair< std::string, loadedFldField > >	m_loadedFldFields

Array< OneD, MultiRegions::ExpListSharedPtr >	m_fields
	Array holding all dependent variables. More...

Array< OneD, MultiRegions::ExpListSharedPtr >	m_base
	Base fields. More...

Array< OneD, MultiRegions::ExpListSharedPtr >	m_derivedfields
	Array holding all dependent variables. More...

SpatialDomains::BoundaryConditionsSharedPtr	m_boundaryConditions
	Pointer to boundary conditions object. More...

SpatialDomains::MeshGraphSharedPtr	m_graph
	Pointer to graph defining mesh. More...

std::string	m_sessionName
	Name of the session. More...

NekDouble	m_time
	Current time of simulation. More...

int	m_initialStep
	Number of the step where the simulation should begin. More...

NekDouble	m_fintime
	Finish time of the simulation. More...

NekDouble	m_timestep
	Time step size. More...

NekDouble	m_lambda
	Lambda constant in real system if one required. More...

NekDouble	m_checktime
	Time between checkpoints. More...

int	m_nchk
	Number of checkpoints written so far. More...

int	m_steps
	Number of steps to take. More...

int	m_checksteps
	Number of steps between checkpoints. More...

int	m_spacedim
	Spatial dimension (>= expansion dim). More...

int	m_expdim
	Expansion dimension. More...

bool	m_singleMode
	Flag to determine if single homogeneous mode is used. More...

bool	m_halfMode
	Flag to determine if half homogeneous mode is used. More...

bool	m_multipleModes
	Flag to determine if use multiple homogenenous modes are used. More...

bool	m_useFFT
	Flag to determine if FFT is used for homogeneous transform. More...

bool	m_homogen_dealiasing
	Flag to determine if dealiasing is used for homogeneous simulations. More...

bool	m_specHP_dealiasing
	Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More...

enum MultiRegions::ProjectionType	m_projectionType
	Type of projection; e.g continuous or discontinuous. More...

Array< OneD, Array< OneD, NekDouble > >	m_traceNormals
	Array holding trace normals for DG simulations in the forwards direction. More...

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_gradtan
	1 x nvariable x nq More...

Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_tanbasis
	2 x m_spacedim x nq More...

Array< OneD, bool >	m_checkIfSystemSingular
	Flag to indicate if the fields should be checked for singularity. More...

LibUtilities::FieldMetaDataMap	m_fieldMetaDataMap
	Map to identify relevant solver info to dump in output fields. More...

int	m_NumQuadPointsError
	Number of Quadrature points used to work out the error. More...

enum HomogeneousType	m_HomogeneousType

NekDouble	m_LhomX
	physical length in X direction (if homogeneous) More...

NekDouble	m_LhomY
	physical length in Y direction (if homogeneous) More...

NekDouble	m_LhomZ
	physical length in Z direction (if homogeneous) More...

int	m_npointsX
	number of points in X direction (if homogeneous) More...

int	m_npointsY
	number of points in Y direction (if homogeneous) More...

int	m_npointsZ
	number of points in Z direction (if homogeneous) More...

int	m_HomoDirec
	number of homogenous directions More...

Private Member Functions
virtual SOLVER_UTILS_EXPORT Array< OneD, bool >	v_GetSystemSingularChecks ()

virtual SOLVER_UTILS_EXPORT void	v_GetFluxVector (const int i, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)

virtual SOLVER_UTILS_EXPORT void	v_GetFluxVector (const int i, const int j, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)

virtual SOLVER_UTILS_EXPORT void	v_GetFluxVector (const int i, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &fluxX, Array< OneD, Array< OneD, NekDouble > > &fluxY)

virtual SOLVER_UTILS_EXPORT void	v_NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numflux)

virtual SOLVER_UTILS_EXPORT void	v_NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxX, Array< OneD, Array< OneD, NekDouble > > &numfluxY)

virtual SOLVER_UTILS_EXPORT void	v_NumFluxforScalar (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &uflux)

virtual SOLVER_UTILS_EXPORT void	v_NumFluxforVector (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &qfield, Array< OneD, Array< OneD, NekDouble > > &qflux)

SOLVER_UTILS_EXPORT void	PrintProgressbar (const int position, const int goal) const

Detailed Description

A base class for describing how to solve specific equations.

This class is a base class for all solver implementations. It provides the underlying generic functionality and interface for solving equations.

To solve a steady-state equation, create a derived class from this class and reimplement the virtual functions to provide custom implementation for the problem.

To solve unsteady problems, derive from the UnsteadySystem class instead which provides general time integration.

Definition at line 77 of file EquationSystem.h.

Member Enumeration Documentation

enum Nektar::SolverUtils::EquationSystem::HomogeneousType

protected

Parameter for homogeneous expansions.

Enumerator
eHomogeneous1D
eHomogeneous2D
eHomogeneous3D
eNotHomogeneous

Definition at line 538 of file EquationSystem.h.

             {
                 eHomogeneous1D,
                 eHomogeneous2D,
                 eHomogeneous3D,
                 eNotHomogeneous
             };

Constructor & Destructor Documentation

Nektar::SolverUtils::EquationSystem::~EquationSystem ( )

virtual

Destructor.

Destructor for class EquationSystem.

Definition at line 674 of file EquationSystem.cpp.

         {
             LibUtilities::NekManager<LocalRegions::MatrixKey,
                 DNekScalMat, LocalRegions::MatrixKey::opLess>::ClearManager();
             LibUtilities::NekManager<LocalRegions::MatrixKey,
                 DNekScalBlkMat, LocalRegions::MatrixKey::opLess>::ClearManager();
         }

Nektar::SolverUtils::EquationSystem::EquationSystem ( const LibUtilities::SessionReaderSharedPtr & pSession )

protected

Initialises EquationSystem class members.

This constructor is protected as the objects of this class are never instantiated directly.

Parameters

pSession The session reader holding problem parameters.

Definition at line 97 of file EquationSystem.cpp.

References m_fieldMetaDataMap, and m_session.

             : m_comm (pSession->GetComm()),
               m_session (pSession),
               m_lambda (0),
               m_fieldMetaDataMap(LibUtilities::NullFieldMetaDataMap)
         {
             // set up session names in fieldMetaDataMap
             const vector<std::string> filenames = m_session->GetFilenames();
             
             for(int i = 0; i < filenames.size(); ++i)
             {
                 string sessionname = "SessionName";
                 sessionname += boost::lexical_cast<std::string>(i);
                 m_fieldMetaDataMap[sessionname] = filenames[i];
                 m_fieldMetaDataMap["ChkFileNum"] = boost::lexical_cast<std::string>(0);
             }
             
         }

Member Function Documentation

void Nektar::SolverUtils::EquationSystem::AdvectionNonConservativeForm	(	const Array< OneD, Array< OneD, NekDouble > > &	V,
		const Array< OneD, const NekDouble > &	u,
		Array< OneD, NekDouble > &	outarray,
		Array< OneD, NekDouble > &	wk = `NullNekDouble1DArray`
	)

Compute the non-conservative advection.

Calculate the inner product $V\cdot \nabla u$

Parameters

V	Fields.
u	Fields.
outarray	Storage for result.
wk	Workspace.

Definition at line 1802 of file EquationSystem.cpp.

References ASSERTL0, m_fields, Vmath::Vmul(), and Vmath::Vvtvp().

Referenced by Nektar::CFLtester::DoOdeRhs(), Nektar::EigenValuesAdvection::v_DoSolve(), and WeakAdvectionNonConservativeForm().

         {
             // Use dimension of Velocity vector to dictate dimension of operation
             int ndim       = V.num_elements();
             //int ndim = m_expdim;
 
             // ToDo: here we should add a check that V has right dimension
 
             int nPointsTot = m_fields[0]->GetNpoints();
             Array<OneD, NekDouble> grad0,grad1,grad2;
 
             // Check to see if wk space is defined
             if (wk.num_elements())
             {
                 grad0 = wk;
             }
             else
             {
                 grad0 = Array<OneD, NekDouble> (nPointsTot);
             }
 
             // Evaluate V\cdot Grad(u)
             switch(ndim)
             {
                 case 1:
                     m_fields[0]->PhysDeriv(u,grad0);
                     Vmath::Vmul(nPointsTot, grad0, 1, V[0], 1, outarray,1);
                     break;
                 case 2:
                     grad1 = Array<OneD, NekDouble> (nPointsTot);
                     m_fields[0]->PhysDeriv(u, grad0, grad1);
                     Vmath::Vmul (nPointsTot, grad0, 1, V[0], 1, outarray, 1);
                     Vmath::Vvtvp(nPointsTot, grad1, 1, V[1], 1,
                                  outarray, 1, outarray, 1);
                     break;
                 case 3:
                     grad1 = Array<OneD, NekDouble> (nPointsTot);
                     grad2 = Array<OneD, NekDouble> (nPointsTot);
                     m_fields[0]->PhysDeriv(u,grad0,grad1,grad2);
                     Vmath::Vmul (nPointsTot, grad0, 1, V[0], 1, outarray, 1);
                     Vmath::Vvtvp(nPointsTot, grad1, 1, V[1], 1,
                                  outarray, 1, outarray, 1);
                     Vmath::Vvtvp(nPointsTot, grad2, 1, V[2], 1,
                                  outarray, 1, outarray, 1);
                     break;
                 default:
                     ASSERTL0(false,"dimension unknown");
             }
         }

template<class T >

boost::shared_ptr<T> Nektar::SolverUtils::EquationSystem::as ( )

inline

Definition at line 114 of file EquationSystem.h.

References ASSERTL1, and CellMLToNektar.cellml_metadata::p.

             {
 #if defined __INTEL_COMPILER && BOOST_VERSION > 105200
                 typedef typename boost::shared_ptr<T>::element_type E;
                 E * p = dynamic_cast< E* >( shared_from_this().get() );
                 ASSERTL1(p, "Cannot perform cast");
                 return boost::shared_ptr<T>( shared_from_this(), p );
 #else
                 return boost::dynamic_pointer_cast<T>( shared_from_this() );
 #endif
             }

void Nektar::SolverUtils::EquationSystem::Checkpoint_BaseFlow ( const int n )

Write base flow file of m_fields.

Write the n-th base flow into a .chk file

Parameters

n	The index of the base flow file.

Definition at line 2168 of file EquationSystem.cpp.

References m_sessionName, and WriteFld().

         {
             std::string outname =  m_sessionName +  "_BaseFlow_" + 
                 boost::lexical_cast<std::string>(n);
 
             WriteFld(outname + ".chk");
         }

void Nektar::SolverUtils::EquationSystem::Checkpoint_Output ( const int n )

Write checkpoint file of m_fields.

Write the n-th checkpoint file.

Parameters

n	The index of the checkpoint file.

Definition at line 2142 of file EquationSystem.cpp.

References m_sessionName, and WriteFld().

Referenced by Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::CoupledLinearNS::v_DoSolve(), Nektar::IsentropicVortex::v_SetInitialConditions(), Nektar::NonlinearPeregrine::v_SetInitialConditions(), Nektar::CompressibleFlowSystem::v_SetInitialConditions(), and v_SetInitialConditions().

         {
             std::string outname =  m_sessionName +  "_" + 
                 boost::lexical_cast<std::string>(n);
             WriteFld(outname + ".chk");
         }

void Nektar::SolverUtils::EquationSystem::Checkpoint_Output	(	const int	n,
		MultiRegions::ExpListSharedPtr &	field,
		std::vector< Array< OneD, NekDouble > > &	fieldcoeffs,
		std::vector< std::string > &	variables
	)

Write checkpoint file of custom data fields.

Write the n-th checkpoint file.

Parameters

n	The index of the checkpoint file.

Definition at line 2153 of file EquationSystem.cpp.

References m_sessionName, and WriteFld().

         {
             std::string outname =  m_sessionName +  "_" +
                 boost::lexical_cast<std::string>(n);
             WriteFld(outname, field, fieldcoeffs, variables);
         }

void Nektar::SolverUtils::EquationSystem::CopyFromPhysField	(	const int	i,
		Array< OneD, NekDouble > &	output
	)

inline

Definition at line 937 of file EquationSystem.h.

References m_fields, and Vmath::Vcopy().

         {
             Vmath::Vcopy(output.num_elements(), m_fields[i]->GetPhys(), 1, output, 1 );
         }

void Nektar::SolverUtils::EquationSystem::CopyToPhysField	(	const int	i,
		Array< OneD, NekDouble > &	output
	)

inline

Definition at line 943 of file EquationSystem.h.

References m_fields, and Vmath::Vcopy().

         {
             Vmath::Vcopy(output.num_elements(), output, 1, m_fields[i]->UpdatePhys(), 1 );
         }

std::string Nektar::SolverUtils::EquationSystem::DescribeFunction	(	std::string	pFieldName,
		const std::string &	pFunctionName,
		const int	domain
	)

Provide a description of a function for a given field name.

Parameters

pFieldName	Field name.
pFunctionName	Function name.

Definition at line 1119 of file EquationSystem.cpp.

References ASSERTL0, Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, and m_session.

Referenced by v_SetInitialConditions().

         {
             ASSERTL0(m_session->DefinesFunction(pFunctionName),
                      "Function '" + pFunctionName + "' does not exist.");
             
             std::string retVal;
             LibUtilities::FunctionType vType;
             
             vType = m_session->GetFunctionType(pFunctionName, pFieldName);
             if (vType == LibUtilities::eFunctionTypeExpression)
             {
                 LibUtilities::EquationSharedPtr ffunc
                     = m_session->GetFunction(pFunctionName, pFieldName,domain);
                 retVal = ffunc->GetExpression();
             }
             else if (vType == LibUtilities::eFunctionTypeFile)
             {
                 std::string filename
                     = m_session->GetFunctionFilename(pFunctionName, pFieldName,domain);
                 retVal = "from file " + filename;
             }
             
             return retVal;
         }

void Nektar::SolverUtils::EquationSystem::DoInitialise ( )

inline

Perform any initialisation necessary before solving the problem.

This allows initialisation of the solver which cannot be completed during object construction (such as setting of initial conditions).

Public interface routine to virtual function implementation.

Definition at line 717 of file EquationSystem.h.

References v_DoInitialise().

         {
             v_DoInitialise();
         }

void Nektar::SolverUtils::EquationSystem::DoSolve ( void )

inline

Solve the problem.

Performs the actual solve.

Public interface routine to virtual function implementation.

Definition at line 749 of file EquationSystem.h.

References v_DoSolve().

         {
             v_DoSolve();
         }

Array< OneD, NekDouble > Nektar::SolverUtils::EquationSystem::ErrorExtraPoints ( unsigned int field )

Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf].

Compute the error in the L2-norm, L-inf for a larger number of quadrature points.

Parameters

field The field to compare.

Returns: Error in the L2-norm and L-inf norm.

Definition at line 1279 of file EquationSystem.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMAlpha1Beta0, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, GetNumExpModes(), m_fields, m_graph, m_NumQuadPointsError, m_session, and m_time.

Referenced by v_L2Error(), and v_LinfError().

         {
             int NumModes = GetNumExpModes();
             Array<OneD,NekDouble> L2INF(2);
 
             const LibUtilities::PointsKey PkeyT1(
                 m_NumQuadPointsError,LibUtilities::eGaussLobattoLegendre);
             const LibUtilities::PointsKey PkeyT2(
                 m_NumQuadPointsError, LibUtilities::eGaussRadauMAlpha1Beta0);
             const LibUtilities::PointsKey PkeyQ1(
                 m_NumQuadPointsError, LibUtilities::eGaussLobattoLegendre);
             const LibUtilities::PointsKey PkeyQ2(
                 m_NumQuadPointsError, LibUtilities::eGaussLobattoLegendre);
             const LibUtilities::BasisKey  BkeyT1(
                 LibUtilities::eModified_A,NumModes, PkeyT1);
             const LibUtilities::BasisKey  BkeyT2(
                 LibUtilities::eModified_B, NumModes, PkeyT2);
             const LibUtilities::BasisKey  BkeyQ1(
                 LibUtilities::eModified_A, NumModes, PkeyQ1);
             const LibUtilities::BasisKey  BkeyQ2(
                 LibUtilities::eModified_A, NumModes, PkeyQ2);
 
             MultiRegions::ExpList2DSharedPtr ErrorExp =
                 MemoryManager<MultiRegions::ExpList2D>::AllocateSharedPtr(
                         m_session, BkeyT1, BkeyT2, BkeyQ1, BkeyQ2, m_graph);
 
             int ErrorCoordim = ErrorExp->GetCoordim(0);
             int ErrorNq      = ErrorExp->GetTotPoints();
 
             Array<OneD,NekDouble> ErrorXc0(ErrorNq, 0.0);
             Array<OneD,NekDouble> ErrorXc1(ErrorNq, 0.0);
             Array<OneD,NekDouble> ErrorXc2(ErrorNq, 0.0);
 
             switch(ErrorCoordim)
             {
                 case 1:
                     ErrorExp->GetCoords(ErrorXc0);
                     break;
                 case 2:
                     ErrorExp->GetCoords(ErrorXc0, ErrorXc1);
                     break;
                 case 3:
                     ErrorExp->GetCoords(ErrorXc0, ErrorXc1, ErrorXc2);
                     break;
             }
             LibUtilities::EquationSharedPtr exSol = 
                 m_session->GetFunction("ExactSolution", field);
             
             // Evaluate the exact solution
             Array<OneD,NekDouble> ErrorSol(ErrorNq);
 
             exSol->Evaluate(ErrorXc0,ErrorXc1,ErrorXc2,m_time,ErrorSol);
 
             // Calcualte spectral/hp approximation on the quadrature points  
             // of this new expansion basis
             ErrorExp->BwdTrans_IterPerExp(m_fields[field]->GetCoeffs(), 
                                           ErrorExp->UpdatePhys());
 
             L2INF[0] = ErrorExp->L2  (ErrorExp->GetPhys(), ErrorSol);
             L2INF[1] = ErrorExp->Linf(ErrorExp->GetPhys(), ErrorSol);
 
             return L2INF;
         }

void Nektar::SolverUtils::EquationSystem::EvaluateExactSolution	(	int	field,
		Array< OneD, NekDouble > &	outfield,
		const NekDouble	time
	)

inline

Evaluates an exact solution.

Definition at line 828 of file EquationSystem.h.

References v_EvaluateExactSolution().

         {
             v_EvaluateExactSolution(field, outfield, time);
         }

void Nektar::SolverUtils::EquationSystem::EvaluateFunction	(	Array< OneD, Array< OneD, NekDouble > > &	pArray,
		std::string	pFunctionName,
		const NekDouble	pTime = `0.0`,
		const int	domain = `0`
	)

Evaluates a function as specified in the session file.

Evaluates a physical function at each quadrature point in the domain.

Parameters

pArray	The array into which to write the values.
pEqn	The equation to evaluate.

Definition at line 688 of file EquationSystem.cpp.

References ASSERTL0, and m_session.

         {
             ASSERTL0(m_session->DefinesFunction(pFunctionName),
                      "Function '" + pFunctionName + "' does not exist.");
 
             std::vector<std::string> vFieldNames = m_session->GetVariables();
 
             for(int i = 0 ; i < vFieldNames.size(); i++)
             {
                 EvaluateFunction(vFieldNames[i], pArray[i], pFunctionName,
                                  pTime, domain);
             }
         }

void Nektar::SolverUtils::EquationSystem::EvaluateFunction	(	std::vector< std::string >	pFieldNames,
		Array< OneD, Array< OneD, NekDouble > > &	pFields,
		const std::string &	pFunctionName,
		const NekDouble &	pTime = `0.0`,
		const int	domain = `0`
	)

Populate given fields with the function from session.

Populates a forcing function for each of the dependent variables using the expression provided by the BoundaryConditions object.

Parameters

force Array of fields to assign forcing.

Definition at line 711 of file EquationSystem.cpp.

References ASSERTL0, ASSERTL1, EvaluateFunction(), and m_session.

         {
             ASSERTL1(pFieldNames.size() == pFields.num_elements(),
                     "Function '" + pFunctionName +
                         "' variable list size mismatch with array storage.");
             ASSERTL0(m_session->DefinesFunction(pFunctionName),
                     "Function '" + pFunctionName + "' does not exist.");
 
             for (int i = 0; i < pFieldNames.size(); i++)
             {
                 EvaluateFunction(pFieldNames[i], pFields[i], pFunctionName, pTime,
                                 domain);
             }
         }

void Nektar::SolverUtils::EquationSystem::EvaluateFunction	(	std::vector< std::string >	pFieldNames,
		Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const std::string &	pFunctionName,
		const NekDouble &	pTime = `0.0`,
		const int	domain = `0`
	)

Populate given fields with the function from session.

Populates a function for each of the dependent variables using the expression or filenames provided by the SessionReader object.

Parameters

force Array of fields to assign forcing.

Definition at line 736 of file EquationSystem.cpp.

References ASSERTL0, EvaluateFunction(), and m_session.

         {
             ASSERTL0(m_session->DefinesFunction(pFunctionName),
                     "Function '" + pFunctionName + "' does not exist.");
             ASSERTL0(pFieldNames.size() == pFields.num_elements(),
                     "Field list / name list size mismatch.");
 
             for (int i = 0; i < pFieldNames.size(); i++)
             {
                 EvaluateFunction(pFieldNames[i], pFields[i]->UpdatePhys(),
                                 pFunctionName, pTime, domain);
                 pFields[i]->FwdTrans_IterPerExp(pFields[i]->GetPhys(),
                                                 pFields[i]->UpdateCoeffs());
             }
         }

void Nektar::SolverUtils::EquationSystem::EvaluateFunction	(	std::string	pFieldName,
		Array< OneD, NekDouble > &	pArray,
		const std::string &	pFunctionName,
		const NekDouble &	pTime = `0.0`,
		const int	domain = `0`
	)

Definition at line 757 of file EquationSystem.cpp.

References ASSERTL0, Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, Nektar::LibUtilities::eFunctionTypeTransientFile, EvaluateFunctionExp(), EvaluateFunctionFld(), EvaluateFunctionPts(), and m_session.

         {
             ASSERTL0(m_session->DefinesFunction(pFunctionName),
                     "Function '" + pFunctionName + "' does not exist.");
 
             LibUtilities::FunctionType vType;
             vType = m_session->GetFunctionType(pFunctionName, pFieldName, domain);
             if (vType == LibUtilities::eFunctionTypeExpression)
             {
                 EvaluateFunctionExp(pFieldName, pArray, pFunctionName, pTime, domain);
             }
             else if (vType == LibUtilities::eFunctionTypeFile ||
                     vType == LibUtilities::eFunctionTypeTransientFile)
             {
                 std::string filename =
                     m_session->GetFunctionFilename(pFunctionName, pFieldName, domain);
 
                 if (boost::filesystem::path(filename).extension() != ".pts")
                 {
                     EvaluateFunctionFld(pFieldName, pArray, pFunctionName, pTime,
                                         domain);
                 }
                 else
                 {
                     EvaluateFunctionPts(pFieldName, pArray, pFunctionName, pTime,
                                         domain);
                 }
             }
         }

void Nektar::SolverUtils::EquationSystem::EvaluateFunctionExp	(	std::string	pFieldName,
		Array< OneD, NekDouble > &	pArray,
		const std::string &	pFunctionName,
		const NekDouble &	pTime = `0.0`,
		const int	domain = `0`
	)

protected

Definition at line 791 of file EquationSystem.cpp.

References ASSERTL0, Nektar::LibUtilities::eFunctionTypeExpression, m_fields, and m_session.

Referenced by EvaluateFunction().

         {
             ASSERTL0(m_session->DefinesFunction(pFunctionName),
                     "Function '" + pFunctionName + "' does not exist.");
 
             unsigned int nq = m_fields[0]->GetNpoints();
             if (pArray.num_elements() < nq)
             {
                 pArray = Array<OneD, NekDouble>(nq);
             }
 
             LibUtilities::FunctionType vType;
             vType = m_session->GetFunctionType(pFunctionName, pFieldName, domain);
             ASSERTL0(vType == LibUtilities::eFunctionTypeExpression,
                     "vType not eFunctionTypeExpression");
 
             Array<OneD, NekDouble> x0(nq);
             Array<OneD, NekDouble> x1(nq);
             Array<OneD, NekDouble> x2(nq);
 
             // Get the coordinates (assuming all fields have the same
             // discretisation)
             m_fields[0]->GetCoords(x0, x1, x2);
             LibUtilities::EquationSharedPtr ffunc =
                 m_session->GetFunction(pFunctionName, pFieldName, domain);
 
             ffunc->Evaluate(x0, x1, x2, pTime, pArray);
         }

void Nektar::SolverUtils::EquationSystem::EvaluateFunctionFld	(	std::string	pFieldName,
		Array< OneD, NekDouble > &	pArray,
		const std::string &	pFunctionName,
		const NekDouble &	pTime = `0.0`,
		const int	domain = `0`
	)

protected

Definition at line 824 of file EquationSystem.cpp.

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateForFile(), Nektar::LibUtilities::eFunctionTypeFile, Nektar::LibUtilities::eFunctionTypeTransientFile, CellMLToNektar.pycml::format, GetNcoeffs(), m_fields, m_loadedFldFields, m_session, and Nektar::LibUtilities::NullFieldMetaDataMap.

Referenced by EvaluateFunction().

         {
 
             ASSERTL0(m_session->DefinesFunction(pFunctionName),
                     "Function '" + pFunctionName + "' does not exist.");
 
             unsigned int nq = m_fields[0]->GetNpoints();
             if (pArray.num_elements() < nq)
             {
                 pArray = Array<OneD, NekDouble>(nq);
             }
 
             LibUtilities::FunctionType vType;
             vType = m_session->GetFunctionType(pFunctionName, pFieldName, domain);
             ASSERTL0(vType == LibUtilities::eFunctionTypeFile ||
                         vType == LibUtilities::eFunctionTypeTransientFile,
                     "vType not eFunctionTypeFile or eFunctionTypeTransientFile");
 
             std::string filename =
                 m_session->GetFunctionFilename(pFunctionName, pFieldName, domain);
             std::string fileVar = m_session->GetFunctionFilenameVariable(
                 pFunctionName, pFieldName, domain);
 
             if (fileVar.length() == 0)
             {
                 fileVar = pFieldName;
             }
 
             //  In case of eFunctionTypeTransientFile, generate filename from
             //  format string
             if (vType == LibUtilities::eFunctionTypeTransientFile)
             {
                 try
                 {
 #if (defined _WIN32 && _MSC_VER < 1900)
                     // We need this to make sure boost::format has always
                     // two digits in the exponents of Scientific notation.
                     unsigned int old_exponent_format;
                     old_exponent_format = _set_output_format(_TWO_DIGIT_EXPONENT);
                     filename = boost::str(boost::format(filename) % pTime);
                     _set_output_format(old_exponent_format);
 #else
                     filename = boost::str(boost::format(filename) % pTime);
 #endif
                 }
                 catch (...)
                 {
                     ASSERTL0(false, "Invalid Filename in function \"" + pFunctionName +
                                         "\", variable \"" + fileVar + "\"")
                 }
             }
 
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
             std::vector<std::vector<NekDouble> > FieldData;
 
             // Define list of global element ids
             int numexp = m_fields[0]->GetExpSize();
             Array<OneD, int> ElementGIDs(numexp);
             for (int i = 0; i < numexp; ++i)
             {
                 ElementGIDs[i] = m_fields[0]->GetExp(i)->GetGeom()->GetGlobalID();
             }
 
             // check if we already loaded this file. For transient files,
             // funcFilename != filename so we can make sure we only keep the
             // latest field per funcFilename.
             std::string funcFilename =
                 m_session->GetFunctionFilename(pFunctionName, pFieldName, domain);
             if (m_loadedFldFields.find(funcFilename) != m_loadedFldFields.end())
             {
                 // found
                 if (m_loadedFldFields[funcFilename].first == filename)
                 {
                     // found
                     FieldDef  = m_loadedFldFields[funcFilename].second.fieldDef;
                     FieldData = m_loadedFldFields[funcFilename].second.fieldData;
                 }
                 else
                 {
                     LibUtilities::FieldIOSharedPtr pts_fld =
                         LibUtilities::FieldIO::CreateForFile(m_session, filename);
                     pts_fld->Import(filename, FieldDef, FieldData,
                                     LibUtilities::NullFieldMetaDataMap,
                                     ElementGIDs);
                 }
             }
             else
             {
                 LibUtilities::FieldIOSharedPtr pts_fld =
                         LibUtilities::FieldIO::CreateForFile(m_session, filename);
                 pts_fld->Import(filename, FieldDef, FieldData,
                                 LibUtilities::NullFieldMetaDataMap,
                                 ElementGIDs);
             }
             // Now we overwrite the field we had in
             // m_loadedFldFields[funcFilename] before, making sure we only keep
             // one field per funcFilename in memory
             m_loadedFldFields[funcFilename].first            = filename;
             m_loadedFldFields[funcFilename].second.fieldDef  = FieldDef;
             m_loadedFldFields[funcFilename].second.fieldData = FieldData;
 
             int idx = -1;
             Array<OneD, NekDouble> vCoeffs(m_fields[0]->GetNcoeffs(), 0.0);
             // Loop over all the expansions
             for (int i = 0; i < FieldDef.size(); ++i)
             {
                 // Find the index of the required field in the
                 // expansion segment
                 for (int j = 0; j < FieldDef[i]->m_fields.size(); ++j)
                 {
                     if (FieldDef[i]->m_fields[j] == fileVar)
                     {
                         idx = j;
                     }
                 }
 
                 if (idx >= 0)
                 {
                     m_fields[0]->ExtractDataToCoeffs(
                         FieldDef[i], FieldData[i], FieldDef[i]->m_fields[idx], vCoeffs);
                 }
                 else
                 {
                     cout << "Field " + fileVar + " not found." << endl;
                 }
             }
 
             m_fields[0]->BwdTrans_IterPerExp(vCoeffs, pArray);
         }

void Nektar::SolverUtils::EquationSystem::EvaluateFunctionPts	(	std::string	pFieldName,
		Array< OneD, NekDouble > &	pArray,
		const std::string &	pFunctionName,
		const NekDouble &	pTime = `0.0`,
		const int	domain = `0`
	)

protected

Definition at line 958 of file EquationSystem.cpp.

References ASSERTL0, Nektar::LibUtilities::eFunctionTypeFile, Nektar::LibUtilities::eFunctionTypeTransientFile, CellMLToNektar.pycml::format, LoadPts(), m_fields, m_loadedPtsFields, and m_session.

Referenced by EvaluateFunction().

         {
 
             ASSERTL0(m_session->DefinesFunction(pFunctionName),
                     "Function '" + pFunctionName + "' does not exist.");
 
             unsigned int nq = m_fields[0]->GetNpoints();
             if (pArray.num_elements() < nq)
             {
                 pArray = Array<OneD, NekDouble>(nq);
             }
 
             LibUtilities::FunctionType vType;
             vType = m_session->GetFunctionType(pFunctionName, pFieldName, domain);
             ASSERTL0(vType == LibUtilities::eFunctionTypeFile ||
                         vType == LibUtilities::eFunctionTypeTransientFile,
                     "vType not eFunctionTypeFile or eFunctionTypeTransientFile");
 
             std::string filename =
                 m_session->GetFunctionFilename(pFunctionName, pFieldName, domain);
             std::string fileVar = m_session->GetFunctionFilenameVariable(
                 pFunctionName, pFieldName, domain);
 
             if (fileVar.length() == 0)
             {
                 fileVar = pFieldName;
             }
 
             //  In case of eFunctionTypeTransientFile, generate filename from
             //  format string
             if (vType == LibUtilities::eFunctionTypeTransientFile)
             {
                 try
                 {
 #if (defined _WIN32 && _MSC_VER < 1900)
                     // We need this to make sure boost::format has always
                     // two digits in the exponents of Scientific notation.
                     unsigned int old_exponent_format;
                     old_exponent_format = _set_output_format(_TWO_DIGIT_EXPONENT);
                     filename = boost::str(boost::format(filename) % pTime);
                     _set_output_format(old_exponent_format);
 #else
                     filename = boost::str(boost::format(filename) % pTime);
 #endif
                 }
                 catch (...)
                 {
                     ASSERTL0(false, "Invalid Filename in function \"" + pFunctionName +
                                         "\", variable \"" + fileVar + "\"")
                 }
             }
 
             LibUtilities::PtsFieldSharedPtr outPts;
             // check if we already loaded this file. For transient files,
             // funcFilename != filename so we can make sure we only keep the
             // latest pts field per funcFilename.
             std::string funcFilename =
                 m_session->GetFunctionFilename(pFunctionName, pFieldName, domain);
 
             if (m_loadedPtsFields.find(funcFilename) != m_loadedPtsFields.end())
             {
                 // found
                 if (m_loadedPtsFields[funcFilename].first == filename)
                 {
                     // found
                     outPts = m_loadedPtsFields[funcFilename].second;
                 }
                 else
                 {
                     LoadPts(funcFilename, filename, outPts);
                 }
             }
             else
             {
                 LoadPts(funcFilename, filename, outPts);
             }
             // Now we overwrite the field we had in
             // m_loadedPtsFields[funcFilename] before, making sure we only keep
             // one field per funcFilename in memory
             m_loadedPtsFields[funcFilename].first  = filename;
             m_loadedPtsFields[funcFilename].second = outPts;
 
             int fieldInd;
             vector<string> fieldNames = outPts->GetFieldNames();
             for (fieldInd = 0; fieldInd < fieldNames.size(); ++fieldInd)
             {
                 if (outPts->GetFieldName(fieldInd) == pFieldName)
                 {
                     break;
                 }
             }
             ASSERTL0(fieldInd != fieldNames.size(), "field not found");
 
             pArray = outPts->GetPts(fieldInd + outPts->GetDim());
         }

void Nektar::SolverUtils::EquationSystem::FwdTransFields ( void )

FwdTrans the m_fields members

Definition at line 1708 of file EquationSystem.cpp.

References m_fields.

         {
             for (int i = 0; i < m_fields.num_elements(); i++)
             {
                 m_fields[i]->FwdTrans(m_fields[i]->GetPhys(),
                                       m_fields[i]->UpdateCoeffs());
                 m_fields[i]->SetPhysState(false);
             }
         }

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetCheckpointNumber ( )

inline

Definition at line 418 of file EquationSystem.h.

References m_nchk.

             {
                 return m_nchk;
             }

SOLVER_UTILS_EXPORT int Nektar::SolverUtils::EquationSystem::GetCheckpointSteps ( )

inline

Definition at line 428 of file EquationSystem.h.

References m_checksteps.

             {
                 return m_checksteps;
             }

int Nektar::SolverUtils::EquationSystem::GetCoeff_Offset ( int n )

inline

Definition at line 897 of file EquationSystem.h.

References m_fields.

         {
             return m_fields[0]->GetCoeff_Offset(n);
         }

int Nektar::SolverUtils::EquationSystem::GetExpSize ( void )

inline

Definition at line 887 of file EquationSystem.h.

References m_fields.

Referenced by Nektar::CompressibleFlowSystem::GetStabilityLimitVector(), and Nektar::UnsteadyAdvectionDiffusion::SubStepAdvance().

         {
             return m_fields[0]->GetExpSize();
         }

NekDouble Nektar::SolverUtils::EquationSystem::GetFinalTime ( )

inline

Return final time.

Definition at line 841 of file EquationSystem.h.

References m_time.

         {
             return m_time;
         }

void Nektar::SolverUtils::EquationSystem::GetFluxVector	(	const int	i,
		Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

inline

Definition at line 949 of file EquationSystem.h.

References v_GetFluxVector().

Referenced by WeakDGAdvection(), and WeakDGDiffusion().

         {
             v_GetFluxVector(i,physfield, flux);
         }

void Nektar::SolverUtils::EquationSystem::GetFluxVector	(	const int	i,
		Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	fluxX,
		Array< OneD, Array< OneD, NekDouble > > &	fluxY
	)

inline

Definition at line 956 of file EquationSystem.h.

References v_GetFluxVector().

         {
             v_GetFluxVector(i,physfield, fluxX, fluxY);
         }

void Nektar::SolverUtils::EquationSystem::GetFluxVector	(	const int	i,
		const int	j,
		Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

inline

Definition at line 964 of file EquationSystem.h.

References v_GetFluxVector().

         {
             v_GetFluxVector(i,j,physfield,flux);
         }

int Nektar::SolverUtils::EquationSystem::GetNcoeffs ( void )

inline

Definition at line 846 of file EquationSystem.h.

References m_fields.

Referenced by Nektar::NonlinearSWE::AddCoriolis(), Nektar::LinearSWE::AddCoriolis(), Nektar::NonlinearPeregrine::AddCoriolis(), Nektar::NonlinearSWE::AddVariableDepth(), Nektar::NonlinearPeregrine::AddVariableDepth(), Nektar::NonlinearSWE::DoOdeProjection(), Nektar::LinearSWE::DoOdeProjection(), Nektar::UnsteadyInviscidBurger::DoOdeProjection(), Nektar::UnsteadyDiffusion::DoOdeProjection(), Nektar::UnsteadyAdvection::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeProjection(), Nektar::UnsteadyAdvectionDiffusion::DoOdeProjection(), Nektar::CFLtester::DoOdeProjection(), Nektar::NonlinearPeregrine::DoOdeRhs(), EvaluateFunctionFld(), ImportFld(), ImportFldToMultiDomains(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::CoupledLinearNS::SolveUnsteadyStokesSystem(), Nektar::EigenValuesAdvection::v_DoSolve(), Nektar::Projection::v_DoSolve(), Nektar::Laplace::v_DoSolve(), Nektar::APE::v_ExtraFldOutput(), Nektar::CoupledLinearNS::v_Output(), Nektar::APE::v_PreIntegrate(), v_SetInitialConditions(), WeakDGAdvection(), WeakDGDiffusion(), and WriteFld().

         {
             return m_fields[0]->GetNcoeffs();
         }

int Nektar::SolverUtils::EquationSystem::GetNcoeffs ( const int eid )

inline

Definition at line 851 of file EquationSystem.h.

References m_fields.

         {
             return m_fields[0]->GetNcoeffs(eid);
         }

int Nektar::SolverUtils::EquationSystem::GetNpoints ( void )

inline

Definition at line 912 of file EquationSystem.h.

References m_fields.

         {
             return m_fields[0]->GetNpoints();
         }

int Nektar::SolverUtils::EquationSystem::GetNumElmVelocity ( void )

inline

Definition at line 917 of file EquationSystem.h.

References m_fields.

         {
             return (m_fields.num_elements() - 1);
         }

int Nektar::SolverUtils::EquationSystem::GetNumExpModes ( void )

inline

Definition at line 856 of file EquationSystem.h.

References m_graph.

Referenced by ErrorExtraPoints().

         {
             return m_graph->GetExpansions().begin()->second->m_basisKeyVector[0]
             .GetNumModes();
         }

const Array< OneD, int > Nektar::SolverUtils::EquationSystem::GetNumExpModesPerExp ( void )

inline

Definition at line 862 of file EquationSystem.h.

References m_fields.

Referenced by Nektar::APE::GetCFLEstimate(), Nektar::IncNavierStokes::GetElmtCFLVals(), and Nektar::CompressibleFlowSystem::v_GetTimeStep().

         {
             return m_fields[0]->EvalBasisNumModesMaxPerExp();
         }

int Nektar::SolverUtils::EquationSystem::GetNvariables ( void )

inline

Definition at line 867 of file EquationSystem.h.

References m_session.

Referenced by ImportFldToMultiDomains().

         {
             return m_session->GetVariables().size();
         }

int Nektar::SolverUtils::EquationSystem::GetPhys_Offset ( int n )

inline

Definition at line 892 of file EquationSystem.h.

References m_fields.

Referenced by Nektar::IncNavierStokes::SetRadiationBoundaryForcing(), Nektar::NonlinearSWE::WallBoundary(), Nektar::LinearSWE::WallBoundary(), Nektar::SolverUtils::UnsteadySystem::WeakPenaltyforScalar(), and Nektar::SolverUtils::UnsteadySystem::WeakPenaltyforVector().

         {
             return m_fields[0]->GetPhys_Offset(n);
         }

MultiRegions::ExpListSharedPtr Nektar::SolverUtils::EquationSystem::GetPressure ( void )

inline

Get pressure field if available.

Get Pressure field if available

Definition at line 784 of file EquationSystem.h.

References v_GetPressure().

         {
             return v_GetPressure();
         }

SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr Nektar::SolverUtils::EquationSystem::GetSession ( )

inline

Get Session name.

Definition at line 133 of file EquationSystem.h.

References m_session.

Referenced by LoadPts().

             {
                 return m_session;
             }

SOLVER_UTILS_EXPORT std::string Nektar::SolverUtils::EquationSystem::GetSessionName ( )

inline

Get Session name.

Definition at line 108 of file EquationSystem.h.

References m_sessionName.

             {
                 return m_sessionName;
             }

int Nektar::SolverUtils::EquationSystem::GetSteps ( void )

inline

Definition at line 922 of file EquationSystem.h.

References m_steps.

         {
             return m_steps;
         }

NekDouble Nektar::SolverUtils::EquationSystem::GetTimeStep ( void )

inline

Definition at line 927 of file EquationSystem.h.

References m_timestep.

Referenced by Nektar::SolverUtils::UnsteadySystem::v_DoSolve().

         {
             return m_timestep;
         }

int Nektar::SolverUtils::EquationSystem::GetTotPoints ( void )

inline

Definition at line 902 of file EquationSystem.h.

References m_fields.

         {
             return m_fields[0]->GetNpoints();
         }

int Nektar::SolverUtils::EquationSystem::GetTotPoints ( int n )

inline

Definition at line 907 of file EquationSystem.h.

References m_fields.

         {
             return m_fields[0]->GetTotPoints(n);
         }

int Nektar::SolverUtils::EquationSystem::GetTraceNpoints ( void )

inline

Definition at line 882 of file EquationSystem.h.

References m_fields.

Referenced by Nektar::UnsteadyAdvectionDiffusion::GetNormalVel(), Nektar::UnsteadyInviscidBurger::GetNormalVelocity(), Nektar::UnsteadyAdvection::GetNormalVelocity(), Nektar::UnsteadyViscousBurgers::GetNormalVelocity(), GetTraceTotPoints(), Nektar::APE::v_InitObject(), Nektar::UnsteadyInviscidBurger::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), v_InitObject(), Nektar::EigenValuesAdvection::v_NumericalFlux(), Nektar::ImageWarpingSystem::v_NumericalFlux(), Nektar::CFLtester::v_NumericalFlux(), Nektar::IncNavierStokes::v_NumericalFlux(), Nektar::SolverUtils::UnsteadySystem::v_NumFluxforScalar(), Nektar::SolverUtils::UnsteadySystem::v_NumFluxforVector(), WeakDGAdvection(), WeakDGDiffusion(), Nektar::SolverUtils::UnsteadySystem::WeakPenaltyforScalar(), and Nektar::SolverUtils::UnsteadySystem::WeakPenaltyforVector().

         {
             return m_fields[0]->GetTrace()->GetNpoints();
         }

int Nektar::SolverUtils::EquationSystem::GetTraceTotPoints ( void )

inline

Definition at line 877 of file EquationSystem.h.

References GetTraceNpoints().

Referenced by Nektar::NonlinearPeregrine::DoOdeRhs(), Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::NonlinearPeregrine::NumericalFluxConsVariables(), Nektar::NonlinearPeregrine::NumericalFluxForcing(), Nektar::NonlinearSWE::SetBoundaryConditions(), Nektar::LinearSWE::SetBoundaryConditions(), Nektar::APE::SetBoundaryConditions(), Nektar::CompressibleFlowSystem::SetBoundaryConditions(), Nektar::NonlinearPeregrine::SetBoundaryConditions(), Nektar::NavierStokesCFE::v_DoDiffusion(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::PulseWavePropagation::v_NumericalFlux(), Nektar::NonlinearPeregrine::WallBoundaryContVariables(), and Nektar::NonlinearPeregrine::WallBoundaryForcing().

         {
             return GetTraceNpoints();
         }

const std::string Nektar::SolverUtils::EquationSystem::GetVariable ( unsigned int i )

inline

Definition at line 872 of file EquationSystem.h.

References m_session.

         {
             return m_session->GetVariable(i);
         }

void Nektar::SolverUtils::EquationSystem::ImportFld	(	const std::string &	infile,
		Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields
	)

Input field data from the given file.

Import field from infile and load into m_fields. This routine will also perform a BwdTrans to ensure data is in both the physical and coefficient storage.

Parameters

infile Filename to read.

Definition at line 2270 of file EquationSystem.cpp.

References ASSERTL1, Nektar::LibUtilities::FieldIO::CreateForFile(), GetNcoeffs(), m_fields, m_session, and Vmath::Zero().

         {
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
             std::vector<std::vector<NekDouble> > FieldData;
             LibUtilities::FieldIOSharedPtr field_fld =
                 LibUtilities::FieldIO::CreateForFile(m_session, infile);
             field_fld->Import(infile,FieldDef,FieldData);
 
             // Copy FieldData into m_fields
             for(int j = 0; j < pFields.num_elements(); ++j)
             {
                 Vmath::Zero(pFields[j]->GetNcoeffs(),
                             pFields[j]->UpdateCoeffs(),1);
                 
                 for(int i = 0; i < FieldDef.size(); ++i)
                 {
                     ASSERTL1(FieldDef[i]->m_fields[j] ==
                              m_session->GetVariable(j),
                              std::string("Order of ") + infile
                              + std::string(" data and that defined in "
                                            "m_boundaryconditions differs"));
 
                     pFields[j]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                                     FieldDef[i]->m_fields[j],
                                                     pFields[j]->UpdateCoeffs());
                 }
                 pFields[j]->BwdTrans(pFields[j]->GetCoeffs(),
                                      pFields[j]->UpdatePhys());
             }
         }

void Nektar::SolverUtils::EquationSystem::ImportFld	(	const std::string &	infile,
		std::vector< std::string > &	fieldStr,
		Array< OneD, Array< OneD, NekDouble > > &	coeffs
	)

Output a field. Input field data into array from the given file.

Import field from infile and load into the array coeffs.

Parameters

infile	Filename to read.
fieldStr	an array of string identifying fields to be imported
coeffs	and array of array of coefficients to store imported data

Definition at line 2396 of file EquationSystem.cpp.

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

         {
 
             ASSERTL0(fieldStr.size() <= coeffs.num_elements(),
                      "length of fieldstr should be the same as pFields");
         
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
             std::vector<std::vector<NekDouble> > FieldData;
 
             LibUtilities::FieldIOSharedPtr field_fld =
                 LibUtilities::FieldIO::CreateForFile(m_session, infile);
             field_fld->Import(infile,FieldDef,FieldData);
 
             // Copy FieldData into m_fields
             for(int j = 0; j < fieldStr.size(); ++j)
             {
                 Vmath::Zero(coeffs[j].num_elements(),coeffs[j],1);
                 for(int i = 0; i < FieldDef.size(); ++i)
                 {
                     m_fields[0]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                                      fieldStr[j], coeffs[j]);
                 }
             }
         }

void Nektar::SolverUtils::EquationSystem::ImportFld	(	const std::string &	infile,
		MultiRegions::ExpListSharedPtr &	pField,
		std::string &	pFieldName
	)

Output a field. Input field data into ExpList from the given file.

Import field from infile and load into pField. This routine will also perform a BwdTrans to ensure data is in both the physical and coefficient storage.

Definition at line 2355 of file EquationSystem.cpp.

References ASSERTL1, Nektar::LibUtilities::FieldIO::CreateForFile(), m_fields, m_session, and Vmath::Zero().

         {
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
             std::vector<std::vector<NekDouble> > FieldData;
 
             LibUtilities::FieldIOSharedPtr field_fld =
                 LibUtilities::FieldIO::CreateForFile(m_session, infile);
             field_fld->Import(infile,FieldDef,FieldData);
             int idx = -1;
 
             Vmath::Zero(pField->GetNcoeffs(),pField->UpdateCoeffs(),1);
 
             for(int i = 0; i < FieldDef.size(); ++i)
             {
                 // find the index of the required field in the file.
                 for(int j = 0; j < FieldData.size(); ++j)
                 {
                     if (FieldDef[i]->m_fields[j] == pFieldName)
                     {
                         idx = j;
                     }
                 }
                 ASSERTL1(idx >= 0, "Field " + pFieldName + " not found.");
 
                 pField->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                             FieldDef[i]->m_fields[idx],
                                             pField->UpdateCoeffs());
             }
             pField->BwdTrans(pField->GetCoeffs(), pField->UpdatePhys());
         }

void Nektar::SolverUtils::EquationSystem::ImportFldBase	(	std::string	pInfile,
		SpatialDomains::MeshGraphSharedPtr	pGraph
	)

protected

Definition at line 1607 of file EquationSystem.cpp.

References ASSERTL0, Nektar::LibUtilities::FieldIO::CreateForFile(), m_base, m_fields, and m_session.

         {
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
             std::vector<std::vector<NekDouble> > FieldData;
 
             //Get Homogeneous
             LibUtilities::FieldIOSharedPtr base_fld =
                 LibUtilities::FieldIO::CreateForFile(m_session, pInfile);
             base_fld->Import(pInfile,FieldDef,FieldData);
 
             int nvar = m_session->GetVariables().size();
             if (m_session->DefinesSolverInfo("HOMOGENEOUS"))
             {
                 std::string HomoStr = m_session->GetSolverInfo("HOMOGENEOUS");
             }
             // copy FieldData into m_fields
             for (int j = 0; j < nvar; ++j)
             {
                 for(int i = 0; i < FieldDef.size(); ++i)
                 {
                     bool flag = FieldDef[i]->m_fields[j] ==
                                 m_session->GetVariable(j);
                     ASSERTL0(flag, (std::string("Order of ") + pInfile
                                     + std::string(" data and that defined in "
                                     "the session differs")).c_str());
 
                     m_base[j]->ExtractDataToCoeffs(FieldDef[i], FieldData[i],
                                                    FieldDef[i]->m_fields[j],
                                                    m_base[j]->UpdateCoeffs());
                 }
             }
         }

void Nektar::SolverUtils::EquationSystem::ImportFldToMultiDomains	(	const std::string &	infile,
		Array< OneD, MultiRegions::ExpListSharedPtr > &	pFields,
		const int	ndomains
	)

Input field data from the given file to multiple domains.

Import field from infile and load into m_fields. This routine will also perform a BwdTrans to ensure data is in both the physical and coefficient storage.

Parameters

infile Filename to read. If optionan ndomains is specified it assumes we loop over nodmains for each nvariables.

Definition at line 2312 of file EquationSystem.cpp.

References ASSERTL0, ASSERTL1, GetNcoeffs(), GetNvariables(), Nektar::LibUtilities::Import(), m_fields, m_session, and Vmath::Zero().

         {
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef;
             std::vector<std::vector<NekDouble> > FieldData;
             
             LibUtilities::Import(infile,FieldDef,FieldData);
             
             int nvariables = GetNvariables();
 
             ASSERTL0(ndomains*nvariables == pFields.num_elements(),"Number of fields does not match the number of variables and domains");
             
             // Copy FieldData into m_fields
             for(int j = 0; j < ndomains; ++j)
             {
                 for(int i = 0; i < nvariables; ++i)
                 {
                     Vmath::Zero(pFields[j*nvariables+i]->GetNcoeffs(),pFields[j*nvariables+i]->UpdateCoeffs(),1);
                     
                     for(int n = 0; n < FieldDef.size(); ++n)
                     {
                         ASSERTL1(FieldDef[n]->m_fields[i] == m_session->GetVariable(i),
                                  std::string("Order of ") + infile
                                  + std::string(" data and that defined in "
                                                "m_boundaryconditions differs"));
                         
                         pFields[j*nvariables+i]->ExtractDataToCoeffs(FieldDef[n], FieldData[n],
                                                                      FieldDef[n]->m_fields[i],
                                                                      pFields[j*nvariables+i]->UpdateCoeffs());
                     }
                     pFields[j*nvariables+i]->BwdTrans(pFields[j*nvariables+i]->GetCoeffs(),
                                                       pFields[j*nvariables+i]->UpdatePhys());
                 }
             }
         }

void Nektar::SolverUtils::EquationSystem::InitialiseBaseFlow ( Array< OneD, Array< OneD, NekDouble > > & base )

Perform initialisation of the base flow.

Definition at line 1427 of file EquationSystem.cpp.

References EvaluateFunction(), m_graph, m_spacedim, and SetUpBaseFields().

Referenced by Nektar::SteadyAdvectionDiffusion::v_InitObject().

         {
             base = Array<OneD, Array<OneD, NekDouble> >(m_spacedim);
             std::vector<std::string> vel;
             vel.push_back("Vx");
             vel.push_back("Vy");
             vel.push_back("Vz");
             vel.resize(m_spacedim);
             SetUpBaseFields(m_graph);
             EvaluateFunction(vel, base, "BaseFlow");
         }           

void Nektar::SolverUtils::EquationSystem::InitObject ( )

inline

Initialises the members of this object.

This is the second part of the two-phase initialisation process. Calls to virtual functions will correctly resolve to the derived class during this phase of the construction.

Definition at line 705 of file EquationSystem.h.

References v_InitObject().

         {
             v_InitObject();
         }

NekDouble Nektar::SolverUtils::EquationSystem::L2Error	(	unsigned int	field,
		const Array< OneD, NekDouble > &	exactsoln,
		bool	Normalised = `false`
	)

inline

Compute the L2 error between fields and a given exact solution.

L_2 Error computation Public interface routine to virtual function implementation.

Definition at line 776 of file EquationSystem.h.

References v_L2Error().

Referenced by L2Error().

         {
             return v_L2Error(field, exactsoln, Normalised);
         }

SOLVER_UTILS_EXPORT NekDouble Nektar::SolverUtils::EquationSystem::L2Error	(	unsigned int	field,
		bool	Normalised = `false`
	)

inline

Compute the L2 error of the fields.

Definition at line 208 of file EquationSystem.h.

References L2Error(), and Nektar::NullNekDouble1DArray.

             {
                 return L2Error(field,NullNekDouble1DArray,Normalised);
             }

NekDouble Nektar::SolverUtils::EquationSystem::LinfError	(	unsigned int	field,
		const Array< OneD, NekDouble > &	exactsoln = `NullNekDouble1DArray`
	)

inline

Linf error computation.

L_inf Error computation Public interface routine to virtual function implementation.

Definition at line 767 of file EquationSystem.h.

References v_LinfError().

         {
             return v_LinfError(field, exactsoln);
         }

void Nektar::SolverUtils::EquationSystem::LoadPts	(	std::string	funcFilename,
		std::string	filename,
		Nektar::LibUtilities::PtsFieldSharedPtr &	outPts
	)

protected

Definition at line 1058 of file EquationSystem.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::FieldUtils::eShepard, GetSession(), Nektar::LibUtilities::PtsIO::Import(), m_comm, m_fields, m_interpolators, m_session, and PrintProgressbar().

Referenced by EvaluateFunctionPts().

         {
             unsigned int nq = m_fields[0]->GetNpoints();
 
             LibUtilities::PtsFieldSharedPtr inPts;
             LibUtilities::PtsIO ptsIO(m_session->GetComm());
             ptsIO.Import(filename, inPts);
 
             Array<OneD, Array<OneD, NekDouble> > pts(inPts->GetDim() +
                                                     inPts->GetNFields());
             for (int i = 0; i < inPts->GetDim() + inPts->GetNFields(); ++i)
             {
                 pts[i] = Array<OneD, NekDouble>(nq);
             }
             if (inPts->GetDim() == 1)
             {
                 m_fields[0]->GetCoords(pts[0]);
             }
             else if (inPts->GetDim() == 2)
             {
                 m_fields[0]->GetCoords(pts[0], pts[1]);
             }
             else if (inPts->GetDim() == 3)
             {
                 m_fields[0]->GetCoords(pts[0], pts[1], pts[2]);
             }
             outPts = MemoryManager<LibUtilities::PtsField>::AllocateSharedPtr(
                 inPts->GetDim(), inPts->GetFieldNames(), pts);
 
             //  check if we already have an interolator for this funcFilename
             if (m_interpolators.find(funcFilename) == m_interpolators.end())
             {
                 m_interpolators[funcFilename] =
                     FieldUtils::Interpolator(Nektar::FieldUtils::eShepard);
                 if (m_comm->GetRank() == 0)
                 {
                     m_interpolators[funcFilename].SetProgressCallback(
                         &EquationSystem::PrintProgressbar, this);
                 }
                 m_interpolators[funcFilename].CalcWeights(inPts, outPts);
                 if (m_comm->GetRank() == 0)
                 {
                     cout << endl;
                     if (GetSession()->DefinesCmdLineArgument("verbose"))
                     {
                         m_interpolators[funcFilename].PrintStatistics();
                     }
                 }
             }
             m_interpolators[funcFilename].Interpolate(inPts, outPts);
         }

int Nektar::SolverUtils::EquationSystem::nocase_cmp	(	const std::string &	s1,
		const std::string &	s2
	)

inlineprotected

Definition at line 565 of file EquationSystem.h.

References NoCaseStringCompare().

             {
                 return NoCaseStringCompare(s1,s2);
             }

int Nektar::SolverUtils::EquationSystem::NoCaseStringCompare	(	const std::string &	s1,
		const std::string &	s2
	)

Perform a case-insensitive string comparison.

Performs a case-insensitive string comparison (from web).

Parameters

s1	First string to compare.
s2	Second string to compare.

Returns: 0 if the strings match.

Definition at line 2519 of file EquationSystem.cpp.

Referenced by nocase_cmp().

         {
             //if (s1.size() < s2.size()) return -1;
             //if (s1.size() > s2.size()) return 1;
 
             string::const_iterator it1=s1.begin();
             string::const_iterator it2=s2.begin();
 
             // Stop when either string's end has been reached
             while ( (it1!=s1.end()) && (it2!=s2.end()) )
             {
                 if(::toupper(*it1) != ::toupper(*it2)) //letters differ?
                 {
                     // Return -1 to indicate smaller than, 1 otherwise
                     return (::toupper(*it1)  < ::toupper(*it2)) ? -1 : 1;
                 }
 
                 // Proceed to the next character in each string
                 ++it1;
                 ++it2;
             }
 
             size_t size1=s1.size();
             size_t size2=s2.size();// cache lengths
 
             // Return -1, 0 or 1 according to strings' lengths
             if (size1==size2)
             {
                 return 0;
             }
 
             return (size1 < size2) ? -1 : 1;
         }

void Nektar::SolverUtils::EquationSystem::NumericalFlux	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numflux
	)

inline

Definition at line 971 of file EquationSystem.h.

References v_NumericalFlux().

Referenced by WeakDGAdvection().

         {
             v_NumericalFlux(physfield, numflux);
         }

void Nektar::SolverUtils::EquationSystem::NumericalFlux	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxX,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxY
	)

inline

Definition at line 977 of file EquationSystem.h.

References v_NumericalFlux().

         {
             v_NumericalFlux(physfield, numfluxX, numfluxY);
         }

void Nektar::SolverUtils::EquationSystem::NumFluxforScalar	(	const Array< OneD, Array< OneD, NekDouble > > &	ufield,
		Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &	uflux
	)

inline

Definition at line 984 of file EquationSystem.h.

References v_NumFluxforScalar().

Referenced by WeakDGDiffusion().

         {
             v_NumFluxforScalar(ufield, uflux);
         }

void Nektar::SolverUtils::EquationSystem::NumFluxforVector	(	const Array< OneD, Array< OneD, NekDouble > > &	ufield,
		Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &	qfield,
		Array< OneD, Array< OneD, NekDouble > > &	qflux
	)

inline

Definition at line 991 of file EquationSystem.h.

References v_NumFluxforVector().

Referenced by WeakDGDiffusion().

         {
             v_NumFluxforVector(ufield, qfield, qflux);
         }

void Nektar::SolverUtils::EquationSystem::Output ( void )

inline

Perform output operations after solve.

Definition at line 758 of file EquationSystem.h.

References v_Output().

         {
             v_Output();
         }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::PrintProgressbar	(	const int	position,
		const int	goal
	)		const

inlineprivate

Definition at line 692 of file EquationSystem.h.

References Nektar::LibUtilities::PrintProgressbar().

Referenced by LoadPts().

             {
                 LibUtilities::PrintProgressbar(position, goal, "Interpolating");
             }

void Nektar::SolverUtils::EquationSystem::PrintSummary ( std::ostream & out )

inline

Print a summary of parameters and solver characteristics.

Prints a summary of variables and problem parameters.

Public interface routine to virtual function implementation.

Parameters

out	The ostream object to write to.

Definition at line 796 of file EquationSystem.h.

References m_session, and v_GenerateSummary().

         {
             if (m_session->GetComm()->GetRank() == 0)
             {
                 std::vector<std::pair<std::string, std::string> > vSummary;
                 v_GenerateSummary(vSummary);
 
                 out << "=======================================================================" << std::endl;
                 SummaryList::const_iterator x;
                 for (x = vSummary.begin(); x != vSummary.end(); ++x)
                 {
                     out << "\t";
                     out.width(20);
                     out << x->first << ": " << x->second << std::endl;
                 }
                 out << "=======================================================================" << std::endl;
             }
         }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::ResetSessionName ( std::string newname )

inline

Reset Session name.

Definition at line 127 of file EquationSystem.h.

References m_sessionName.

             {
                 m_sessionName = newname;
             }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::ScanForHistoryPoints ( )

Builds map of which element holds each history point.

void Nektar::SolverUtils::EquationSystem::SessionSummary ( SummaryList & s )

Write out a session summary.

Write out a summary of the session data.

Parameters

out	Output stream to write data to.

Definition at line 2428 of file EquationSystem.cpp.

References Nektar::SolverUtils::AddSummaryItem(), Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, eHomogeneous1D, eHomogeneous2D, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::GetAdvectionFactory(), Nektar::SolverUtils::GetDiffusionFactory(), m_expdim, m_fields, m_halfMode, m_HomogeneousType, m_LhomY, m_LhomZ, m_multipleModes, m_npointsY, m_npointsZ, m_projectionType, m_session, m_sessionName, m_singleMode, m_spacedim, and m_useFFT.

Referenced by Nektar::Projection::v_GenerateSummary(), Nektar::Laplace::v_GenerateSummary(), Nektar::LinearElasticSystem::v_GenerateSummary(), and v_GenerateSummary().

         {
             AddSummaryItem(s, "EquationType", m_session->GetSolverInfo("EQTYPE"));
             AddSummaryItem(s, "Session Name", m_sessionName);
             AddSummaryItem(s, "Spatial Dim.", m_spacedim);
             AddSummaryItem(s, "Max SEM Exp. Order", m_fields[0]->EvalBasisNumModesMax());
 
             if (m_session->GetComm()->GetSize() > 1)
             {
                 AddSummaryItem(s, "Num. Processes",
                         m_session->GetComm()->GetSize());
             }
 
             if(m_HomogeneousType == eHomogeneous1D)
             {
                 AddSummaryItem(s, "Quasi-3D", "Homogeneous in z-direction");
                 AddSummaryItem(s, "Expansion Dim.", m_expdim + 1);
                 AddSummaryItem(s, "Num. Hom. Modes (z)", m_npointsZ);
                 AddSummaryItem(s, "Hom. length (LZ)", m_LhomZ);
                 AddSummaryItem(s, "FFT Type", m_useFFT ? "FFTW" : "MVM");
                 if (m_halfMode)
                 {
                     AddSummaryItem(s, "ModeType", "Half Mode");
                 }
                 else if (m_singleMode)
                 {
                     AddSummaryItem(s, "ModeType", "Single Mode");
                 }
                 else if (m_multipleModes)
                 {
                     AddSummaryItem(s, "ModeType", "Multiple Modes");
                 }
             }
             else if(m_HomogeneousType == eHomogeneous2D)
             {
                 AddSummaryItem(s, "Quasi-3D", "Homogeneous in yz-plane");
                 AddSummaryItem(s, "Expansion Dim.", m_expdim + 2);
                 AddSummaryItem(s, "Num. Hom. Modes (y)", m_npointsY);
                 AddSummaryItem(s, "Num. Hom. Modes (z)", m_npointsZ);
                 AddSummaryItem(s, "Hom. length (LY)", m_LhomY);
                 AddSummaryItem(s, "Hom. length (LZ)", m_LhomZ);
                 AddSummaryItem(s, "FFT Type", m_useFFT ? "FFTW" : "MVM");
             }
             else
             {
                 AddSummaryItem(s, "Expansion Dim.", m_expdim);
             }
             
             if (m_session->DefinesSolverInfo("UpwindType"))
             {
                 AddSummaryItem(s, "Riemann Solver",
                                   m_session->GetSolverInfo("UpwindType"));
             }
             
             if (m_session->DefinesSolverInfo("AdvectionType"))
             {
                 std::string AdvectionType;
                 AdvectionType = m_session->GetSolverInfo("AdvectionType");
                 AddSummaryItem(s, "Advection Type", GetAdvectionFactory().
                                GetClassDescription(AdvectionType));
             }
 
             if (m_projectionType == MultiRegions::eGalerkin)
             {
                 AddSummaryItem(s, "Projection Type", "Continuous Galerkin");
             }
             else if (m_projectionType == MultiRegions::eDiscontinuous)
             {
                 AddSummaryItem(s, "Projection Type", "Discontinuous Galerkin");
             }
             else if (m_projectionType == MultiRegions::eMixed_CG_Discontinuous)
             {
                 AddSummaryItem(s, "Projection Type",
                                   "Mixed Continuous Galerkin and Discontinuous");
             }
             
             if (m_session->DefinesSolverInfo("DiffusionType"))
             {
                 std::string DiffusionType;
                 DiffusionType = m_session->GetSolverInfo("DiffusionType");
                 AddSummaryItem(s, "Diffusion Type", GetDiffusionFactory().
                                GetClassDescription(DiffusionType));
             }
         }

void Nektar::SolverUtils::EquationSystem::SetBoundaryConditions ( NekDouble time )

Evaluates the boundary conditions at the given time.

If boundary conditions are time-dependent, they will be evaluated at the time specified.

Parameters

time	The time at which to evaluate the BCs

Definition at line 1152 of file EquationSystem.cpp.

References m_fields, and m_session.

         {
             std::string varName;
             int nvariables = m_fields.num_elements();
             for (int i = 0; i < nvariables; ++i)
             {
                 varName = m_session->GetVariable(i); 
                 m_fields[i]->EvaluateBoundaryConditions(time, varName);
             }
         }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetCheckpointNumber ( int num )

inline

Definition at line 423 of file EquationSystem.h.

References m_nchk.

             {
                 m_nchk = num;
             }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetCheckpointSteps ( int num )

inline

Definition at line 433 of file EquationSystem.h.

References m_checksteps.

             {
                 m_checksteps = num;
             }

void Nektar::SolverUtils::EquationSystem::SetInitialConditions	(	NekDouble	initialtime = `0.0`,
		bool	dumpInitialConditions = `true`,
		const int	domain = `0`
	)

inline

Initialise the data in the dependent fields.

Definition at line 820 of file EquationSystem.h.

References v_SetInitialConditions().

Referenced by main(), Nektar::SolverUtils::UnsteadySystem::v_DoInitialise(), Nektar::PulseWaveSystem::v_DoInitialise(), and Nektar::CoupledLinearNS::v_DoInitialise().

         {
             v_SetInitialConditions(initialtime,dumpInitialConditions,domain);
         }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetInitialStep ( const int step )

inline

Definition at line 444 of file EquationSystem.h.

References m_initialStep.

             {
                 m_initialStep = step;
             }

void Nektar::SolverUtils::EquationSystem::SetLambda ( NekDouble lambda )

inline

Set parameter m_lambda.

Definition at line 815 of file EquationSystem.h.

References m_lambda.

         {
             m_lambda = lambda;
         }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetModifiedBasis ( const bool modbasis )

inline

void Nektar::SolverUtils::EquationSystem::SetSteps ( const int steps )

inline

Definition at line 932 of file EquationSystem.h.

References m_steps.

         {
             m_steps = steps;
         }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetTime ( const NekDouble time )

inline

Definition at line 438 of file EquationSystem.h.

References m_time.

             {
                 m_time = time;
             }

void Nektar::SolverUtils::EquationSystem::SetUpBaseFields ( SpatialDomains::MeshGraphSharedPtr & mesh )

protected

Definition at line 1440 of file EquationSystem.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eFourier, Nektar::LibUtilities::eFourierEvenlySpaced, Nektar::LibUtilities::eFourierHalfModeRe, Nektar::LibUtilities::eFourierSingleModeSpaced, Nektar::MultiRegions::eGalerkin, eHomogeneous1D, Nektar::MultiRegions::eMixed_CG_Discontinuous, m_base, m_expdim, m_graph, m_halfMode, m_homogen_dealiasing, m_HomogeneousType, m_LhomZ, m_npointsZ, m_projectionType, m_session, m_singleMode, and m_useFFT.

Referenced by InitialiseBaseFlow().

         {
             int i;
             
             // The number of variables can be different from the dimension 
             // of the base flow
             int nvariables = m_session->GetVariables().size();
             m_base = Array<OneD, MultiRegions::ExpListSharedPtr>(nvariables);
             if (m_projectionType == MultiRegions::eGalerkin ||
                 m_projectionType == MultiRegions::eMixed_CG_Discontinuous)
             {
                 switch (m_expdim)
                 {
                     case 1:
                     {
                         for(i = 0; i < m_base.num_elements(); i++)
                         {
                             m_base[i] = MemoryManager<MultiRegions::ContField1D>
                                 ::AllocateSharedPtr(m_session, mesh, 
                                                     m_session->GetVariable(0));
                         }
                     }
                         break;
                     case 2:
                     {
                         if (m_HomogeneousType == eHomogeneous1D)
                         {
                             if (m_singleMode)
                             {
                                 const LibUtilities::PointsKey PkeyZ(m_npointsZ,
                                         LibUtilities::eFourierSingleModeSpaced);
                                 const LibUtilities::BasisKey  BkeyZ(
                                         LibUtilities::eFourier,
                                         m_npointsZ,PkeyZ);
 
                                 for (i = 0 ; i < m_base.num_elements(); i++)
                                 {
                                     m_base[i] = MemoryManager<MultiRegions
                                         ::ContField3DHomogeneous1D>
                                             ::AllocateSharedPtr(
                                                 m_session, BkeyZ, m_LhomZ, 
                                                 m_useFFT, m_homogen_dealiasing, 
                                                 m_graph, 
                                                 m_session->GetVariable(i));
                                     m_base[i]->SetWaveSpace(true);
                                 }
                             }
                             else if (m_halfMode)
                             {
                                 //1 plane field (half mode expansion)
                                 const LibUtilities::PointsKey PkeyZ(m_npointsZ,
                                         LibUtilities::eFourierSingleModeSpaced);
                                 const LibUtilities::BasisKey  BkeyZ(
                                         LibUtilities::eFourierHalfModeRe,
                                         m_npointsZ,PkeyZ);
 
                                 for (i = 0 ; i < m_base.num_elements(); i++)
                                 {
                                     m_base[i] = MemoryManager<MultiRegions
                                         ::ContField3DHomogeneous1D>
                                             ::AllocateSharedPtr(
                                                 m_session, BkeyZ, m_LhomZ, 
                                                 m_useFFT, m_homogen_dealiasing, 
                                                 m_graph, 
                                                 m_session->GetVariable(i));
                                     m_base[i]->SetWaveSpace(true);
                                 }
                             }
                             else
                             {
                                 const LibUtilities::PointsKey PkeyZ(m_npointsZ,
                                         LibUtilities::eFourierEvenlySpaced);
                                 const LibUtilities::BasisKey  BkeyZ(
                                         LibUtilities::eFourier,m_npointsZ,
                                         PkeyZ);
 
                                 for (i = 0 ; i < m_base.num_elements(); i++)
                                 {
                                     m_base[i] = MemoryManager<MultiRegions
                                         ::ContField3DHomogeneous1D>
                                             ::AllocateSharedPtr(
                                                 m_session, BkeyZ, m_LhomZ, 
                                                 m_useFFT, m_homogen_dealiasing, 
                                                 m_graph, 
                                                 m_session->GetVariable(i));
                                     m_base[i]->SetWaveSpace(false);
                                 }
                             }
                         }
                         else
                         {
                             i = 0;
                             MultiRegions::ContField2DSharedPtr firstbase =
                                 MemoryManager<MultiRegions::ContField2D>
                                 ::AllocateSharedPtr(m_session,mesh,
                                                 m_session->GetVariable(i));
                             m_base[0]=firstbase;
 
                             for (i = 1 ; i < m_base.num_elements(); i++)
                             {
                                 m_base[i] = MemoryManager<MultiRegions::
                                     ContField2D>::AllocateSharedPtr(
                                         *firstbase,mesh,
                                         m_session->GetVariable(i));
                             }
                         }
                     }
                     break;
                     case 3:
                     {
                         MultiRegions::ContField3DSharedPtr firstbase =
                             MemoryManager<MultiRegions::ContField3D>
                             ::AllocateSharedPtr(m_session, m_graph,
                                                 m_session->GetVariable(0));
                         m_base[0] = firstbase;
                         for (i = 1 ; i < m_base.num_elements(); i++)
                         {
                             m_base[i] = MemoryManager<MultiRegions::ContField3D>
                                 ::AllocateSharedPtr(*firstbase, m_graph,
                                                     m_session->GetVariable(0));
                         }
                     }
                     break;
                     default:
                         ASSERTL0(false,"Expansion dimension not recognised");
                         break;
                 }
             }
             else
             {
                 switch(m_expdim)
                 {
                     case 1:
                     {
                         // need to use zero for variable as may be more base 
                         // flows than variables
                         for(i = 0 ; i < m_base.num_elements(); i++)
                         {
                             m_base[i] = MemoryManager<MultiRegions
                                 ::DisContField1D>
                                 ::AllocateSharedPtr(m_session, m_graph,
                                                     m_session->GetVariable(0));
                         }
                         break;
                     }
                     case 2:
                     {
                         for(i = 0 ; i < m_base.num_elements(); i++)
                         {
                             m_base[i] = MemoryManager<MultiRegions::
                                 DisContField2D>::AllocateSharedPtr(
                                     m_session,m_graph,
                                     m_session->GetVariable(0));
                         }
                         break;
                     }
                     case 3:
                         ASSERTL0(false, "3 D not set up");
                     default:
                         ASSERTL0(false, "Expansion dimension not recognised");
                         break;
                 }
             }
         }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::SetUpTraceNormals ( void )

void Nektar::SolverUtils::EquationSystem::TransCoeffToPhys ( void )

inline

Transform from coefficient to physical space.

Performs the transformation from coefficient to physical space.

Public interface routine to virtual function implementation.

Definition at line 728 of file EquationSystem.h.

References v_TransCoeffToPhys().

         {
             v_TransCoeffToPhys();
         }

void Nektar::SolverUtils::EquationSystem::TransPhysToCoeff ( void )

inline

Transform from physical to coefficient space.

Performs the transformation from physical to coefficient space.

Public interface routine to virtual function implementation.

Definition at line 738 of file EquationSystem.h.

References v_TransPhysToCoeff().

         {
             v_TransPhysToCoeff();
         }

SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMap& Nektar::SolverUtils::EquationSystem::UpdateFieldMetaDataMap ( )

inline

Get hold of FieldInfoMap so it can be updated.

Array< OneD, MultiRegions::ExpListSharedPtr > & Nektar::SolverUtils::EquationSystem::UpdateFields ( void )

inline

Definition at line 835 of file EquationSystem.h.

References m_fields.

         {
             return m_fields;
         }

void Nektar::SolverUtils::EquationSystem::v_DoInitialise ( void )

protectedvirtual

Virtual function for initialisation implementation.

By default, nothing needs initialising at the EquationSystem level.

Reimplemented in Nektar::CoupledLinearNS, Nektar::PulseWaveSystem, Nektar::VelocityCorrectionScheme, Nektar::SolverUtils::UnsteadySystem, Nektar::VCSMapping, Nektar::SteadyAdvectionDiffusion, and Nektar::EigenValuesAdvection.

Definition at line 1421 of file EquationSystem.cpp.

Referenced by DoInitialise().

         {
 
         }

void Nektar::SolverUtils::EquationSystem::v_DoSolve ( void )

protectedvirtual

Virtual function for solve implementation.

Reimplemented in Nektar::CoupledLinearNS, Nektar::PulseWaveSystem, Nektar::LinearElasticSystem, Nektar::SolverUtils::UnsteadySystem, Nektar::IterativeElasticSystem, Nektar::SteadyAdvectionDiffusion, Nektar::Laplace, Nektar::Projection, and Nektar::EigenValuesAdvection.

Definition at line 1645 of file EquationSystem.cpp.

Referenced by DoSolve().

         {
 
         }

void Nektar::SolverUtils::EquationSystem::v_EvaluateExactSolution	(	unsigned int	field,
		Array< OneD, NekDouble > &	outfield,
		const NekDouble	time
	)

protectedvirtual

Reimplemented in Nektar::IsentropicVortex, and Nektar::RinglebFlow.

Definition at line 1402 of file EquationSystem.cpp.

References ASSERTL0, EvaluateFunction(), m_fields, m_session, and Vmath::Zero().

Referenced by EvaluateExactSolution().

         {
             ASSERTL0 (outfield.num_elements() == m_fields[field]->GetNpoints(),
                       "ExactSolution array size mismatch.");
             Vmath::Zero(outfield.num_elements(), outfield, 1);
             if (m_session->DefinesFunction("ExactSolution"))
             {
                 EvaluateFunction(m_session->GetVariable(field), outfield, 
                                  "ExactSolution", time);
             }
         }

void Nektar::SolverUtils::EquationSystem::v_ExtraFldOutput	(	std::vector< Array< OneD, NekDouble > > &	fieldcoeffs,
		std::vector< std::string > &	variables
	)

protectedvirtual

Reimplemented in Nektar::CompressibleFlowSystem, Nektar::LinearElasticSystem, and Nektar::APE.

Definition at line 2629 of file EquationSystem.cpp.

Referenced by WriteFld().

2632 {

2633 }

void Nektar::SolverUtils::EquationSystem::v_GenerateSummary ( SummaryList & l )

protectedvirtual

Virtual function for generating summary information.

Reimplemented in Nektar::CoupledLinearNS, Nektar::UnsteadyViscousBurgers, Nektar::UnsteadyAdvectionDiffusion, Nektar::VelocityCorrectionScheme, Nektar::CFLtester, Nektar::LinearElasticSystem, Nektar::UnsteadyAdvection, Nektar::NonlinearPeregrine, Nektar::SolverUtils::UnsteadySystem, Nektar::PulseWavePropagation, Nektar::Monodomain, Nektar::Bidomain, Nektar::BidomainRoth, Nektar::ShallowWaterSystem, Nektar::LinearSWE, Nektar::NonlinearSWE, Nektar::ImageWarpingSystem, Nektar::IterativeElasticSystem, Nektar::Laplace, Nektar::SteadyAdvectionDiffusion, Nektar::UnsteadyDiffusion, Nektar::Projection, Nektar::VCSWeakPressure, Nektar::Helmholtz, Nektar::SteadyAdvectionDiffusionReaction, Nektar::IsentropicVortex, Nektar::RinglebFlow, and Nektar::Poisson.

Definition at line 1678 of file EquationSystem.cpp.

References SessionSummary().

Referenced by PrintSummary(), and Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary().

         {
             SessionSummary(l);
         }

void Nektar::SolverUtils::EquationSystem::v_GetFluxVector	(	const int	i,
		Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

privatevirtual

Reimplemented in Nektar::IncNavierStokes, Nektar::CFLtester, Nektar::PulseWavePropagation, Nektar::ImageWarpingSystem, and Nektar::EigenValuesAdvection.

Definition at line 2560 of file EquationSystem.cpp.

References ASSERTL0.

Referenced by GetFluxVector().

         {
             ASSERTL0(false, "v_GetFluxVector: This function is not valid "
                      "for the Base class");
         }

void Nektar::SolverUtils::EquationSystem::v_GetFluxVector	(	const int	i,
		const int	j,
		Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	flux
	)

privatevirtual

Definition at line 2569 of file EquationSystem.cpp.

References ASSERTL0.

         {
             ASSERTL0(false, "v_GetqFluxVector: This function is not valid "
                      "for the Base class");
         }

void Nektar::SolverUtils::EquationSystem::v_GetFluxVector	(	const int	i,
		Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	fluxX,
		Array< OneD, Array< OneD, NekDouble > > &	fluxY
	)

privatevirtual

Definition at line 2578 of file EquationSystem.cpp.

References ASSERTL0.

         {
             ASSERTL0(false, "v_GetFluxVector: This function is not valid "
                      "for the Base class");
         }

MultiRegions::ExpListSharedPtr Nektar::SolverUtils::EquationSystem::v_GetPressure ( void )

protectedvirtual

Reimplemented in Nektar::IncNavierStokes.

Definition at line 2622 of file EquationSystem.cpp.

References ASSERTL0.

Referenced by GetPressure().

         {
             ASSERTL0(false, "This function is not valid for the Base class");
             MultiRegions::ExpListSharedPtr null;
             return null;
         }

Array< OneD, bool > Nektar::SolverUtils::EquationSystem::v_GetSystemSingularChecks ( )

privatevirtual

Reimplemented in Nektar::VelocityCorrectionScheme, Nektar::Laplace, Nektar::Helmholtz, and Nektar::Poisson.

Definition at line 2555 of file EquationSystem.cpp.

References m_session.

Referenced by v_InitObject().

         {
             return Array<OneD, bool>(m_session->GetVariables().size(), false);
         }

void Nektar::SolverUtils::EquationSystem::v_InitObject ( )

protectedvirtual

Initialisation object for EquationSystem.

Continuous field

Setting up the normals

Reimplemented in Nektar::CoupledLinearNS, Nektar::IncNavierStokes, Nektar::PulseWaveSystem, Nektar::UnsteadyViscousBurgers, Nektar::UnsteadyAdvectionDiffusion, Nektar::LinearElasticSystem, Nektar::CFLtester, Nektar::CompressibleFlowSystem, Nektar::UnsteadyAdvection, Nektar::SolverUtils::UnsteadySystem, Nektar::UnsteadyInviscidBurger, Nektar::APE, Nektar::ShallowWaterSystem, Nektar::NonlinearPeregrine, Nektar::IterativeElasticSystem, Nektar::PulseWavePropagation, Nektar::ImageWarpingSystem, Nektar::UnsteadyDiffusion, Nektar::Monodomain, Nektar::Bidomain, Nektar::BidomainRoth, Nektar::VCSMapping, Nektar::LinearSWE, Nektar::NonlinearSWE, Nektar::PulseWaveSystemOutput, Nektar::Laplace, Nektar::SteadyAdvectionDiffusion, Nektar::Projection, Nektar::NavierStokesCFE, Nektar::EigenValuesAdvection, Nektar::Helmholtz, Nektar::SteadyAdvectionDiffusionReaction, Nektar::VelocityCorrectionScheme, Nektar::Poisson, and Nektar::SolverUtils::AdvectionSystem.

Definition at line 120 of file EquationSystem.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::FieldIO::CreateDefault(), Nektar::MultiRegions::eDiscontinuous, Nektar::LibUtilities::eFourier, Nektar::LibUtilities::eFourierEvenlySpaced, Nektar::LibUtilities::eFourierHalfModeIm, Nektar::LibUtilities::eFourierHalfModeRe, Nektar::LibUtilities::eFourierSingleMode, Nektar::LibUtilities::eFourierSingleModeSpaced, Nektar::MultiRegions::eGalerkin, eHomogeneous1D, eHomogeneous2D, eHomogeneous3D, Nektar::MultiRegions::eMixed_CG_Discontinuous, eNotHomogeneous, GetTraceNpoints(), m_boundaryConditions, m_checkIfSystemSingular, m_checksteps, m_checktime, m_expdim, m_fields, m_fintime, m_fld, m_graph, m_halfMode, m_HomoDirec, m_homogen_dealiasing, m_HomogeneousType, m_LhomY, m_LhomZ, m_multipleModes, m_nchk, m_npointsY, m_npointsZ, m_NumQuadPointsError, m_projectionType, m_session, m_sessionName, m_singleMode, m_spacedim, m_specHP_dealiasing, m_steps, m_time, m_timestep, m_traceNormals, m_useFFT, Nektar::SpatialDomains::MeshGraph::Read(), v_GetSystemSingularChecks(), and ZeroPhysFields().

Referenced by InitObject(), Nektar::EigenValuesAdvection::v_InitObject(), Nektar::Projection::v_InitObject(), Nektar::SteadyAdvectionDiffusion::v_InitObject(), Nektar::Laplace::v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), and Nektar::LinearElasticSystem::v_InitObject().

         {
             // Save the basename of input file name for output details
             m_sessionName = m_session->GetSessionName();
 
             // Instantiate a field reader/writer
             m_fld = LibUtilities::FieldIO::CreateDefault(m_session);
 
             // Read the geometry and the expansion information
             m_graph = SpatialDomains::MeshGraph::Read(m_session);
 
             // Also read and store the boundary conditions
             m_boundaryConditions =
                 MemoryManager<SpatialDomains::BoundaryConditions>::
                     AllocateSharedPtr(m_session, m_graph);
 
             // Set space dimension for use in class
             m_spacedim = m_graph->GetSpaceDimension();
  
             // Setting parameteres for homogenous problems
             m_HomoDirec             = 0;
             m_useFFT                = false;
             m_homogen_dealiasing    = false;
             m_singleMode            = false;
             m_halfMode              = false;
             m_multipleModes         = false;
             m_HomogeneousType       = eNotHomogeneous;
 
             if (m_session->DefinesSolverInfo("HOMOGENEOUS"))
             {
                 std::string HomoStr = m_session->GetSolverInfo("HOMOGENEOUS");
                 m_spacedim          = 3;
 
                 if ((HomoStr == "HOMOGENEOUS1D") || (HomoStr == "Homogeneous1D")
                     || (HomoStr == "1D") || (HomoStr == "Homo1D"))
                 {
                     m_HomogeneousType = eHomogeneous1D;
                     m_session->LoadParameter("LZ", m_LhomZ);
                     m_HomoDirec       = 1;
                 
                     if(m_session->DefinesSolverInfo("ModeType"))
                     {
                         m_session->MatchSolverInfo("ModeType", "SingleMode", 
                                                    m_singleMode, false);
                         m_session->MatchSolverInfo("ModeType", "HalfMode", 
                                                    m_halfMode, false);
                         m_session->MatchSolverInfo("ModeType", "MultipleModes", 
                                                    m_multipleModes, false);
                     }
 
                     // Stability Analysis flags
                     if (m_session->DefinesSolverInfo("ModeType"))
                     {
                         if(m_singleMode)
                         {
                             m_npointsZ = 2;
                         }
                         else if(m_halfMode)
                         {
                             m_npointsZ = 1;
                         }
                         else if(m_multipleModes)
                         {
                             m_npointsZ = m_session->GetParameter("HomModesZ");
                         }
                         else
                         {
                             ASSERTL0(false, "SolverInfo ModeType not valid");
                         }
                     }
                     else 
                     {
                         m_npointsZ = m_session->GetParameter("HomModesZ");
                     }
                 }
 
                 if ((HomoStr == "HOMOGENEOUS2D") || (HomoStr == "Homogeneous2D")
                     || (HomoStr == "2D") || (HomoStr == "Homo2D"))
                 {
                     m_HomogeneousType = eHomogeneous2D;
                     m_session->LoadParameter("HomModesY",   m_npointsY);
                     m_session->LoadParameter("LY",          m_LhomY);
                     m_session->LoadParameter("HomModesZ",   m_npointsZ);
                     m_session->LoadParameter("LZ",          m_LhomZ);
                     m_HomoDirec       = 2;
                 }
 
                 if ((HomoStr == "HOMOGENEOUS3D") || (HomoStr == "Homogeneous3D")
                     || (HomoStr == "3D") || (HomoStr == "Homo3D"))
                 {
                     m_HomogeneousType = eHomogeneous3D;
                     m_session->LoadParameter("HomModesY",   m_npointsY);
                     m_session->LoadParameter("LY",          m_LhomY);
                     m_session->LoadParameter("HomModesZ",   m_npointsZ);
                     m_session->LoadParameter("LZ",          m_LhomZ);
                     m_HomoDirec       = 2;
                 }
 
                 m_session->MatchSolverInfo("USEFFT", "FFTW", m_useFFT, false);
             
                 m_session->MatchSolverInfo("DEALIASING", "True", 
                                            m_homogen_dealiasing, false);
                 if(m_homogen_dealiasing == false)
                 {
                     m_session->MatchSolverInfo("DEALIASING", "On", 
                                                m_homogen_dealiasing, false);
                 }
             }
             else
             {
                 // set to default value so can use to identify 2d or 3D 
                 // (homogeneous) expansions
                 m_npointsZ = 1; 
             }
            
             m_session->MatchSolverInfo("SPECTRALHPDEALIASING", "True", 
                                        m_specHP_dealiasing, false);
             if (m_specHP_dealiasing == false)
             {
                 m_session->MatchSolverInfo("SPECTRALHPDEALIASING", "On", 
                                            m_specHP_dealiasing, false);
             }
  
             // Options to determine type of projection from file or directly 
             // from constructor
             if (m_session->DefinesSolverInfo("PROJECTION"))
             {
                 std::string ProjectStr = m_session->GetSolverInfo("PROJECTION");
 
                 if ((ProjectStr == "Continuous") || (ProjectStr == "Galerkin") ||
                    (ProjectStr == "CONTINUOUS") || (ProjectStr == "GALERKIN"))
                 {
                     m_projectionType = MultiRegions::eGalerkin;
                 }
                 else if ((ProjectStr == "MixedCGDG") ||
                         (ProjectStr == "Mixed_CG_Discontinuous"))
                 {
                     m_projectionType = MultiRegions::eMixed_CG_Discontinuous;
                 }                        
                 else if(ProjectStr == "DisContinuous")
                 {
                     m_projectionType = MultiRegions::eDiscontinuous;
                 }
                 else
                 {
                     ASSERTL0(false,"PROJECTION value not recognised");
                 }
             }
             else
             {
                 cerr << "Projection type not specified in SOLVERINFO,"
                     "defaulting to continuous Galerkin" << endl;
                 m_projectionType = MultiRegions::eGalerkin;
             }
 
             // Enforce singularity check for some problems
             m_checkIfSystemSingular = v_GetSystemSingularChecks();
 
             int i;
             int nvariables = m_session->GetVariables().size();
             bool DeclareCoeffPhysArrays = true;
 
 
             m_fields   = Array<OneD, MultiRegions::ExpListSharedPtr>(nvariables);
             m_spacedim = m_graph->GetSpaceDimension()+m_HomoDirec;
             m_expdim   = m_graph->GetMeshDimension();
 
             /// Continuous field
             if (m_projectionType == MultiRegions::eGalerkin ||
                m_projectionType == MultiRegions::eMixed_CG_Discontinuous)
             {
                 switch(m_expdim)
                 {
                 case 1:
                     {
                         if (m_HomogeneousType == eHomogeneous2D
                             || m_HomogeneousType == eHomogeneous3D)
                         {
                             const LibUtilities::PointsKey PkeyY
                                 (m_npointsY, LibUtilities::eFourierEvenlySpaced);
                             const LibUtilities::BasisKey  BkeyY
                                 (LibUtilities::eFourier, m_npointsY, PkeyY);
                             const LibUtilities::PointsKey PkeyZ
                                 (m_npointsZ, LibUtilities::eFourierEvenlySpaced);
                             const LibUtilities::BasisKey
                                 BkeyZ(LibUtilities::eFourier, m_npointsZ, PkeyZ);
 
                             for (i = 0; i < m_fields.num_elements(); i++)
                             {
                                 m_fields[i] = MemoryManager<MultiRegions
                                     ::ContField3DHomogeneous2D>
                                         ::AllocateSharedPtr(
                                             m_session, BkeyY, BkeyZ, m_LhomY, 
                                             m_LhomZ, m_useFFT, 
                                             m_homogen_dealiasing, m_graph, 
                                             m_session->GetVariable(i));
                             }
                         }
                         else
                         {
                             for (i = 0; i < m_fields.num_elements(); i++)
                             {
                                 m_fields[i] = MemoryManager
                                 <MultiRegions::ContField1D>::
                                     AllocateSharedPtr(
                                         m_session, m_graph,
                                         m_session->GetVariable(i));
                             }
                         }
                         break;
                     }
                 case 2:
                     {
                         if (m_HomogeneousType == eHomogeneous1D)
                         {
                             // Fourier single mode stability analysis
                             if (m_singleMode)
                             {   
                                 const LibUtilities::PointsKey PkeyZ(
                                     m_npointsZ,
                                     LibUtilities::eFourierSingleModeSpaced);
                                 
                                 const LibUtilities::BasisKey  BkeyZ(
                                     LibUtilities::eFourierSingleMode,
                                     m_npointsZ,
                                     PkeyZ);
                             
                                 for(i = 0; i < m_fields.num_elements(); i++)
                                 {
                                     m_fields[i] = MemoryManager<MultiRegions
                                         ::ContField3DHomogeneous1D>
                                             ::AllocateSharedPtr(
                                                 m_session, BkeyZ, m_LhomZ, 
                                                 m_useFFT, m_homogen_dealiasing, 
                                                 m_graph, 
                                                 m_session->GetVariable(i), 
                                                 m_checkIfSystemSingular[i]);
                                 }
                             }
                             // Half mode stability analysis
                             else if(m_halfMode)
                             {
                                 const LibUtilities::PointsKey PkeyZ(
                                     m_npointsZ,
                                     LibUtilities::eFourierSingleModeSpaced);
                                     
                                 const LibUtilities::BasisKey  BkeyZR(
                                     LibUtilities::eFourierHalfModeRe,
                                     m_npointsZ, PkeyZ);
                                 
                                 const LibUtilities::BasisKey  BkeyZI(
                                     LibUtilities::eFourierHalfModeIm,
                                     m_npointsZ, PkeyZ);
                                 
                                     
                                 for (i = 0; i < m_fields.num_elements(); i++)
                                 {
                                     if(m_session->GetVariable(i).compare("w")
                                             == 0)
                                     {
                                         m_fields[i] = MemoryManager<MultiRegions
                                             ::ContField3DHomogeneous1D>
                                                 ::AllocateSharedPtr(
                                                     m_session, BkeyZI, m_LhomZ, 
                                                     m_useFFT, 
                                                     m_homogen_dealiasing,
                                                     m_graph, 
                                                     m_session->GetVariable(i), 
                                                     m_checkIfSystemSingular[i]);
                                     }
                                     else
                                     {
                                         m_fields[i] = MemoryManager<MultiRegions
                                             ::ContField3DHomogeneous1D>
                                                 ::AllocateSharedPtr(
                                                     m_session, BkeyZR, m_LhomZ, 
                                                     m_useFFT, m_homogen_dealiasing,
                                                     m_graph, 
                                                     m_session->GetVariable(i), 
                                                     m_checkIfSystemSingular[i]);
                                     }
                                     
                                     
                                 }
                             }
                             // Normal homogeneous 1D
                             else
                             {   
                                 const LibUtilities::PointsKey PkeyZ(
                                     m_npointsZ,
                                     LibUtilities::eFourierEvenlySpaced);
                                 const LibUtilities::BasisKey  BkeyZ(
                                     LibUtilities::eFourier, m_npointsZ, PkeyZ);
                             
                                 for (i = 0; i < m_fields.num_elements(); i++)
                                 {
                                     m_fields[i] = MemoryManager<MultiRegions
                                         ::ContField3DHomogeneous1D>
                                             ::AllocateSharedPtr(
                                                 m_session, BkeyZ, m_LhomZ, 
                                                 m_useFFT, m_homogen_dealiasing,
                                                 m_graph, 
                                                 m_session->GetVariable(i), 
                                                 m_checkIfSystemSingular[i]);
                                 }
                             }
                         }
                         else
                         {
                             i = 0;
                             MultiRegions::ContField2DSharedPtr firstfield;
                             firstfield = MemoryManager<MultiRegions::
                                 ContField2D>::AllocateSharedPtr(
                                     m_session, m_graph,
                                     m_session->GetVariable(i),
                                     DeclareCoeffPhysArrays,
                                     m_checkIfSystemSingular[0]);
                             m_fields[0] = firstfield;
                             for (i = 1; i < m_fields.num_elements(); i++)
                             {
                                 if (m_graph->
                                       SameExpansions(m_session->GetVariable(0),
                                                      m_session->GetVariable(i)))
                                 {
                                     m_fields[i] = MemoryManager<MultiRegions::
                                         ContField2D>::AllocateSharedPtr(
                                             *firstfield, m_graph,
                                             m_session->GetVariable(i),
                                             DeclareCoeffPhysArrays,
                                             m_checkIfSystemSingular[i]);
                                 }
                                 else
                                 {
                                     m_fields[i] = MemoryManager<MultiRegions
                                         ::ContField2D>::AllocateSharedPtr(
                                             m_session, m_graph, 
                                             m_session->GetVariable(i),
                                             DeclareCoeffPhysArrays, 
                                             m_checkIfSystemSingular[i]);                                    
                                 }
                             }
 
                             if (m_projectionType ==
                                MultiRegions::eMixed_CG_Discontinuous)
                             {
                                 /// Setting up the normals
                                 m_traceNormals =
                                     Array<OneD, Array<OneD, NekDouble> >
                                                                    (m_spacedim);
                                 
                                 for (i = 0; i < m_spacedim; ++i)
                                 {
                                     m_traceNormals[i] = Array<OneD, NekDouble>
                                                             (GetTraceNpoints());
                                 }
                                 
                                 m_fields[0]->GetTrace()->
                                     GetNormals(m_traceNormals);
                             }
 
                         }
 
                         break;
                     }
                 case 3:
                     {
                         i = 0;
                         MultiRegions::ContField3DSharedPtr firstfield =
                             MemoryManager<MultiRegions::ContField3D>
                             ::AllocateSharedPtr(m_session, m_graph, 
                                                 m_session->GetVariable(i),
                                                 m_checkIfSystemSingular[i]);
 
                         m_fields[0] = firstfield;
                         for (i = 1; i < m_fields.num_elements(); i++)
                         {
                             if(m_graph->SameExpansions(
                                         m_session->GetVariable(0),
                                         m_session->GetVariable(i)))
                             {
                                 m_fields[i] = MemoryManager<MultiRegions
                                     ::ContField3D>::AllocateSharedPtr(
                                         *firstfield, m_graph,
                                         m_session->GetVariable(i),
                                         m_checkIfSystemSingular[i]);
                             }
                             else
                             {
                                 m_fields[i] = MemoryManager<MultiRegions
                                     ::ContField3D>::AllocateSharedPtr(
                                         m_session, m_graph, 
                                         m_session->GetVariable(i),
                                         m_checkIfSystemSingular[i]); 
                             }
                         }
                         
                         if (m_projectionType ==
                            MultiRegions::eMixed_CG_Discontinuous)
                         {
                             /// Setting up the normals
                             m_traceNormals =
                                 Array<OneD, Array<OneD, NekDouble> >
                                                                 (m_spacedim);
                             for(i = 0; i < m_spacedim; ++i)
                             {
                                 m_traceNormals[i] =
                                     Array<OneD, NekDouble> (GetTraceNpoints());
                             }
                             
                             m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
                             // Call the trace on all fields to ensure DG setup. 
                             for(i = 1; i < m_fields.num_elements(); ++i)
                             {
                                 m_fields[i]->GetTrace();
                             }
                         }
                         break;
                     }
                 default:
                     ASSERTL0(false,"Expansion dimension not recognised");
                     break;
                 }
             }
             // Discontinuous field
             else
             {
                 switch(m_expdim)
                 {
                 case 1:
                     {
                         if (m_HomogeneousType == eHomogeneous2D
                             || m_HomogeneousType == eHomogeneous3D)
                         {
                             const LibUtilities::PointsKey PkeyY(
                                 m_npointsY, LibUtilities::eFourierEvenlySpaced);
                             const LibUtilities::BasisKey  BkeyY(
                                 LibUtilities::eFourier, m_npointsY, PkeyY);
                             const LibUtilities::PointsKey PkeyZ(
                                 m_npointsZ, LibUtilities::eFourierEvenlySpaced);
                             const LibUtilities::BasisKey  BkeyZ(
                                 LibUtilities::eFourier, m_npointsZ, PkeyZ);
 
                             for (i = 0; i < m_fields.num_elements(); i++)
                             {
                                 m_fields[i] = MemoryManager<MultiRegions
                                     ::DisContField3DHomogeneous2D>
                                         ::AllocateSharedPtr(
                                             m_session, BkeyY, BkeyZ, m_LhomY, 
                                             m_LhomZ, m_useFFT, 
                                             m_homogen_dealiasing, m_graph, 
                                             m_session->GetVariable(i));
                             }
                         }
                         else
                         {
                             for (i = 0; i < m_fields.num_elements(); i++)
                             {
                                 m_fields[i] = MemoryManager<MultiRegions::
                                     DisContField1D>::AllocateSharedPtr(
                                         m_session, m_graph,
                                         m_session->GetVariable(i));
                             }
                         }
 
                         break;
                     }
                 case 2:
                     {
                         if(m_HomogeneousType == eHomogeneous1D)
                         {
                             const LibUtilities::PointsKey PkeyZ(
                                 m_npointsZ,LibUtilities::eFourierEvenlySpaced);
                             const LibUtilities::BasisKey BkeyZ(
                                 LibUtilities::eFourier, m_npointsZ,PkeyZ);
 
                             for (i = 0; i < m_fields.num_elements(); i++)
                             {
                                 m_fields[i] = MemoryManager<MultiRegions
                                     ::DisContField3DHomogeneous1D>
                                         ::AllocateSharedPtr(
                                             m_session, BkeyZ, m_LhomZ, m_useFFT, 
                                             m_homogen_dealiasing, m_graph, 
                                             m_session->GetVariable(i));
                             }
                         }
                         else
                         {
                             for (i = 0; i < m_fields.num_elements(); i++)
                             {
                                 m_fields[i] = MemoryManager<MultiRegions::
                                     DisContField2D>::AllocateSharedPtr(
                                         m_session, m_graph,
                                         m_session->GetVariable(i));
                             }
                         }
 
                         break;
                     }
                 case 3:
                     {
                         if (m_HomogeneousType == eHomogeneous3D)
                         {
                             ASSERTL0(false,
                               "3D fully periodic problems not implemented yet");
                         }
                         else
                         {
                             for (i = 0; i < m_fields.num_elements(); i++)
                             {
                                 m_fields[i] = MemoryManager<MultiRegions::
                                     DisContField3D>::AllocateSharedPtr(
                                         m_session, m_graph,
                                         m_session->GetVariable(i));
                             }
                         }
                         break;
                     }
                     default:
                         ASSERTL0(false, "Expansion dimension not recognised");
                         break;
                 }
 
                 // Setting up the normals
                 m_traceNormals =
                     Array<OneD, Array<OneD, NekDouble> >(m_spacedim);
                 
                 for (i = 0; i < m_spacedim; ++i)
                 {
                     m_traceNormals[i] =
                         Array<OneD, NekDouble> (GetTraceNpoints(), 0.0);
                 }
 
                 m_fields[0]->GetTrace()->GetNormals(m_traceNormals);
             }
 
             // Set Default Parameter
             m_session->LoadParameter("Time",          m_time,       0.0);
             m_session->LoadParameter("TimeStep",      m_timestep,   0.01);
             m_session->LoadParameter("NumSteps",      m_steps,      0);
             m_session->LoadParameter("IO_CheckSteps", m_checksteps, 0);
             m_session->LoadParameter("IO_CheckTime",  m_checktime,  0.0);
             m_session->LoadParameter("FinTime",       m_fintime,    0);
             m_session->LoadParameter("NumQuadPointsError",
                                      m_NumQuadPointsError, 0);
 
             m_nchk = 0;
 
             // Zero all physical fields initially
             ZeroPhysFields();
         }

NekDouble Nektar::SolverUtils::EquationSystem::v_L2Error	(	unsigned int	field,
		const Array< OneD, NekDouble > &	exactsoln = `NullNekDouble1DArray`,
		bool	Normalised = `false`
	)

protectedvirtual

Virtual function for the L_2 error computation between fields and a given exact solution.

Compute the error in the L2-norm.

Parameters

field	The field to compare.
exactsoln	The exact solution to compare with.
Normalised	Normalise L2-error.

Returns: Error in the L2-norm.

Reimplemented in Nektar::PulseWaveSystem.

Definition at line 1170 of file EquationSystem.cpp.

References ErrorExtraPoints(), EvaluateFunction(), GetNpoints(), m_comm, m_fields, m_NumQuadPointsError, m_session, m_time, and Nektar::LibUtilities::ReduceSum.

Referenced by L2Error().

         {       
             NekDouble L2error = -1.0;
 
             if (m_NumQuadPointsError == 0)
             {
                 if (m_fields[field]->GetPhysState() == false)
                 {
                     m_fields[field]->BwdTrans(m_fields[field]->GetCoeffs(),
                                               m_fields[field]->UpdatePhys());
                 }
 
                 if (exactsoln.num_elements())
                 {
                     L2error = m_fields[field]->L2(m_fields[field]->GetPhys(), exactsoln);
                 }
                 else if (m_session->DefinesFunction("ExactSolution"))
                 {
                     Array<OneD, NekDouble>
                         exactsoln(m_fields[field]->GetNpoints());
 
                     EvaluateFunction(m_session->GetVariable(field), exactsoln, 
                                      "ExactSolution", m_time);
 
                     L2error = m_fields[field]->L2(m_fields[field]->GetPhys(), exactsoln);
                 }
                 else
                 {
                     L2error = m_fields[field]->L2(m_fields[field]->GetPhys());
                 }
 
                 if (Normalised == true)
                 {
                     Array<OneD, NekDouble> one(m_fields[field]->GetNpoints(),
                                                1.0);
 
                     NekDouble Vol = m_fields[field]->PhysIntegral(one);
                     m_comm->AllReduce(Vol, LibUtilities::ReduceSum);
 
                     L2error = sqrt(L2error*L2error/Vol);
                 }
             }
             else
             {
                 Array<OneD,NekDouble> L2INF(2);
                 L2INF = ErrorExtraPoints(field);
                 L2error = L2INF[0];
             }
             return L2error;
         }

NekDouble Nektar::SolverUtils::EquationSystem::v_LinfError	(	unsigned int	field,
		const Array< OneD, NekDouble > &	exactsoln = `NullNekDouble1DArray`
	)

protectedvirtual

Virtual function for the L_inf error computation between fields and a given exact solution.

Compute the error in the L_inf-norm

Parameters

field	The field to compare.
exactsoln	The exact solution to compare with.

Returns: Error in the L_inft-norm.

Reimplemented in Nektar::PulseWaveSystem.

Definition at line 1230 of file EquationSystem.cpp.

References ErrorExtraPoints(), EvaluateFunction(), GetNpoints(), m_fields, m_NumQuadPointsError, m_session, and m_time.

Referenced by LinfError().

         {
             NekDouble Linferror = -1.0;
 
             if (m_NumQuadPointsError == 0)
             {
                 if (m_fields[field]->GetPhysState() == false)
                 {
                     m_fields[field]->BwdTrans(m_fields[field]->GetCoeffs(),
                                               m_fields[field]->UpdatePhys());
                 }
 
                 if (exactsoln.num_elements())
                 {
                     Linferror = m_fields[field]->Linf(m_fields[field]->GetPhys(), exactsoln);
                 }
                 else if (m_session->DefinesFunction("ExactSolution"))
                 {
                     Array<OneD, NekDouble>
                         exactsoln(m_fields[field]->GetNpoints());
 
                     EvaluateFunction(m_session->GetVariable(field), exactsoln,
                                      "ExactSolution", m_time);
 
                     Linferror = m_fields[field]->Linf(m_fields[field]->GetPhys(), exactsoln);
                 }
                 else
                 {
                     Linferror = m_fields[field]->Linf(m_fields[field]->GetPhys());
                 }
             }
             else
             {
                 Array<OneD,NekDouble> L2INF(2);
                 L2INF = ErrorExtraPoints(field);
                 Linferror = L2INF[1];
             }
 
             return Linferror;
         }

bool Nektar::SolverUtils::EquationSystem::v_NegatedOp ( void )

virtual

Virtual function to identify if operator is negated in DoSolve.

Virtual function to define if operator in DoSolve is negated with regard to the strong form. This is currently only used in Arnoldi solves. Default is false.

Reimplemented in Nektar::CoupledLinearNS.

Definition at line 1655 of file EquationSystem.cpp.

         {
             return false; 
         }

void Nektar::SolverUtils::EquationSystem::v_NumericalFlux	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numflux
	)

privatevirtual

Reimplemented in Nektar::IncNavierStokes, Nektar::CFLtester, Nektar::SolverUtils::UnsteadySystem, Nektar::PulseWavePropagation, Nektar::ImageWarpingSystem, and Nektar::EigenValuesAdvection.

Definition at line 2588 of file EquationSystem.cpp.

References ASSERTL0.

Referenced by NumericalFlux().

         {
             ASSERTL0(false, "v_NumericalFlux: This function is not valid "
                      "for the Base class");
         }

void Nektar::SolverUtils::EquationSystem::v_NumericalFlux	(	Array< OneD, Array< OneD, NekDouble > > &	physfield,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxX,
		Array< OneD, Array< OneD, NekDouble > > &	numfluxY
	)

privatevirtual

Reimplemented in Nektar::SolverUtils::UnsteadySystem.

Definition at line 2596 of file EquationSystem.cpp.

References ASSERTL0.

         {
             ASSERTL0(false, "v_NumericalFlux: This function is not valid "
                      "for the Base class");
         }

void Nektar::SolverUtils::EquationSystem::v_NumFluxforScalar	(	const Array< OneD, Array< OneD, NekDouble > > &	ufield,
		Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &	uflux
	)

privatevirtual

Reimplemented in Nektar::SolverUtils::UnsteadySystem.

Definition at line 2605 of file EquationSystem.cpp.

References ASSERTL0.

Referenced by NumFluxforScalar().

         {
             ASSERTL0(false, "v_NumFluxforScalar: This function is not valid "
                      "for the Base class");
         }

void Nektar::SolverUtils::EquationSystem::v_NumFluxforVector	(	const Array< OneD, Array< OneD, NekDouble > > &	ufield,
		Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &	qfield,
		Array< OneD, Array< OneD, NekDouble > > &	qflux
	)

privatevirtual

Reimplemented in Nektar::SolverUtils::UnsteadySystem.

Definition at line 2613 of file EquationSystem.cpp.

References ASSERTL0.

Referenced by NumFluxforVector().

         {
             ASSERTL0(false, "v_NumFluxforVector: This function is not valid "
                      "for the Base class");
         }

void Nektar::SolverUtils::EquationSystem::v_Output ( void )

protectedvirtual

Write the field data to file. The file is named according to the session name with the extension .fld appended.

Reimplemented in Nektar::CoupledLinearNS, and Nektar::PulseWaveSystem.

Definition at line 1688 of file EquationSystem.cpp.

References m_sessionName, and WriteFld().

Referenced by Output().

         {
             WriteFld(m_sessionName + ".fld");
         }

void Nektar::SolverUtils::EquationSystem::v_SetInitialConditions	(	NekDouble	initialtime = `0.0`,
		bool	dumpInitialConditions = `true`,
		const int	domain = `0`
	)

protectedvirtual

Set the physical fields based on a restart file, or a function describing the initial condition given in the session.

Parameters

initialtime	Time at which to evaluate the function.
dumpInitialConditions	Write the initial condition to file?

Reimplemented in Nektar::CompressibleFlowSystem, Nektar::NonlinearPeregrine, Nektar::Monodomain, Nektar::Bidomain, Nektar::BidomainRoth, and Nektar::IsentropicVortex.

Definition at line 1351 of file EquationSystem.cpp.

References Checkpoint_Output(), DescribeFunction(), EvaluateFunction(), GetNcoeffs(), m_checksteps, m_fields, m_nchk, m_session, m_time, and Vmath::Zero().

Referenced by SetInitialConditions(), Nektar::Bidomain::v_SetInitialConditions(), Nektar::BidomainRoth::v_SetInitialConditions(), Nektar::Monodomain::v_SetInitialConditions(), Nektar::NonlinearPeregrine::v_SetInitialConditions(), and Nektar::CompressibleFlowSystem::v_SetInitialConditions().

         {
             if (m_session->GetComm()->GetRank() == 0)
             {
                 cout << "Initial Conditions:" << endl;
             }
         
             if (m_session->DefinesFunction("InitialConditions"))
             {
                 EvaluateFunction(m_session->GetVariables(), m_fields, 
                                  "InitialConditions", m_time, domain);
                 
                 if (m_session->GetComm()->GetRank() == 0)
                 {
                     
                     for (int i = 0; i < m_fields.num_elements(); ++i)
                     {
                         std::string varName = m_session->GetVariable(i);
                         cout << "  - Field " << varName << ": "
                              << DescribeFunction(varName, "InitialConditions",domain)
                              << endl;
                     }
                 }
             }
             else
             {
                 int nq = m_fields[0]->GetNpoints();
                 for (int i = 0; i < m_fields.num_elements(); i++)
                 {
                     Vmath::Zero(nq, m_fields[i]->UpdatePhys(), 1);
                     m_fields[i]->SetPhysState(true);
                     Vmath::Zero(m_fields[i]->GetNcoeffs(), 
                                 m_fields[i]->UpdateCoeffs(), 1);
                     if (m_session->GetComm()->GetRank() == 0)
                     {
                         cout << "  - Field "    << m_session->GetVariable(i)
                              << ": 0 (default)" << endl;
                     }
                 }
 
             }
 
             if (dumpInitialConditions && m_checksteps)
             {
                 Checkpoint_Output(m_nchk);
                 m_nchk++;
             }
         }

void Nektar::SolverUtils::EquationSystem::v_TransCoeffToPhys ( void )

protectedvirtual

Virtual function for transformation to physical space.

Reimplemented in Nektar::IncNavierStokes, Nektar::CoupledLinearNS, and Nektar::VelocityCorrectionScheme.

Definition at line 1663 of file EquationSystem.cpp.

Referenced by TransCoeffToPhys().

         {
         
         }

void Nektar::SolverUtils::EquationSystem::v_TransPhysToCoeff ( void )

protectedvirtual

Virtual function for transformation to coefficient space.

Reimplemented in Nektar::IncNavierStokes, Nektar::CoupledLinearNS, and Nektar::VelocityCorrectionScheme.

Definition at line 1671 of file EquationSystem.cpp.

Referenced by TransPhysToCoeff().

         {
         
         }

void Nektar::SolverUtils::EquationSystem::WeakAdvectionDivergenceForm	(	const Array< OneD, Array< OneD, NekDouble > > &	F,
		Array< OneD, NekDouble > &	outarray
	)

Compute the inner product $(\phi, \nabla \cdot F)$ .

Calculate Inner product of the divergence advection form $(\phi, \nabla \cdot F)$ , where for example $ F = uV $ .

Parameters

F	Fields.
outarray	Storage for result.

Definition at line 1741 of file EquationSystem.cpp.

References Nektar::MultiRegions::DirCartesianMap, m_fields, and Vmath::Vadd().

         {
             // Use dimension of Velocity vector to dictate dimension of operation
             int ndim       = F.num_elements();
             int nPointsTot = m_fields[0]->GetNpoints();
             Array<OneD, NekDouble> tmp(nPointsTot);
             Array<OneD, NekDouble> div(nPointsTot, 0.0);
 
             // Evaluate the divergence
             for (int i = 0; i < ndim; ++i)
             {
                 //m_fields[0]->PhysDeriv(i,F[i],tmp);
                 m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[i],F[i],tmp);
                 Vmath::Vadd(nPointsTot, tmp, 1, div, 1, div, 1);
             }
 
             m_fields[0]->IProductWRTBase(div, outarray);
         }

void Nektar::SolverUtils::EquationSystem::WeakAdvectionGreensDivergenceForm	(	const Array< OneD, Array< OneD, NekDouble > > &	F,
		Array< OneD, NekDouble > &	outarray
	)

Compute the inner product $(\nabla \phi \cdot F)$ .

Computes the weak Green form of advection terms (without boundary integral), i.e. $(\nabla \phi \cdot F)$ where for example $ F=uV $ .

Parameters

F	Fields.
outarray	Storage for result.

Note: Assuming all fields are of the same expansion and order so that we can use the parameters of m_fields[0].

Definition at line 1728 of file EquationSystem.cpp.

References m_fields.

Referenced by WeakDGAdvection(), and WeakDGDiffusion().

         {
             m_fields[0]->IProductWRTDerivBase(F,outarray);
         }

void Nektar::SolverUtils::EquationSystem::WeakAdvectionNonConservativeForm	(	const Array< OneD, Array< OneD, NekDouble > > &	V,
		const Array< OneD, const NekDouble > &	u,
		Array< OneD, NekDouble > &	outarray,
		bool	UseContCoeffs = `false`
	)

Compute the inner product $(\phi, V\cdot \nabla u)$ .

Calculate Inner product of the divergence advection form $(\phi, V\cdot \nabla u)$

Parameters

V	Fields.
u	Fields.
outarray	Storage for result.

Definition at line 1769 of file EquationSystem.cpp.

References AdvectionNonConservativeForm(), Nektar::MultiRegions::eGlobal, and m_fields.

         {
             // use dimension of Velocity vector to dictate dimension of operation
             int ndim       = V.num_elements();
 
             int nPointsTot = m_fields[0]->GetNpoints();
             Array<OneD, NekDouble> tmp(nPointsTot);
             Array<OneD, NekDouble> wk(ndim * nPointsTot, 0.0);
 
             AdvectionNonConservativeForm(V, u, tmp, wk);
         
             if (UseContCoeffs)
             {
                 m_fields[0]->IProductWRTBase(tmp, outarray,
                                              MultiRegions::eGlobal);
             }
             else
             {
                 m_fields[0]->IProductWRTBase_IterPerExp(tmp, outarray);
             }
         }

void Nektar::SolverUtils::EquationSystem::WeakDGAdvection	(	const Array< OneD, Array< OneD, NekDouble > > &	InField,
		Array< OneD, Array< OneD, NekDouble > > &	OutField,
		bool	NumericalFluxIncludesNormal = `true`,
		bool	InFieldIsInPhysSpace = `false`,
		int	nvariables = `0`
	)

Calculate the weak discontinuous Galerkin advection.

Calculate weak DG advection in the form $\langle\phi, \hat{F}\cdot n\rangle - (\nabla \phi \cdot F)$ .

Parameters

InField	Fields.
OutField	Storage for result.
NumericalFluxIncludesNormal	Default: true.
InFieldIsPhysSpace	Default: false.
nvariables	Number of fields.

Definition at line 1866 of file EquationSystem.cpp.

References GetFluxVector(), GetNcoeffs(), GetNpoints(), GetTraceNpoints(), m_expdim, m_fields, Vmath::Neg(), NumericalFlux(), and WeakAdvectionGreensDivergenceForm().

Referenced by Nektar::ImageWarpingSystem::DoOdeRhs(), Nektar::PulseWavePropagation::DoOdeRhs(), Nektar::CFLtester::DoOdeRhs(), and Nektar::EigenValuesAdvection::v_DoSolve().

         {
             int i;
             int nVelDim         = m_expdim;
             int nPointsTot      = GetNpoints();
             int ncoeffs         = GetNcoeffs();
             int nTracePointsTot = GetTraceNpoints();
 
             if (!nvariables)
             {
                 nvariables      = m_fields.num_elements();
             }
 
             Array<OneD, Array<OneD, NekDouble> > fluxvector(nVelDim);
             Array<OneD, Array<OneD, NekDouble> > physfield (nvariables);
 
             for(i = 0; i < nVelDim; ++i)
             {
                 fluxvector[i]    = Array<OneD, NekDouble>(nPointsTot);
             }
 
             // Get the variables in physical space
             // already in physical space
             if (InFieldIsInPhysSpace == true)
             {
                 for (i = 0; i < nvariables; ++i)
                 {
                     physfield[i] = InField[i];
                 }
             }
             // otherwise do a backward transformation
             else
             {
                 for(i = 0; i < nvariables; ++i)
                 {
                     // Could make this point to m_fields[i]->UpdatePhys();
                     physfield[i] = Array<OneD, NekDouble>(nPointsTot);
                     m_fields[i]->BwdTrans(InField[i],physfield[i]);
                 }
             }
 
             // Get the advection part (without numerical flux)
             for (i = 0; i < nvariables; ++i)
             {
                 // Get the ith component of the  flux vector in (physical space)
                 GetFluxVector(i, physfield, fluxvector);
 
                 // Calculate the i^th value of (\grad_i \phi, F)
                 WeakAdvectionGreensDivergenceForm(fluxvector,OutField[i]);
             }
 
             // Get the numerical flux and add to the modal coeffs
             // if the NumericalFluxs function already includes the
             // normal in the output
             if (NumericalFluxIncludesNormal == true)
             {
                 Array<OneD, Array<OneD, NekDouble> > numflux   (nvariables);
 
                 for (i = 0; i < nvariables; ++i)
                 {
                     numflux[i]   = Array<OneD, NekDouble>(nTracePointsTot);
                 }
 
                 // Evaluate numerical flux in physical space which may in
                 // general couple all component of vectors
                 NumericalFlux(physfield, numflux);
 
                 // Evaulate  <\phi, \hat{F}\cdot n> - OutField[i]
                 for (i = 0; i < nvariables; ++i)
                 {
                     Vmath::Neg(ncoeffs,OutField[i],1);
                     m_fields[i]->AddTraceIntegral(numflux[i],OutField[i]);
                     m_fields[i]->SetPhysState(false);
                 }
             }
             // if the NumericalFlux function does not include the
             // normal in the output
             else
             {
                 Array<OneD, Array<OneD, NekDouble> > numfluxX   (nvariables);
                 Array<OneD, Array<OneD, NekDouble> > numfluxY   (nvariables);
 
                 for (i = 0; i < nvariables; ++i)
                 {
                     numfluxX[i]   = Array<OneD, NekDouble>(nTracePointsTot);
                     numfluxY[i]   = Array<OneD, NekDouble>(nTracePointsTot);
                 }
 
                 // Evaluate numerical flux in physical space which may in
                 // general couple all component of vectors
                 NumericalFlux(physfield, numfluxX, numfluxY);
 
                 // Evaulate  <\phi, \hat{F}\cdot n> - OutField[i]
                 for(i = 0; i < nvariables; ++i)
                 {
                     Vmath::Neg(ncoeffs,OutField[i],1);
                     m_fields[i]->AddTraceIntegral(numfluxX[i], numfluxY[i],
                                                   OutField[i]);
                     m_fields[i]->SetPhysState(false);
                 }
             }
         }

void Nektar::SolverUtils::EquationSystem::WeakDGDiffusion	(	const Array< OneD, Array< OneD, NekDouble > > &	InField,
		Array< OneD, Array< OneD, NekDouble > > &	OutField,
		bool	NumericalFluxIncludesNormal = `true`,
		bool	InFieldIsInPhysSpace = `false`
	)

Calculate weak DG Diffusion in the LDG form.

Calculate weak DG Diffusion in the LDG form $\langle\psi, \hat{u}\cdot n\rangle - \langle\nabla\psi \cdot u\rangle \langle\phi, \hat{q}\cdot n\rangle - (\nabla \phi \cdot q) \rangle$

Definition at line 1980 of file EquationSystem.cpp.

References GetFluxVector(), GetNcoeffs(), GetNpoints(), GetTraceNpoints(), m_fields, m_spacedim, m_tanbasis, Vmath::Neg(), NumFluxforScalar(), NumFluxforVector(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vmul(), and WeakAdvectionGreensDivergenceForm().

         {
             int i, j, k;
             int nPointsTot      = GetNpoints();
             int ncoeffs         = GetNcoeffs();
             int nTracePointsTot = GetTraceNpoints();
             int nvariables      = m_fields.num_elements();
             int nqvar           = 2;
 
             Array<OneD, NekDouble>  qcoeffs (ncoeffs);
             Array<OneD, NekDouble>  temp (ncoeffs);
 
             Array<OneD, Array<OneD, NekDouble> > fluxvector (m_spacedim);
             Array<OneD, Array<OneD, NekDouble> > ufield (nvariables);
 
             Array<OneD, Array<OneD, Array<OneD, NekDouble> > >  flux   (nqvar);
             Array<OneD, Array<OneD, Array<OneD, NekDouble> > >  qfield  (nqvar);
 
             for (j = 0; j < nqvar; ++j)
             {
                 qfield[j]   = Array<OneD, Array<OneD, NekDouble> >(nqvar);
                 flux[j]     = Array<OneD, Array<OneD, NekDouble> >(nqvar);
 
                 for (i = 0; i< nvariables; ++i)
                 {
                     ufield[i] = Array<OneD, NekDouble>(nPointsTot, 0.0);
                     qfield[j][i]  = Array<OneD, NekDouble>(nPointsTot, 0.0);
                     flux[j][i] = Array<OneD, NekDouble>(nTracePointsTot, 0.0);
                 }
             }
 
             for (k = 0; k < m_spacedim; ++k)
             {
                 fluxvector[k] = Array<OneD, NekDouble>(nPointsTot, 0.0);
             }
 
             // Get the variables in physical space already in physical space
             if (InFieldIsInPhysSpace == true)
             {
                 for (i = 0; i < nvariables; ++i)
                 {
                     ufield[i] = InField[i];
                 }
             }
             // Otherwise do a backward transformation
             else
             {
                 for (i = 0; i < nvariables; ++i)
                 {
                     // Could make this point to m_fields[i]->UpdatePhys();
                     ufield[i] = Array<OneD, NekDouble>(nPointsTot);
                     m_fields[i]->BwdTrans(InField[i],ufield[i]);
                 }
             }
 
             // ##########################################################
             // Compute q_{\eta} and q_{\xi} from su
             // Obtain Numerical Fluxes
             // ##########################################################
             NumFluxforScalar(ufield, flux);
 
             for (j = 0; j < nqvar; ++j)
             {
                 for (i = 0; i < nvariables; ++i)
                 {
                     // Get the ith component of the  flux vector in
                     // (physical space) fluxvector = m_tanbasis * u,
                     // where m_tanbasis = 2 by m_spacedim by nPointsTot
                     if (m_tanbasis.num_elements())
                     {
                         for (k = 0; k < m_spacedim; ++k)
                         {
                             Vmath::Vmul(nPointsTot, m_tanbasis[j][k], 1,
                                         ufield[i], 1, fluxvector[k], 1);
                         }
                     }
                     else
                     {
                         GetFluxVector(i, j, ufield, fluxvector);
                     }
 
                     // Calculate the i^th value of (\grad_i \phi, F)
                     WeakAdvectionGreensDivergenceForm(fluxvector, qcoeffs);
 
                     Vmath::Neg(ncoeffs,qcoeffs,1);
                     m_fields[i]->AddTraceIntegral(flux[j][i], qcoeffs);
                     m_fields[i]->SetPhysState(false);
 
                     // Add weighted mass matrix = M ( \nabla \cdot Tanbasis )
 //                if(m_gradtan.num_elements())
 //                {
 //                    MultiRegions::GlobalMatrixKey key(StdRegions::eMass,
 //                                                        m_gradtan[j]);
 //                    m_fields[i]->MultiRegions::ExpList::GeneralMatrixOp(key,
 //                                                        InField[i], temp);
 //                    Vmath::Svtvp(ncoeffs, -1.0, temp, 1, qcoeffs, 1,
 //                                                        qcoeffs, 1);
 //                }
 
                     //Multiply by the inverse of mass matrix
                     m_fields[i]->MultiplyByElmtInvMass(qcoeffs, qcoeffs);
 
                     // Back to physical space
                     m_fields[i]->BwdTrans(qcoeffs, qfield[j][i]);
                 }
             }
 
 
             // ##########################################################
             //   Compute u from q_{\eta} and q_{\xi}
             // ##########################################################
 
             // Obtain Numerical Fluxes
             NumFluxforVector(ufield, qfield, flux[0]);
 
             for (i = 0; i < nvariables; ++i)
             {
                 // L = L(tan_eta) q_eta + L(tan_xi) q_xi
                 OutField[i] = Array<OneD, NekDouble>(ncoeffs, 0.0);
                 temp = Array<OneD, NekDouble>(ncoeffs, 0.0);
 
                 if (m_tanbasis.num_elements())
                 {
                     for (j = 0; j < nqvar; ++j)
                     {
                         for (k = 0; k < m_spacedim; ++k)
                         {
                             Vmath::Vmul(nPointsTot, m_tanbasis[j][k], 1,
                                         qfield[j][i], 1, fluxvector[k], 1);
                         }
 
                         WeakAdvectionGreensDivergenceForm(fluxvector, temp);
                         Vmath::Vadd(ncoeffs, temp, 1, OutField[i], 1,
                                     OutField[i], 1);
                     }
                 }
                 else
                 {
                     for (k = 0; k < m_spacedim; ++k)
                     {
                         Vmath::Vcopy(nPointsTot, qfield[k][i], 1,
                                      fluxvector[k], 1);
                     }
 
                     WeakAdvectionGreensDivergenceForm(fluxvector, OutField[i]);
                 }
 
                 // Evaulate  <\phi, \hat{F}\cdot n> - OutField[i]
                 Vmath::Neg(ncoeffs,OutField[i],1);
                 m_fields[i]->AddTraceIntegral(flux[0][i], OutField[i]);
                 m_fields[i]->SetPhysState(false);
             }
         }

void Nektar::SolverUtils::EquationSystem::WriteFld ( const std::string & outname )

Write field data to the given filename.

Writes the field data to a file with the given filename.

Parameters

outname Filename to write to.

Definition at line 2180 of file EquationSystem.cpp.

References GetNcoeffs(), m_boundaryConditions, m_fields, and v_ExtraFldOutput().

Referenced by Checkpoint_BaseFlow(), Checkpoint_Output(), Nektar::BidomainRoth::v_InitObject(), Nektar::Monodomain::v_InitObject(), Nektar::CoupledLinearNS::v_Output(), and v_Output().

         {
             std::vector<Array<OneD, NekDouble> > fieldcoeffs(
                 m_fields.num_elements());
             std::vector<std::string> variables(m_fields.num_elements());
 
             for (int i = 0; i < m_fields.num_elements(); ++i)
             {
                 if (m_fields[i]->GetNcoeffs() == m_fields[0]->GetNcoeffs())
                 {
                     fieldcoeffs[i] = m_fields[i]->UpdateCoeffs();
                 }
                 else
                 {
                     fieldcoeffs[i] = Array<OneD,NekDouble>(m_fields[0]->
                                                            GetNcoeffs());
                     m_fields[0]->ExtractCoeffsToCoeffs(m_fields[i],
                                                        m_fields[i]->GetCoeffs(),
                                                        fieldcoeffs[i]);
                 }
                 variables[i] = m_boundaryConditions->GetVariable(i);
             }
 
             v_ExtraFldOutput(fieldcoeffs, variables);
 
             WriteFld(outname, m_fields[0], fieldcoeffs, variables);
         }

void Nektar::SolverUtils::EquationSystem::WriteFld	(	const std::string &	outname,
		MultiRegions::ExpListSharedPtr &	field,
		std::vector< Array< OneD, NekDouble > > &	fieldcoeffs,
		std::vector< std::string > &	variables
	)

Write input fields to the given filename.

Writes the field data to a file with the given filename.

Parameters

outname	Filename to write to.
field	ExpList on which data is based.
fieldcoeffs	An array of array of expansion coefficients.
variables	An array of variable names.

Definition at line 2217 of file EquationSystem.cpp.

References Nektar::GlobalMapping::Mapping::Load(), m_fieldMetaDataMap, m_fld, m_nchk, m_session, m_time, and Nektar::GlobalMapping::MappingSharedPtr.

         {
             std::vector<LibUtilities::FieldDefinitionsSharedPtr> FieldDef
                 = field->GetFieldDefinitions();
             std::vector<std::vector<NekDouble> > FieldData(FieldDef.size());
 
             // Copy Data into FieldData and set variable
             for(int j = 0; j < fieldcoeffs.size(); ++j)
             {
                 for(int i = 0; i < FieldDef.size(); ++i)
                 {
                     // Could do a search here to find correct variable
                     FieldDef[i]->m_fields.push_back(variables[j]);
                     field->AppendFieldData(FieldDef[i], FieldData[i],
                                            fieldcoeffs[j]);
                 }            
             }
 
             // Update time in field info if required
             if(m_fieldMetaDataMap.find("Time") != m_fieldMetaDataMap.end())
             {
                 m_fieldMetaDataMap["Time"] = boost::lexical_cast<std::string>(m_time);
             }
 
             // Update step in field info if required
             if(m_fieldMetaDataMap.find("ChkFileNum") != m_fieldMetaDataMap.end())
             {
                 m_fieldMetaDataMap["ChkFileNum"] = boost::lexical_cast<std::string>(m_nchk);
             }
             
             // If necessary, add mapping information to metadata
             //      and output mapping coordinates
             Array<OneD, MultiRegions::ExpListSharedPtr> fields(1);
             fields[0] = field;           
             GlobalMapping::MappingSharedPtr mapping = 
                     GlobalMapping::Mapping::Load(m_session, fields);
             LibUtilities::FieldMetaDataMap fieldMetaDataMap(m_fieldMetaDataMap);
             mapping->Output( fieldMetaDataMap, outname);
 
             m_fld->Write(outname, FieldDef, FieldData, fieldMetaDataMap, true);
         }

SOLVER_UTILS_EXPORT void Nektar::SolverUtils::EquationSystem::WriteHistoryData ( std::ostream & out )

Probe each history point and write to file.

void Nektar::SolverUtils::EquationSystem::ZeroPhysFields ( void )

Zero the physical fields.

Definition at line 1696 of file EquationSystem.cpp.

References GetNpoints(), m_fields, and Vmath::Zero().

Referenced by Nektar::PulseWaveSystem::v_InitObject(), and v_InitObject().

         {
             for (int i = 0; i < m_fields.num_elements(); i++)
             {
                 Vmath::Zero(m_fields[i]->GetNpoints(),
                             m_fields[i]->UpdatePhys(),1);
             }
         }

Member Data Documentation

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::SolverUtils::EquationSystem::m_base

protected

Base fields.

Definition at line 472 of file EquationSystem.h.

Referenced by ImportFldBase(), and SetUpBaseFields().

SpatialDomains::BoundaryConditionsSharedPtr Nektar::SolverUtils::EquationSystem::m_boundaryConditions

protected

Pointer to boundary conditions object.

Definition at line 476 of file EquationSystem.h.

Referenced by Nektar::CoupledLinearNS::DefineForcingTerm(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::IncNavierStokes::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), v_InitObject(), Nektar::CoupledLinearNS::v_Output(), and WriteFld().

Array<OneD, bool> Nektar::SolverUtils::EquationSystem::m_checkIfSystemSingular

protected

Flag to indicate if the fields should be checked for singularity.

Definition at line 530 of file EquationSystem.h.

Referenced by v_InitObject().

int Nektar::SolverUtils::EquationSystem::m_checksteps

protected

Number of steps between checkpoints.

Definition at line 498 of file EquationSystem.h.

Referenced by GetCheckpointSteps(), SetCheckpointSteps(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), Nektar::PulseWaveSystem::v_InitObject(), v_InitObject(), Nektar::IsentropicVortex::v_SetInitialConditions(), and v_SetInitialConditions().

NekDouble Nektar::SolverUtils::EquationSystem::m_checktime

protected

Time between checkpoints.

Definition at line 492 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), and v_InitObject().

LibUtilities::CommSharedPtr Nektar::SolverUtils::EquationSystem::m_comm

protected

Communicator.

Definition at line 458 of file EquationSystem.h.

Referenced by Nektar::CompressibleFlowSystem::CalcSteadyState(), Nektar::APE::GetCFLEstimate(), Nektar::IncNavierStokes::GetCFLEstimate(), Nektar::CompressibleFlowSystem::InitializeSteadyState(), LoadPts(), Nektar::CompressibleFlowSystem::v_GetTimeStep(), Nektar::IterativeElasticSystem::v_InitObject(), Nektar::PulseWaveSystem::v_L2Error(), v_L2Error(), Nektar::APE::v_PostIntegrate(), Nektar::CompressibleFlowSystem::v_PostIntegrate(), Nektar::IncNavierStokes::v_PostIntegrate(), and Nektar::CompressibleFlowSystem::v_SetInitialConditions().

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::SolverUtils::EquationSystem::m_derivedfields

protected

Array holding all dependent variables.

Definition at line 474 of file EquationSystem.h.

int Nektar::SolverUtils::EquationSystem::m_expdim

protected

Expansion dimension.

Definition at line 502 of file EquationSystem.h.

Referenced by Nektar::UnsteadyAdvection::GetFluxVectorDeAlias(), Nektar::CFLtester::GetStdVelocity(), SessionSummary(), SetUpBaseFields(), v_InitObject(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryForcing(), and WeakDGAdvection().

LibUtilities::FieldMetaDataMap Nektar::SolverUtils::EquationSystem::m_fieldMetaDataMap

protected

Map to identify relevant solver info to dump in output fields.

Definition at line 532 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::CheckForRestartTime(), EquationSystem(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), WriteFld(), and Nektar::PulseWaveSystem::WriteVessels().

Array<OneD, MultiRegions::ExpListSharedPtr> Nektar::SolverUtils::EquationSystem::m_fields

protected

Array holding all dependent variables.

Definition at line 470 of file EquationSystem.h.

NekDouble Nektar::SolverUtils::EquationSystem::m_fintime

protected

Finish time of the simulation.

Definition at line 486 of file EquationSystem.h.

Referenced by Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::PulseWaveSystem::v_InitObject(), and v_InitObject().

LibUtilities::FieldIOSharedPtr Nektar::SolverUtils::EquationSystem::m_fld

protected

Field input/output.

Definition at line 462 of file EquationSystem.h.

Referenced by v_InitObject(), and WriteFld().

Array<OneD, Array<OneD, Array<OneD,NekDouble> > > Nektar::SolverUtils::EquationSystem::m_gradtan

protected

1 x nvariable x nq

Definition at line 526 of file EquationSystem.h.

SpatialDomains::MeshGraphSharedPtr Nektar::SolverUtils::EquationSystem::m_graph

protected

Pointer to graph defining mesh.

Definition at line 478 of file EquationSystem.h.

Referenced by ErrorExtraPoints(), Nektar::CoupledLinearNS::GenPressureExp(), GetNumExpModes(), InitialiseBaseFlow(), SetUpBaseFields(), Nektar::IterativeElasticSystem::v_DoSolve(), Nektar::LinearElasticSystem::v_DoSolve(), Nektar::ImageWarpingSystem::v_InitObject(), Nektar::APE::v_InitObject(), Nektar::LinearElasticSystem::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), and v_InitObject().

bool Nektar::SolverUtils::EquationSystem::m_halfMode

protected

Flag to determine if half homogeneous mode is used.

Definition at line 506 of file EquationSystem.h.

Referenced by SessionSummary(), SetUpBaseFields(), and v_InitObject().

int Nektar::SolverUtils::EquationSystem::m_HomoDirec

protected

number of homogenous directions

Definition at line 558 of file EquationSystem.h.

Referenced by v_InitObject().

bool Nektar::SolverUtils::EquationSystem::m_homogen_dealiasing

protected

Flag to determine if dealiasing is used for homogeneous simulations.

Definition at line 515 of file EquationSystem.h.

Referenced by SetUpBaseFields(), Nektar::VCSWeakPressure::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::CoupledLinearNS::v_InitObject(), and v_InitObject().

enum HomogeneousType Nektar::SolverUtils::EquationSystem::m_HomogeneousType

protected

Definition at line 548 of file EquationSystem.h.

Referenced by Nektar::CompressibleFlowSystem::DoOdeRhs(), Nektar::IncNavierStokes::GetCFLEstimate(), Nektar::IncNavierStokes::GetElmtCFLVals(), SessionSummary(), SetUpBaseFields(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::VCSWeakPressure::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), and v_InitObject().

int Nektar::SolverUtils::EquationSystem::m_initialStep

protected

Number of the step where the simulation should begin.

Definition at line 484 of file EquationSystem.h.

Referenced by SetInitialStep(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), and Nektar::SolverUtils::UnsteadySystem::v_InitObject().

std::map<std::string, FieldUtils::Interpolator > Nektar::SolverUtils::EquationSystem::m_interpolators

protected

Map of interpolator objects.

Definition at line 464 of file EquationSystem.h.

Referenced by LoadPts().

NekDouble Nektar::SolverUtils::EquationSystem::m_lambda

protected

Lambda constant in real system if one required.

Definition at line 490 of file EquationSystem.h.

Referenced by SetLambda(), and Nektar::CoupledLinearNS::v_DoInitialise().

NekDouble Nektar::SolverUtils::EquationSystem::m_LhomX

protected

physical length in X direction (if homogeneous)

Definition at line 550 of file EquationSystem.h.

NekDouble Nektar::SolverUtils::EquationSystem::m_LhomY

protected

physical length in Y direction (if homogeneous)

Definition at line 551 of file EquationSystem.h.

Referenced by SessionSummary(), and v_InitObject().

NekDouble Nektar::SolverUtils::EquationSystem::m_LhomZ

protected

physical length in Z direction (if homogeneous)

Definition at line 552 of file EquationSystem.h.

Referenced by SessionSummary(), SetUpBaseFields(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::CoupledLinearNS::v_InitObject(), and v_InitObject().

std::map<std::string, std::pair<std::string, loadedFldField> > Nektar::SolverUtils::EquationSystem::m_loadedFldFields

protected

Definition at line 468 of file EquationSystem.h.

Referenced by EvaluateFunctionFld().

std::map<std::string, std::pair<std::string, LibUtilities::PtsFieldSharedPtr> > Nektar::SolverUtils::EquationSystem::m_loadedPtsFields

protected

pts fields we already read from disk: {funcFilename: (filename, ptsfield)}

Definition at line 466 of file EquationSystem.h.

Referenced by EvaluateFunctionPts().

bool Nektar::SolverUtils::EquationSystem::m_multipleModes

protected

Flag to determine if use multiple homogenenous modes are used.

Definition at line 508 of file EquationSystem.h.

Referenced by SessionSummary(), and v_InitObject().

int Nektar::SolverUtils::EquationSystem::m_nchk

protected

Number of checkpoints written so far.

Definition at line 494 of file EquationSystem.h.

Referenced by GetCheckpointNumber(), SetCheckpointNumber(), Nektar::SolverUtils::UnsteadySystem::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), v_InitObject(), v_SetInitialConditions(), and WriteFld().

int Nektar::SolverUtils::EquationSystem::m_npointsX

protected

number of points in X direction (if homogeneous)

Definition at line 554 of file EquationSystem.h.

int Nektar::SolverUtils::EquationSystem::m_npointsY

protected

number of points in Y direction (if homogeneous)

Definition at line 555 of file EquationSystem.h.

Referenced by SessionSummary(), and v_InitObject().

int Nektar::SolverUtils::EquationSystem::m_npointsZ

protected

number of points in Z direction (if homogeneous)

Definition at line 556 of file EquationSystem.h.

Referenced by SessionSummary(), SetUpBaseFields(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::CoupledLinearNS::v_InitObject(), and v_InitObject().

int Nektar::SolverUtils::EquationSystem::m_NumQuadPointsError

protected

Number of Quadrature points used to work out the error.

Definition at line 535 of file EquationSystem.h.

Referenced by ErrorExtraPoints(), Nektar::PulseWaveSystem::v_InitObject(), v_InitObject(), Nektar::PulseWaveSystem::v_L2Error(), v_L2Error(), Nektar::PulseWaveSystem::v_LinfError(), and v_LinfError().

enum MultiRegions::ProjectionType Nektar::SolverUtils::EquationSystem::m_projectionType

protected

Type of projection; e.g continuous or discontinuous.

Definition at line 522 of file EquationSystem.h.

LibUtilities::SessionReaderSharedPtr Nektar::SolverUtils::EquationSystem::m_session

protected

The session reader.

Definition at line 460 of file EquationSystem.h.

std::string Nektar::SolverUtils::EquationSystem::m_sessionName

protected

Name of the session.

Definition at line 480 of file EquationSystem.h.

Referenced by Checkpoint_BaseFlow(), Nektar::PulseWaveSystem::CheckPoint_Output(), Checkpoint_Output(), GetSessionName(), ResetSessionName(), SessionSummary(), v_InitObject(), Nektar::PulseWaveSystem::v_Output(), Nektar::CoupledLinearNS::v_Output(), and v_Output().

bool Nektar::SolverUtils::EquationSystem::m_singleMode

protected

Flag to determine if single homogeneous mode is used.

Definition at line 504 of file EquationSystem.h.

Referenced by SessionSummary(), SetUpBaseFields(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::CoupledLinearNS::v_InitObject(), v_InitObject(), and Nektar::CoupledLinearNS::v_Output().

int Nektar::SolverUtils::EquationSystem::m_spacedim

protected

Spatial dimension (>= expansion dim).

Definition at line 500 of file EquationSystem.h.

bool Nektar::SolverUtils::EquationSystem::m_specHP_dealiasing

protected

Flag to determine if dealisising is usde for the Spectral/hp element discretisation.

Definition at line 520 of file EquationSystem.h.

Referenced by Nektar::CompressibleFlowSystem::InitAdvection(), Nektar::VCSWeakPressure::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::NavierStokesCFE::v_InitObject(), Nektar::UnsteadyAdvection::v_InitObject(), and v_InitObject().

int Nektar::SolverUtils::EquationSystem::m_steps

protected

Number of steps to take.

Definition at line 496 of file EquationSystem.h.

Referenced by GetSteps(), SetSteps(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), Nektar::PulseWaveSystem::v_InitObject(), and v_InitObject().

Array<OneD, Array<OneD, Array<OneD,NekDouble> > > Nektar::SolverUtils::EquationSystem::m_tanbasis

protected

2 x m_spacedim x nq

Definition at line 528 of file EquationSystem.h.

Referenced by WeakDGDiffusion().

NekDouble Nektar::SolverUtils::EquationSystem::m_time

protected

Current time of simulation.

Definition at line 482 of file EquationSystem.h.

Referenced by Nektar::CompressibleFlowSystem::CalcSteadyState(), Nektar::APE::DoOdeRhs(), ErrorExtraPoints(), Nektar::IncNavierStokes::EvaluateAdvectionTerms(), GetFinalTime(), SetTime(), Nektar::IncNavierStokes::SetWomersleyBoundary(), Nektar::SolverUtils::UnsteadySystem::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::IterativeElasticSystem::v_DoSolve(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::APE::v_InitObject(), Nektar::SolverUtils::UnsteadySystem::v_InitObject(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), v_InitObject(), Nektar::PulseWaveSystem::v_L2Error(), v_L2Error(), Nektar::PulseWaveSystem::v_LinfError(), v_LinfError(), Nektar::APE::v_PreIntegrate(), Nektar::UnsteadyAdvectionDiffusion::v_PreIntegrate(), Nektar::IncNavierStokes::v_PreIntegrate(), v_SetInitialConditions(), WriteFld(), and Nektar::PulseWaveSystem::WriteVessels().

NekDouble Nektar::SolverUtils::EquationSystem::m_timestep

protected

Time step size.

Definition at line 488 of file EquationSystem.h.

Referenced by Nektar::APE::GetCFLEstimate(), Nektar::IncNavierStokes::GetElmtCFLVals(), GetTimeStep(), Nektar::UnsteadyAdvectionDiffusion::SubStepAdvance(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::SolverUtils::UnsteadySystem::v_DoSolve(), Nektar::PulseWaveSystem::v_DoSolve(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary(), Nektar::PulseWaveSystem::v_InitObject(), Nektar::IncNavierStokes::v_InitObject(), v_InitObject(), and Nektar::IncNavierStokes::v_PreIntegrate().

Array<OneD, Array<OneD, NekDouble> > Nektar::SolverUtils::EquationSystem::m_traceNormals

protected

Array holding trace normals for DG simulations in the forwards direction.

Definition at line 524 of file EquationSystem.h.

Referenced by Nektar::APE::GetNormals(), Nektar::ShallowWaterSystem::GetNormals(), Nektar::CompressibleFlowSystem::GetNormals(), Nektar::UnsteadyAdvectionDiffusion::GetNormalVel(), Nektar::UnsteadyInviscidBurger::GetNormalVelocity(), Nektar::UnsteadyAdvection::GetNormalVelocity(), Nektar::UnsteadyViscousBurgers::GetNormalVelocity(), Nektar::CompressibleFlowSystem::v_InitObject(), v_InitObject(), Nektar::EigenValuesAdvection::v_NumericalFlux(), Nektar::ImageWarpingSystem::v_NumericalFlux(), Nektar::CFLtester::v_NumericalFlux(), Nektar::IncNavierStokes::v_NumericalFlux(), Nektar::SolverUtils::UnsteadySystem::v_NumFluxforScalar(), Nektar::SolverUtils::UnsteadySystem::v_NumFluxforVector(), Nektar::APE::WallBC(), Nektar::NonlinearSWE::WallBoundary(), Nektar::LinearSWE::WallBoundary(), Nektar::NonlinearPeregrine::WallBoundary(), Nektar::NonlinearSWE::WallBoundary2D(), Nektar::LinearSWE::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundary2D(), Nektar::NonlinearPeregrine::WallBoundaryForcing(), and Nektar::SolverUtils::UnsteadySystem::WeakPenaltyforVector().

bool Nektar::SolverUtils::EquationSystem::m_useFFT

protected

Flag to determine if FFT is used for homogeneous transform.

Definition at line 510 of file EquationSystem.h.

Referenced by SessionSummary(), SetUpBaseFields(), Nektar::CoupledLinearNS::v_InitObject(), and v_InitObject().

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation