This class is the base class for Navier Stokes problems. More...

#include <IncNavierStokes.h>

Inheritance diagram for Nektar::IncNavierStokes:

Collaboration diagram for Nektar::IncNavierStokes:

Public Member Functions
virtual	~IncNavierStokes ()

virtual void	v_InitObject ()
	Init object for UnsteadySystem class. More...

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

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

int	GetNConvectiveFields (void)

Array< OneD, int > &	GetVelocity (void)

Array< OneD, NekDouble >	GetElmtCFLVals (void)

NekDouble	GetCFLEstimate (int &elmtid)

void	AddForcing (const SolverUtils::ForcingSharedPtr &pForce)

Public Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT	AdvectionSystem (const LibUtilities::SessionReaderSharedPtr &pSession)

virtual SOLVER_UTILS_EXPORT	~AdvectionSystem ()

AdvectionSharedPtr	GetAdvObject ()
	Returns the advection object held by this instance. More...

Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
virtual SOLVER_UTILS_EXPORT	~UnsteadySystem ()
	Destructor. More...

SOLVER_UTILS_EXPORT NekDouble	GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
	Calculate the larger time-step mantaining the problem stable. More...

Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
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 Member Functions
	IncNavierStokes (const LibUtilities::SessionReaderSharedPtr &pSession)
	Constructor. More...

EquationType	GetEquationType (void)

void	EvaluateAdvectionTerms (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)

void	WriteModalEnergy (void)

void	SetBoundaryConditions (NekDouble time)
	time dependent boundary conditions updating More...

void	SetRadiationBoundaryForcing (int fieldid)
	Set Radiation forcing term. More...

void	SetZeroNormalVelocity ()
	Set Normal Velocity Component to Zero. More...

void	SetWomersleyBoundary (const int fldid, const int bndid)
	Set Womersley Profile if specified. More...

void	SetUpWomersley (const int bndid, std::string womstr)
	Set Up Womersley details. More...

bool	CalcSteadyState (void)
	evaluate steady state More...

virtual MultiRegions::ExpListSharedPtr	v_GetPressure ()

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

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

virtual int	v_GetForceDimension ()=0

virtual bool	v_PreIntegrate (int step)

virtual bool	v_PostIntegrate (int step)

Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT	UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession)
	Initialises UnsteadySystem class members. More...

SOLVER_UTILS_EXPORT NekDouble	MaxTimeStepEstimator ()
	Get the maximum timestep estimator for cfl control. More...

virtual SOLVER_UTILS_EXPORT void	v_DoSolve ()
	Solves an unsteady problem. More...

virtual SOLVER_UTILS_EXPORT void	v_DoInitialise ()
	Sets up initial conditions. More...

virtual SOLVER_UTILS_EXPORT void	v_GenerateSummary (SummaryList &s)
	Print a summary of time stepping parameters. More...

virtual SOLVER_UTILS_EXPORT void	v_AppendOutput1D (Array< OneD, Array< OneD, NekDouble > > &solution1D)
	Print the solution at each solution point in a txt file. More...

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)

virtual SOLVER_UTILS_EXPORT NekDouble	v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
	Return the timestep to be used for the next step in the time-marching loop. More...

virtual SOLVER_UTILS_EXPORT bool	v_SteadyStateCheck (int step)

virtual SOLVER_UTILS_EXPORT bool	v_RequireFwdTrans ()

SOLVER_UTILS_EXPORT void	CheckForRestartTime (NekDouble &time, int &nchk)

SOLVER_UTILS_EXPORT void	SVVVarDiffCoeff (const Array< OneD, Array< OneD, NekDouble > > vel, StdRegions::VarCoeffMap &varCoeffMap)
	Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h time velocity. More...

Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
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 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_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 void	v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)

Protected Attributes
ExtrapolateSharedPtr	m_extrapolation

std::ofstream	m_mdlFile
	modal energy file More...

bool	m_SmoothAdvection
	bool to identify if advection term smoothing is requested More...

std::vector < SolverUtils::ForcingSharedPtr >	m_forcing
	Forcing terms. More...

int	m_nConvectiveFields
	Number of fields to be convected;. More...

Array< OneD, int >	m_velocity
	int which identifies which components of m_fields contains the velocity (u,v,w); More...

MultiRegions::ExpListSharedPtr	m_pressure
	Pointer to field holding pressure field. More...

NekDouble	m_kinvis
	Kinematic viscosity. More...

int	m_energysteps
	dump energy to file at steps time More...

int	m_cflsteps
	dump cfl estimate More...

int	m_steadyStateSteps
	Check for steady state at step interval. More...

NekDouble	m_steadyStateTol
	Tolerance to which steady state should be evaluated at. More...

EquationType	m_equationType
	equation type; More...

Array< OneD, Array< OneD, int > >	m_fieldsBCToElmtID
	Mapping from BCs to Elmt IDs. More...

Array< OneD, Array< OneD, int > >	m_fieldsBCToTraceID
	Mapping from BCs to Elmt Edge IDs. More...

Array< OneD, Array< OneD, NekDouble > >	m_fieldsRadiationFactor
	RHS Factor for Radiation Condition. More...

int	m_intSteps
	Number of time integration steps AND Order of extrapolation for pressure boundary conditions. More...

std::map< int, WomersleyParamsSharedPtr >	m_womersleyParams
	Womersley parameters if required. More...

Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem
SolverUtils::AdvectionSharedPtr	m_advObject
	Advection term. More...

Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
int	m_infosteps
	Number of time steps between outputting status information. More...

int	m_nanSteps

LibUtilities::TimeIntegrationWrapperSharedPtr	m_intScheme
	Wrapper to the time integration scheme. More...

LibUtilities::TimeIntegrationSchemeOperators	m_ode
	The time integration scheme operators to use. More...

LibUtilities::TimeIntegrationSolutionSharedPtr	m_intSoln

NekDouble	m_epsilon

bool	m_explicitDiffusion
	Indicates if explicit or implicit treatment of diffusion is used. More...

bool	m_explicitAdvection
	Indicates if explicit or implicit treatment of advection is used. More...

bool	m_explicitReaction
	Indicates if explicit or implicit treatment of reaction is used. More...

bool	m_homoInitialFwd
	Flag to determine if simulation should start in homogeneous forward transformed state. More...

std::vector< int >	m_intVariables

std::vector< FilterSharedPtr >	m_filters

Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
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...

Additional Inherited Members
Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
NekDouble	m_cflSafetyFactor
	CFL safety factor (comprise between 0 to 1). More...

Protected Types inherited from Nektar::SolverUtils::EquationSystem
enum	HomogeneousType { eHomogeneous1D, eHomogeneous2D, eHomogeneous3D, eNotHomogeneous }
	Parameter for homogeneous expansions. More...

Detailed Description

This class is the base class for Navier Stokes problems.

Definition at line 130 of file IncNavierStokes.h.

Constructor & Destructor Documentation

Nektar::IncNavierStokes::~IncNavierStokes ( void )

virtual

Destructor

Definition at line 299 of file IncNavierStokes.cpp.

300 {

301 }

Nektar::IncNavierStokes::IncNavierStokes ( const LibUtilities::SessionReaderSharedPtr & pSession )

protected

Constructor.

Constructor. Creates ...

Parameters

param

Definition at line 70 of file IncNavierStokes.cpp.

                                                                                       :
         UnsteadySystem(pSession),
         AdvectionSystem(pSession),
         m_SmoothAdvection(false),
         m_steadyStateSteps(0)
     {
     }

Member Function Documentation

void Nektar::IncNavierStokes::AddForcing ( const SolverUtils::ForcingSharedPtr & pForce )

Add an additional forcing term programmatically.

Definition at line 806 of file IncNavierStokes.cpp.

References m_forcing.

Referenced by Nektar::VortexWaveInteraction::ExecuteRoll().

     {
         m_forcing.push_back(pForce);
     }

bool Nektar::IncNavierStokes::CalcSteadyState ( void )

protected

evaluate steady state

Decide if at a steady state if the discrerte L2 sum of the coefficients is the same as the previous step to within the tolerance m_steadyStateTol;

Definition at line 817 of file IncNavierStokes.cpp.

References Vmath::Dot(), Nektar::SolverUtils::EquationSystem::m_fields, and m_steadyStateTol.

Referenced by v_PostIntegrate().

     {
         static NekDouble previousL2 = 0.0;
         bool returnval = false;
 
         NekDouble L2 = 0.0;
 
         // calculate L2 discrete summation
         int ncoeffs = m_fields[0]->GetNcoeffs();
 
         for(int i = 0; i < m_fields.num_elements(); ++i)
         {
             L2 += Vmath::Dot(ncoeffs,m_fields[i]->GetCoeffs(),1,m_fields[i]->GetCoeffs(),1);
         }
 
         if(fabs(L2-previousL2) < ncoeffs*m_steadyStateTol)
         {
             returnval = true;
         }
 
         previousL2 = L2;
 
         return returnval;
     }

void Nektar::IncNavierStokes::EvaluateAdvectionTerms	(	const Array< OneD, const Array< OneD, NekDouble > > &	inarray,
		Array< OneD, Array< OneD, NekDouble > > &	outarray
	)

protected

Evaluation -N(V) for all fields except pressure using m_velocity

Definition at line 368 of file IncNavierStokes.cpp.

References Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::EquationSystem::m_fields, m_nConvectiveFields, Nektar::SolverUtils::EquationSystem::m_time, and m_velocity.

Referenced by Nektar::CoupledLinearNS::EvaluateAdvection(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), and Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs().

     {
         int i;
         int VelDim     = m_velocity.num_elements();
         Array<OneD, Array<OneD, NekDouble> > velocity(VelDim);
 
         for(i = 0; i < VelDim; ++i)
         {
             velocity[i] = inarray[m_velocity[i]];
         }
 
         m_advObject->Advect(m_nConvectiveFields, m_fields,
                             velocity, inarray, outarray, m_time);
     }

NekDouble Nektar::IncNavierStokes::GetCFLEstimate ( int & elmtid )

Definition at line 892 of file IncNavierStokes.cpp.

References Nektar::SolverUtils::EquationSystem::eHomogeneous1D, GetElmtCFLVals(), Vmath::Imax(), Nektar::SolverUtils::EquationSystem::m_comm, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, and Nektar::LibUtilities::ReduceMax.

Referenced by v_PostIntegrate().

     {
         int n_element = m_fields[0]->GetExpSize();
 
         Array<OneD, NekDouble> cfl = GetElmtCFLVals();
 
         elmtid = Vmath::Imax(n_element,cfl,1);
         NekDouble CFL,CFL_loc;
 
         CFL = CFL_loc = cfl[elmtid];
         m_comm->AllReduce(CFL,LibUtilities::ReduceMax);
 
         // unshuffle elmt id if data is not stored in consecutive order.
         elmtid = m_fields[0]->GetExp(elmtid)->GetGeom()->GetGlobalID();
         if(CFL != CFL_loc)
         {
             elmtid = -1;
         }
 
         m_comm->AllReduce(elmtid,LibUtilities::ReduceMax);
 
         // express element id with respect to plane
         if(m_HomogeneousType == eHomogeneous1D)
         {
             elmtid = elmtid%m_fields[0]->GetPlane(0)->GetExpSize();
         }
         return CFL;
     }

Array< OneD, NekDouble > Nektar::IncNavierStokes::GetElmtCFLVals ( void )

Definition at line 845 of file IncNavierStokes.cpp.

References Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::SolverUtils::EquationSystem::GetNumExpModesPerExp(), m_extrapolation, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, Nektar::SolverUtils::EquationSystem::m_timestep, and m_velocity.

Referenced by GetCFLEstimate().

     {
         int n_vel     = m_velocity.num_elements();
         int n_element = m_fields[0]->GetExpSize();
 
         const Array<OneD, int> ExpOrder = GetNumExpModesPerExp();
         Array<OneD, int> ExpOrderList (n_element, ExpOrder);
 
         const NekDouble cLambda = 0.2; // Spencer book pag. 317
 
         Array<OneD, NekDouble> cfl        (n_element, 0.0);
         Array<OneD, NekDouble> stdVelocity(n_element, 0.0);
         Array<OneD, Array<OneD, NekDouble> > velfields;
 
         if(m_HomogeneousType == eHomogeneous1D) // just do check on 2D info
         {
             velfields = Array<OneD, Array<OneD, NekDouble> >(2);
 
             for(int i = 0; i < 2; ++i)
             {
                 velfields[i] = m_fields[m_velocity[i]]->UpdatePhys();
             }
         }
         else
         {
             velfields = Array<OneD, Array<OneD, NekDouble> >(n_vel);
 
             for(int i = 0; i < n_vel; ++i)
             {
                 velfields[i] = m_fields[m_velocity[i]]->UpdatePhys();
             }
         }
 
         stdVelocity = m_extrapolation->GetMaxStdVelocity(velfields);
 
         for(int el = 0; el < n_element; ++el)
         {
             cfl[el] =  m_timestep*(stdVelocity[el] * cLambda *
                                    (ExpOrder[el]-1) * (ExpOrder[el]-1));
         }
 
         return cfl;
     }

EquationType Nektar::IncNavierStokes::GetEquationType ( void )

inlineprotected

Definition at line 217 of file IncNavierStokes.h.

References m_equationType.

         {
             return m_equationType;
         }

int Nektar::IncNavierStokes::GetNConvectiveFields ( void )

inline

Definition at line 148 of file IncNavierStokes.h.

References m_nConvectiveFields.

         {
             return m_nConvectiveFields;  
         }

Array<OneD, int>& Nektar::IncNavierStokes::GetVelocity ( void )

inline

Definition at line 153 of file IncNavierStokes.h.

References m_velocity.

         {
             return  m_velocity; 
         }

void Nektar::IncNavierStokes::SetBoundaryConditions ( NekDouble time )

protected

time dependent boundary conditions updating

Time dependent boundary conditions updating

Definition at line 387 of file IncNavierStokes.cpp.

References Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_session, SetRadiationBoundaryForcing(), SetWomersleyBoundary(), and SetZeroNormalVelocity().

Referenced by Nektar::VelocityCorrectionScheme::v_DoInitialise(), and v_PreIntegrate().

     {
         int i, n;
         std::string varName;
         int nvariables = m_fields.num_elements();
 
         for (i = 0; i < nvariables; ++i)
         {
             for(n = 0; n < m_fields[i]->GetBndConditions().num_elements(); ++n)
             {
                 if(m_fields[i]->GetBndConditions()[n]->IsTimeDependent())
                 {
                     varName = m_session->GetVariable(i);
                     m_fields[i]->EvaluateBoundaryConditions(time, varName);
                 }
                 else if(boost::istarts_with(m_fields[i]->GetBndConditions()[n]->GetUserDefined(),"Womersley"))
                 {
                     SetWomersleyBoundary(i,n);
                 }
             }
 
             // Set Radiation conditions if required
             SetRadiationBoundaryForcing(i);
         }
 
         SetZeroNormalVelocity();
     }

void Nektar::IncNavierStokes::SetRadiationBoundaryForcing ( int fieldid )

protected

Set Radiation forcing term.

Probably should be pushed back into ContField?

Definition at line 418 of file IncNavierStokes.cpp.

References Nektar::SpatialDomains::eRobin, Nektar::SolverUtils::EquationSystem::GetPhys_Offset(), Nektar::SolverUtils::EquationSystem::m_fields, m_fieldsBCToElmtID, m_fieldsBCToTraceID, m_fieldsRadiationFactor, m_velocity, and Vmath::Vmul().

Referenced by SetBoundaryConditions().

     {
         int  i,n;
 
         Array<OneD, const SpatialDomains::BoundaryConditionShPtr > BndConds;
         Array<OneD, MultiRegions::ExpListSharedPtr>                BndExp;
 
         BndConds = m_fields[fieldid]->GetBndConditions();
         BndExp   = m_fields[fieldid]->GetBndCondExpansions();
 
         StdRegions::StdExpansionSharedPtr elmt;
         StdRegions::StdExpansionSharedPtr Bc;
 
         int cnt;
         int elmtid,nq,offset, boundary;
         Array<OneD, NekDouble> Bvals, U;
         int cnt1 = 0;
 
         for(cnt = n = 0; n < BndConds.num_elements(); ++n)
         {
             std::string type = BndConds[n]->GetUserDefined();
 
             if((BndConds[n]->GetBoundaryConditionType() == SpatialDomains::eRobin)&&(boost::iequals(type,"Radiation")))
             {
                 for(i = 0; i < BndExp[n]->GetExpSize(); ++i,cnt++)
                 {
                     elmtid = m_fieldsBCToElmtID[m_velocity[fieldid]][cnt];
                     elmt   = m_fields[fieldid]->GetExp(elmtid);
                     offset = m_fields[fieldid]->GetPhys_Offset(elmtid);
 
                     U = m_fields[fieldid]->UpdatePhys() + offset;
                     Bc = BndExp[n]->GetExp(i);
 
                     boundary = m_fieldsBCToTraceID[fieldid][cnt];
 
                     // Get edge values and put into ubc
                     nq = Bc->GetTotPoints();
                     Array<OneD, NekDouble> ubc(nq);
                     elmt->GetTracePhysVals(boundary,Bc,U,ubc);
 
                     Vmath::Vmul(nq,&m_fieldsRadiationFactor[fieldid][cnt1 +
                                 BndExp[n]->GetPhys_Offset(i)],1,&ubc[0],1,&ubc[0],1);
 
                     Bvals = BndExp[n]->UpdateCoeffs()+BndExp[n]->GetCoeff_Offset(i);
 
                     Bc->IProductWRTBase(ubc,Bvals);
                 }
                 cnt1 += BndExp[n]->GetTotPoints();
             }
             else
             {
                 cnt += BndExp[n]->GetExpSize();
             }
         }
     }

void Nektar::IncNavierStokes::SetUpWomersley	(	const int	bndid,
		std::string	womstr
	)

protected

Set Up Womersley details.

Error value returned by TinyXML.

Definition at line 659 of file IncNavierStokes.cpp.

References ASSERTL0, ASSERTL1, Nektar::ParseUtils::GenerateUnOrderedVector(), m_womersleyParams, Nektar::LibUtilities::rad(), and CellMLToNektar.pycml::stream.

Referenced by v_InitObject().

     {
         std::string::size_type indxBeg = womStr.find_first_of(':') + 1;
         string filename = womStr.substr(indxBeg,string::npos);
 
         std::complex<NekDouble> coef;
 
 #if 1
         TiXmlDocument doc(filename);
 
         bool loadOkay = doc.LoadFile();
         ASSERTL0(loadOkay,(std::string("Failed to load file: ") +
                            filename).c_str());
 
         TiXmlHandle docHandle(&doc);
 
         int err;    /// Error value returned by TinyXML.
 
         TiXmlElement *nektar = doc.FirstChildElement("NEKTAR");
         ASSERTL0(nektar, "Unable to find NEKTAR tag in file.");
 
         TiXmlElement *wombc = nektar->FirstChildElement("WOMERSLEYBC");
         ASSERTL0(wombc, "Unable to find WOMERSLEYBC tag in file.");
 
         // read womersley parameters
         TiXmlElement *womparam = wombc->FirstChildElement("WOMPARAMS");
         ASSERTL0(womparam, "Unable to find WOMPARAMS tag in file.");
 
         // Input coefficients
         TiXmlElement *params = womparam->FirstChildElement("W");
         map<std::string,std::string> Wparams;
 
         // read parameter list
         while (params)
         {
 
             std::string propstr;
             propstr = params->Attribute("PROPERTY");
 
             ASSERTL0(!propstr.empty(),"Failed to read PROPERTY value Womersley BC Parameter");
 
 
             std::string valstr;
             valstr = params->Attribute("VALUE");
 
             ASSERTL0(!valstr.empty(),"Failed to read VALUE value Womersley BC Parameter");
 
             std::transform(propstr.begin(),propstr.end(),propstr.begin(),
                            ::toupper);
             Wparams[propstr] = valstr;
 
             params = params->NextSiblingElement("W");
         }
 
         // Read parameters
 
         ASSERTL0(Wparams.count("RADIUS") == 1,
           "Failed to find Radius parameter in Womersley boundary conditions");
         std::vector<NekDouble> rad;
         ParseUtils::GenerateUnOrderedVector(
                                          Wparams["RADIUS"].c_str(),rad);
         m_womersleyParams[bndid]->m_radius = rad[0];
 
         ASSERTL0(Wparams.count("PERIOD") == 1,
           "Failed to find period parameter in Womersley boundary conditions");
         std::vector<NekDouble> period;
         ParseUtils::GenerateUnOrderedVector(
                                          Wparams["PERIOD"].c_str(),period);
         m_womersleyParams[bndid]->m_period = period[0];
 
 
         ASSERTL0(Wparams.count("AXISNORMAL") == 1,
           "Failed to find axisnormal parameter in Womersley boundary conditions");
         std::vector<NekDouble> anorm;
         ParseUtils::GenerateUnOrderedVector(
                                          Wparams["AXISNORMAL"].c_str(),anorm);
         m_womersleyParams[bndid]->m_axisnormal[0] = anorm[0];
         m_womersleyParams[bndid]->m_axisnormal[1] = anorm[1];
         m_womersleyParams[bndid]->m_axisnormal[2] = anorm[2];
 
 
         ASSERTL0(Wparams.count("AXISPOINT") == 1,
           "Failed to find axispoint parameter in Womersley boundary conditions");
         std::vector<NekDouble> apt;
         ParseUtils::GenerateUnOrderedVector(
                                          Wparams["AXISPOINT"].c_str(),apt);
         m_womersleyParams[bndid]->m_axispoint[0] = apt[0];
         m_womersleyParams[bndid]->m_axispoint[1] = apt[1];
         m_womersleyParams[bndid]->m_axispoint[2] = apt[2];
 
         // Read Temporal Foruier Coefficients.
 
         // Find the FourierCoeff tag
         TiXmlElement *coeff = wombc->FirstChildElement("FOURIERCOEFFS");
 
         // Input coefficients
         TiXmlElement *fval = coeff->FirstChildElement("F");
 
         int indx;
         int nextFourierCoeff = -1;
 
         while (fval)
         {
             nextFourierCoeff++;
 
             TiXmlAttribute *fvalAttr = fval->FirstAttribute();
             std::string attrName(fvalAttr->Name());
 
             ASSERTL0(attrName == "ID", (std::string("Unknown attribute name: ") + attrName).c_str());
 
             err = fvalAttr->QueryIntValue(&indx);
             ASSERTL0(err == TIXML_SUCCESS, "Unable to read attribute ID.");
 
             std::string coeffStr = fval->FirstChild()->ToText()->ValueStr();
             vector<NekDouble> coeffvals;
             bool parseGood = ParseUtils::GenerateUnOrderedVector(coeffStr.c_str(),
                                                                coeffvals);
             ASSERTL0(parseGood,(std::string("Problem reading value of fourier coefficient, ID=") + boost::lexical_cast<string>(indx)).c_str());
             ASSERTL1(coeffvals.size() == 2,(std::string("Have not read two entries of Fourier coefficicent from ID="+ boost::lexical_cast<string>(indx)).c_str()));
             m_womersleyParams[bndid]->m_wom_vel_r.push_back(coeffvals[0]);
             m_womersleyParams[bndid]->m_wom_vel_i.push_back(coeffvals[1]);
 
             fval = fval->NextSiblingElement("F");
         }
 
 #else
         std::ifstream file(filename);
         std::string line;
 
         ASSERTL1(file.is_open(),(std::string("Missing file ") + filename).c_str());
         int count = 0;
         while(std::getline(file,line))
         {
             std::stringstream stream(line);
             while(stream>>coef)
             {
                 m_womersleyParams[bndid]->m_wom_vel_r.push_back(coef.real());
                 m_womersleyParams[bndid]->m_wom_vel_i.push_back(coef.imag());
                 count++;
             }
         }
 #endif
     }

void Nektar::IncNavierStokes::SetWomersleyBoundary	(	const int	fldid,
		const int	bndid
	)

protected

Set Womersley Profile if specified.

Womersley boundary condition defintion

Definition at line 562 of file IncNavierStokes.cpp.

References ASSERTL1, Polylib::ImagBesselComp(), Nektar::SolverUtils::EquationSystem::m_fields, m_fieldsBCToElmtID, m_fieldsBCToTraceID, m_kinvis, Nektar::SolverUtils::EquationSystem::m_time, m_womersleyParams, and Vmath::Smul().

Referenced by SetBoundaryConditions().

     {
         ASSERTL1(m_womersleyParams.count(bndid) == 1, "Womersley parameters for this boundary have not been set up");
 
         WomersleyParamsSharedPtr WomParam = m_womersleyParams[bndid];
         std::complex<NekDouble> za, zar, zJ0, zJ0r, zq, zvel, zJ0rJ0;
         int  i,j,k;
 
         int M = WomParam->m_wom_vel_r.size();
 
         NekDouble R = WomParam->m_radius;
         NekDouble T = WomParam->m_period;
 
         Array<OneD, NekDouble > normals = WomParam->m_axisnormal;
         Array<OneD, NekDouble > x0      = WomParam->m_axispoint;
 
         // Womersley Number
         NekDouble alpha = R*sqrt(2*M_PI/T/m_kinvis);
         NekDouble r,kt;
 
         std::complex<NekDouble> z1 (1.0,0.0);
         std::complex<NekDouble> zi (0.0,1.0);
         std::complex<NekDouble> comp_conj (-1.0,1.0); //complex conjugate
 
         Array<OneD, MultiRegions::ExpListSharedPtr>  BndExp;
 
         BndExp   = m_fields[fldid]->GetBndCondExpansions();
 
         StdRegions::StdExpansionSharedPtr elmt;
         StdRegions::StdExpansionSharedPtr bc;
         int cnt=0;
         int elmtid,offset, boundary,nfq;
 
         Array<OneD, NekDouble> Bvals,w;
 
         //Loop over all expansions
         for(i = 0; i < BndExp[bndid]->GetExpSize(); ++i,cnt++)
         {
             // Get element id and offset
             elmtid = m_fieldsBCToElmtID[fldid][cnt];
             elmt   = m_fields[fldid]->GetExp(elmtid);
             offset = m_fields[fldid]->GetPhys_Offset(elmtid);
 
             // Get Boundary and trace expansion
             bc = BndExp[bndid]->GetExp(i);
             boundary = m_fieldsBCToTraceID[fldid][cnt];
 
             nfq=bc->GetTotPoints();
             w = m_fields[fldid]->UpdatePhys() + offset;
 
             Array<OneD, NekDouble> x(nfq,0.0);
             Array<OneD, NekDouble> y(nfq,0.0);
             Array<OneD, NekDouble> z(nfq,0.0);
             Array<OneD, NekDouble> wbc(nfq,0.0);
             bc->GetCoords(x,y,z);
 
             // Add edge values (trace) into the wbc
             elmt->GetTracePhysVals(boundary,bc,w,wbc);
 
             //Compute womersley solution
             for (j=0;j<nfq;j++)
             {
                 //NOTE: only need to calculate these two once, could
                 //be stored or precomputed?
                 r = sqrt((x[j]-x0[0])*(x[j]-x0[0]) +
                          (y[j]-x0[1])*(y[j]-x0[1]) +
                          (z[j]-x0[2])*(z[j]-x0[2]))/R;
 
                 wbc[j] = WomParam->m_wom_vel_r[0]*(1. - r*r); // Compute Poiseulle Flow
 
                 for (k=1; k<M; k++)
                 {
                     kt = 2.0 * M_PI * k * m_time / T;
                     za = alpha * sqrt((NekDouble)k/2.0) * comp_conj;
                     zar = r * za;
                     zJ0  = Polylib::ImagBesselComp(0,za);
                     zJ0r = Polylib::ImagBesselComp(0,zar);
                     zJ0rJ0 = zJ0r / zJ0;
                     zq = std::exp(zi * kt) * std::complex<NekDouble>(
                                                    WomParam->m_wom_vel_r[k],
                                                    WomParam->m_wom_vel_i[k]);
                     zvel = zq * (z1 - zJ0rJ0);
                     wbc[j] = wbc[j] + zvel.real();
                 }
             }
 
             // Multiply w by normal to get u,v,w component of velocity
             Vmath::Smul(nfq,normals[fldid],wbc,1,wbc,1);
 
             Bvals = BndExp[bndid]->UpdateCoeffs()+
                     BndExp[bndid]->GetCoeff_Offset(i);
             // Push back to Coeff space
             bc->FwdTrans(wbc,Bvals);
         }
     }

void Nektar::IncNavierStokes::SetZeroNormalVelocity ( )

protected

Set Normal Velocity Component to Zero.

Definition at line 475 of file IncNavierStokes.cpp.

References Nektar::SpatialDomains::eDirichlet, Nektar::SolverUtils::EquationSystem::m_fields, m_fieldsBCToElmtID, m_fieldsBCToTraceID, Nektar::SolverUtils::EquationSystem::m_spacedim, m_velocity, Vmath::Neg(), and Vmath::Vvtvp().

Referenced by SetBoundaryConditions().

     {
         // use static trip since cannot use UserDefinedTag for zero
         // velocity and have time dependent conditions
         static bool Setup  = false;
 
         if(Setup == true)
         {
             return;
         }
         Setup = true;
 
         int  i,n;
 
         Array<OneD, Array<OneD, const SpatialDomains::BoundaryConditionShPtr > >
             BndConds(m_spacedim);
         Array<OneD, Array<OneD, MultiRegions::ExpListSharedPtr> >
             BndExp(m_spacedim);
 
 
         for(i = 0; i < m_spacedim; ++i)
         {
             BndConds[i] = m_fields[m_velocity[i]]->GetBndConditions();
             BndExp[i]   = m_fields[m_velocity[i]]->GetBndCondExpansions();
         }
 
         StdRegions::StdExpansionSharedPtr elmt,Bc;
 
         int cnt;
         int elmtid,nq, boundary;
 
         Array<OneD, Array<OneD, NekDouble> > normals;
         Array<OneD, NekDouble> Bphys,Bcoeffs;
 
         int fldid = m_velocity[0];
 
         for(cnt = n = 0; n < BndConds[0].num_elements(); ++n)
         {
             if((BndConds[0][n]->GetBoundaryConditionType() == SpatialDomains::eDirichlet)&& (boost::iequals(BndConds[0][n]->GetUserDefined(),"ZeroNormalComponent")))
             {
                 for(i = 0; i < BndExp[0][n]->GetExpSize(); ++i,cnt++)
                 {
                     elmtid   = m_fieldsBCToElmtID[fldid][cnt];
                     elmt     = m_fields[0]->GetExp(elmtid);
                     boundary = m_fieldsBCToTraceID[fldid][cnt];
 
                     normals = elmt->GetSurfaceNormal(boundary);
 
                     nq = BndExp[0][n]->GetExp(i)->GetTotPoints();
                     Array<OneD, NekDouble> normvel(nq,0.0);
 
                     for(int k = 0; k < m_spacedim; ++k)
                     {
                         Bphys  = BndExp[k][n]->UpdatePhys()+
                             BndExp[k][n]->GetPhys_Offset(i);
                         Bc  = BndExp[k][n]->GetExp(i);
                         Vmath::Vvtvp(nq,normals[k],1,Bphys,1,normvel,1,
                                      normvel,1);
                     }
 
                     // negate normvel for next step
                     Vmath::Neg(nq,normvel,1);
 
                     for(int k = 0; k < m_spacedim; ++k)
                     {
                         Bphys  = BndExp[k][n]->UpdatePhys()+
                             BndExp[k][n]->GetPhys_Offset(i);
                         Bcoeffs = BndExp[k][n]->UpdateCoeffs()+
                             BndExp[k][n]->GetCoeff_Offset(i);
                         Bc  = BndExp[k][n]->GetExp(i);
                         Vmath::Vvtvp(nq,normvel,1,normals[k],1,Bphys,1,
                                      Bphys,1);
                         Bc->FwdTrans_BndConstrained(Bphys,Bcoeffs);
                     }
                 }
             }
             else
             {
                 cnt += BndExp[0][n]->GetExpSize();
             }
         }
     }

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

virtual

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 307 of file IncNavierStokes.cpp.

References ASSERTL1, Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::m_fields, m_velocity, and Vmath::Vmul().

     {
         ASSERTL1(flux.num_elements() == m_velocity.num_elements(),"Dimension of flux array and velocity array do not match");
 
         for(int j = 0; j < flux.num_elements(); ++j)
         {
             Vmath::Vmul(GetNpoints(), physfield[i], 1, m_fields[m_velocity[j]]->GetPhys(), 1, flux[j], 1);
         }
     }

virtual int Nektar::IncNavierStokes::v_GetForceDimension ( )

protectedpure virtual

Implemented in Nektar::CoupledLinearNS, and Nektar::VelocityCorrectionScheme.

Referenced by v_InitObject().

virtual MultiRegions::ExpListSharedPtr Nektar::IncNavierStokes::v_GetPressure ( void )

inlineprotectedvirtual

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 248 of file IncNavierStokes.h.

References m_pressure.

         {
             return m_pressure;
         }

void Nektar::IncNavierStokes::v_InitObject ( )

virtual

Init object for UnsteadySystem class.

Initialization object for UnsteadySystem class.

Reimplemented from Nektar::SolverUtils::AdvectionSystem.

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

Definition at line 78 of file IncNavierStokes.cpp.

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

     {
         AdvectionSystem::v_InitObject();
 
         int i,j;
         int numfields = m_fields.num_elements();
         std::string velids[] = {"u","v","w"};
 
         // Set up Velocity field to point to the first m_expdim of m_fields;
         m_velocity = Array<OneD,int>(m_spacedim);
 
         for(i = 0; i < m_spacedim; ++i)
         {
             for(j = 0; j < numfields; ++j)
             {
                 std::string var = m_boundaryConditions->GetVariable(j);
                 if(boost::iequals(velids[i], var))
                 {
                     m_velocity[i] = j;
                     break;
                 }
 
                 ASSERTL0(j != numfields, "Failed to find field: " + var);
             }
         }
 
         // Set up equation type enum using kEquationTypeStr
         for(i = 0; i < (int) eEquationTypeSize; ++i)
         {
             bool match;
             m_session->MatchSolverInfo("EQTYPE",kEquationTypeStr[i],match,false);
             if(match)
             {
                 m_equationType = (EquationType)i;
                 break;
             }
         }
         ASSERTL0(i != eEquationTypeSize,"EQTYPE not found in SOLVERINFO section");
 
         // This probably should to into specific implementations
         // Equation specific Setups
         switch(m_equationType)
         {
         case eSteadyStokes:
         case eSteadyOseen:
         case eSteadyNavierStokes:
         case eSteadyLinearisedNS:
             break;
         case eUnsteadyNavierStokes:
         case eUnsteadyStokes:
             {
                 m_session->LoadParameter("IO_InfoSteps", m_infosteps, 0);
                 m_session->LoadParameter("IO_CFLSteps", m_cflsteps, 0);
                 m_session->LoadParameter("SteadyStateSteps", m_steadyStateSteps, 0);
                 m_session->LoadParameter("SteadyStateTol", m_steadyStateTol, 1e-6);
             }
             break;
         case eNoEquationType:
         default:
             ASSERTL0(false,"Unknown or undefined equation type");
         }
 
         m_session->LoadParameter("Kinvis", m_kinvis);
 
         // Default advection type per solver
         std::string vConvectiveType;
         switch(m_equationType)
         {
         case eUnsteadyStokes:
         case eSteadyLinearisedNS:
             vConvectiveType = "NoAdvection";
             break;
         case eUnsteadyNavierStokes:
         case eSteadyNavierStokes:
             vConvectiveType = "Convective";
             break;
         case eUnsteadyLinearisedNS:
             vConvectiveType = "Linearised";
             break;
         default:
             break;
         }
 
         // Check if advection type overridden
         if (m_session->DefinesTag("AdvectiveType") && m_equationType != eUnsteadyStokes &&
             m_equationType != eSteadyLinearisedNS)
         {
             vConvectiveType = m_session->GetTag("AdvectiveType");
         }
 
         // Initialise advection
         m_advObject = SolverUtils::GetAdvectionFactory().CreateInstance(vConvectiveType, vConvectiveType);
         m_advObject->InitObject( m_session, m_fields);
 
         // Forcing terms
         m_forcing = SolverUtils::Forcing::Load(m_session, m_fields,
                                                v_GetForceDimension());
 
         // check to see if any Robin boundary conditions and if so set
         // up m_field to boundary condition maps;
         m_fieldsBCToElmtID  = Array<OneD, Array<OneD, int> >(numfields);
         m_fieldsBCToTraceID = Array<OneD, Array<OneD, int> >(numfields);
         m_fieldsRadiationFactor  = Array<OneD, Array<OneD, NekDouble> > (numfields);
 
         for (i = 0; i < m_fields.num_elements(); ++i)
         {
             bool Set = false;
 
             Array<OneD, const SpatialDomains::BoundaryConditionShPtr > BndConds;
             Array<OneD, MultiRegions::ExpListSharedPtr>  BndExp;
             int radpts = 0;
 
             BndConds = m_fields[i]->GetBndConditions();
             BndExp   = m_fields[i]->GetBndCondExpansions();
             for(int n = 0; n < BndConds.num_elements(); ++n)
             {
                 if(boost::iequals(BndConds[n]->GetUserDefined(),"Radiation"))
                 {
                     ASSERTL0(BndConds[n]->GetBoundaryConditionType() == SpatialDomains::eRobin,
                              "Radiation boundary condition must be of type Robin <R>");
 
                     if(Set == false)
                     {
                         m_fields[i]->GetBoundaryToElmtMap(m_fieldsBCToElmtID[i],m_fieldsBCToTraceID[i]);
                         Set = true;
                     }
                     radpts += BndExp[n]->GetTotPoints();
                 }
                 if(boost::iequals(BndConds[n]->GetUserDefined(),"ZeroNormalComponent"))
                 {
                     ASSERTL0(BndConds[n]->GetBoundaryConditionType() == SpatialDomains::eDirichlet,
                              "Zero Normal Component boundary condition option must be of type Dirichlet <D>");
 
                     if(Set == false)
                     {
                         m_fields[i]->GetBoundaryToElmtMap(m_fieldsBCToElmtID[i],m_fieldsBCToTraceID[i]);
                         Set = true;
                     }
                 }
             }
 
             m_fieldsRadiationFactor[i] = Array<OneD, NekDouble>(radpts);
 
             radpts = 0; // reset to use as a counter
 
             for(int n = 0; n < BndConds.num_elements(); ++n)
             {
                 if(boost::iequals(BndConds[n]->GetUserDefined(),"Radiation"))
                 {
 
                     int npoints    = BndExp[n]->GetNpoints();
                     Array<OneD, NekDouble> x0(npoints,0.0);
                     Array<OneD, NekDouble> x1(npoints,0.0);
                     Array<OneD, NekDouble> x2(npoints,0.0);
                     Array<OneD, NekDouble> tmpArray;
 
                     BndExp[n]->GetCoords(x0,x1,x2);
 
                     LibUtilities::Equation coeff =
                         boost::static_pointer_cast<
                     SpatialDomains::RobinBoundaryCondition
                         >(BndConds[n])->m_robinPrimitiveCoeff;
 
                     coeff.Evaluate(x0,x1,x2,m_time,
                                    tmpArray = m_fieldsRadiationFactor[i]+ radpts);
                     //Vmath::Neg(npoints,tmpArray = m_fieldsRadiationFactor[i]+ radpts,1);
                     radpts += npoints;
                 }
             }
         }
 
         // Set up maping for womersley BC - and load variables
         for (int i = 0; i < m_fields.num_elements(); ++i)
         {
             for(int n = 0; n < m_fields[i]->GetBndConditions().num_elements(); ++n)
             {
                 if(boost::istarts_with(m_fields[i]->GetBndConditions()[n]->GetUserDefined(),"Womersley"))
                 {
 
                     m_womersleyParams[n] = MemoryManager<WomersleyParams>::AllocateSharedPtr(m_spacedim);
 
 
 #if 0
                     m_session->LoadParameter("Period",m_womersleyParams[n]->m_period);
                     m_session->LoadParameter("Radius",m_womersleyParams[n]->m_radius);
 
                     NekDouble n0,n1,n2;
                     m_session->LoadParameter("n0",n0);
                     m_session->LoadParameter("n1",n1);
                     m_session->LoadParameter("n2",n2);
                     m_womersleyParams[n]->m_axisnormal[0] = n0;
                     m_womersleyParams[n]->m_axisnormal[1] = n1;
                     m_womersleyParams[n]->m_axisnormal[2] = n2;
 
                     NekDouble x0,x1,x2;
                     m_session->LoadParameter("x0",x0);
                     m_session->LoadParameter("x1",x1);
                     m_session->LoadParameter("x2",x2);
                     m_womersleyParams[n]->m_axispoint[0] = x0;
                     m_womersleyParams[n]->m_axispoint[1] = x1;
                     m_womersleyParams[n]->m_axispoint[2] = x2;
 #endif
 
                     // Read in fourier coeffs
                     SetUpWomersley(n,
                                    m_fields[i]->GetBndConditions()[n]->GetUserDefined());
 
                     m_fields[i]->GetBoundaryToElmtMap(m_fieldsBCToElmtID[i],m_fieldsBCToTraceID[i]);
 
                 }
             }
         }
 
         // Set up Field Meta Data for output files
         m_fieldMetaDataMap["Kinvis"]   = boost::lexical_cast<std::string>(m_kinvis);
         m_fieldMetaDataMap["TimeStep"] = boost::lexical_cast<std::string>(m_timestep);
     }

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

virtual

Calcualate numerical fluxes

Counter variable

Number of trace points

Number of spatial dimensions

Forward state array

Backward state array

Normal velocity array

Compute the numerical fluxes at the trace points

Extract forwards/backwards trace spaces

Upwind between elements

Calculate the numerical fluxes multipling Fwd or Bwd by the normal advection velocity

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 322 of file IncNavierStokes.cpp.

References Nektar::SolverUtils::EquationSystem::GetTraceNpoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::SolverUtils::EquationSystem::m_traceNormals, m_velocity, Vmath::Vmul(), and Vmath::Vvtvp().

     {
         /// Counter variable
         int i;
 
         /// Number of trace points
         int nTracePts   = GetTraceNpoints();
 
         /// Number of spatial dimensions
         int nDimensions = m_spacedim;
 
         /// Forward state array
         Array<OneD, NekDouble> Fwd(2*nTracePts);
 
         /// Backward state array
         Array<OneD, NekDouble> Bwd = Fwd + nTracePts;
 
         /// Normal velocity array
         Array<OneD, NekDouble> Vn (nTracePts, 0.0);
 
         // Extract velocity field along the trace space and multiply by trace normals
         for(i = 0; i < nDimensions; ++i)
         {
             m_fields[0]->ExtractTracePhys(m_fields[m_velocity[i]]->GetPhys(), Fwd);
             Vmath::Vvtvp(nTracePts, m_traceNormals[i], 1, Fwd, 1, Vn, 1, Vn, 1);
         }
 
         /// Compute the numerical fluxes at the trace points
         for(i = 0; i < numflux.num_elements(); ++i)
         {
             /// Extract forwards/backwards trace spaces
             m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd, Bwd);
 
             /// Upwind between elements
             m_fields[i]->GetTrace()->Upwind(Vn, Fwd, Bwd, numflux[i]);
 
             /// Calculate the numerical fluxes multipling Fwd or Bwd
             /// by the normal advection velocity
             Vmath::Vmul(nTracePts, numflux[i], 1, Vn, 1, numflux[i], 1);
         }
     }

bool Nektar::IncNavierStokes::v_PostIntegrate ( int step )

protectedvirtual

Estimate CFL and perform steady-state check

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 937 of file IncNavierStokes.cpp.

References CalcSteadyState(), GetCFLEstimate(), m_cflsteps, Nektar::SolverUtils::EquationSystem::m_comm, m_steadyStateSteps, and m_steadyStateTol.

     {
         if(m_cflsteps && !((step+1)%m_cflsteps))
         {
             int elmtid;
             NekDouble cfl = GetCFLEstimate(elmtid);
 
             if(m_comm->GetRank() == 0)
             {
                 cout << "CFL (zero plane): "<< cfl << " (in elmt "
                      << elmtid << ")" << endl;
             }
         }
 
         if(m_steadyStateSteps && step && (!((step+1)%m_steadyStateSteps)))
         {
             if(CalcSteadyState() == true)
             {
                 cout << "Reached Steady State to tolerance "
                      << m_steadyStateTol << endl;
                 return true;
             }
         }
 
         return false;
     }

bool Nektar::IncNavierStokes::v_PreIntegrate ( int step )

protectedvirtual

Perform the extrapolation.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 925 of file IncNavierStokes.cpp.

References m_extrapolation, Nektar::SolverUtils::UnsteadySystem::m_intSoln, Nektar::SolverUtils::EquationSystem::m_time, Nektar::SolverUtils::EquationSystem::m_timestep, and SetBoundaryConditions().

     {
         m_extrapolation->SubStepSaveFields(step);
         m_extrapolation->SubStepAdvance(m_intSoln,step,m_time);
         SetBoundaryConditions(m_time+m_timestep);
         return false;
     }

virtual void Nektar::IncNavierStokes::v_TransCoeffToPhys ( void )

inlineprotectedvirtual

Virtual function for transformation to physical space.

Reimplemented from Nektar::SolverUtils::EquationSystem.

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

Definition at line 253 of file IncNavierStokes.h.

References ASSERTL0.

         {
             ASSERTL0(false,"This method is not defined in this class");
         }

virtual void Nektar::IncNavierStokes::v_TransPhysToCoeff ( void )

inlineprotectedvirtual

Virtual function for transformation to coefficient space.

Reimplemented from Nektar::SolverUtils::EquationSystem.

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

Definition at line 258 of file IncNavierStokes.h.

References ASSERTL0.

         {
             ASSERTL0(false,"This method is not defined in this class");
         }

void Nektar::IncNavierStokes::WriteModalEnergy ( void )

protected

Member Data Documentation

int Nektar::IncNavierStokes::m_cflsteps

protected

dump cfl estimate

Definition at line 194 of file IncNavierStokes.h.

Referenced by v_InitObject(), and v_PostIntegrate().

int Nektar::IncNavierStokes::m_energysteps

protected

dump energy to file at steps time

Definition at line 192 of file IncNavierStokes.h.

EquationType Nektar::IncNavierStokes::m_equationType

protected

equation type;

Definition at line 201 of file IncNavierStokes.h.

Referenced by GetEquationType(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoSolve(), Nektar::VelocityCorrectionScheme::v_InitObject(), v_InitObject(), and Nektar::CoupledLinearNS::v_InitObject().

ExtrapolateSharedPtr Nektar::IncNavierStokes::m_extrapolation

protected

Definition at line 169 of file IncNavierStokes.h.

Referenced by GetElmtCFLVals(), Nektar::VelocityCorrectionScheme::SolveUnsteadyStokesSystem(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), Nektar::VCSWeakPressure::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_GenerateSummary(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::VCSMapping::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), v_PreIntegrate(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSWeakPressure::v_SolvePressure(), Nektar::VCSMapping::v_SolvePressure(), and Nektar::VelocityCorrectionScheme::v_SolvePressure().

Array<OneD, Array<OneD, int> > Nektar::IncNavierStokes::m_fieldsBCToElmtID

protected

Mapping from BCs to Elmt IDs.

Definition at line 204 of file IncNavierStokes.h.

Referenced by SetRadiationBoundaryForcing(), SetWomersleyBoundary(), SetZeroNormalVelocity(), and v_InitObject().

Array<OneD, Array<OneD, int> > Nektar::IncNavierStokes::m_fieldsBCToTraceID

protected

Mapping from BCs to Elmt Edge IDs.

Definition at line 206 of file IncNavierStokes.h.

Referenced by SetRadiationBoundaryForcing(), SetWomersleyBoundary(), SetZeroNormalVelocity(), and v_InitObject().

Array<OneD, Array<OneD, NekDouble> > Nektar::IncNavierStokes::m_fieldsRadiationFactor

protected

RHS Factor for Radiation Condition.

Definition at line 208 of file IncNavierStokes.h.

Referenced by SetRadiationBoundaryForcing(), and v_InitObject().

std::vector<SolverUtils::ForcingSharedPtr> Nektar::IncNavierStokes::m_forcing

protected

Forcing terms.

Definition at line 178 of file IncNavierStokes.h.

Referenced by AddForcing(), Nektar::CoupledLinearNS::EvaluateAdvection(), Nektar::CoupledLinearNS::Solve(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), and v_InitObject().

int Nektar::IncNavierStokes::m_intSteps

protected

Number of time integration steps AND Order of extrapolation for pressure boundary conditions.

Definition at line 212 of file IncNavierStokes.h.

NekDouble Nektar::IncNavierStokes::m_kinvis

protected

Kinematic viscosity.

Definition at line 190 of file IncNavierStokes.h.

Referenced by Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::CoupledLinearNS::Continuation(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), SetWomersleyBoundary(), Nektar::CoupledLinearNS::SolveSteadyNavierStokes(), Nektar::VelocityCorrectionScheme::SolveUnsteadyStokesSystem(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoInitialise(), Nektar::CoupledLinearNS::v_DoSolve(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), Nektar::VelocityCorrectionScheme::v_InitObject(), v_InitObject(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpViscousForcing(), Nektar::VCSWeakPressure::v_SolvePressure(), Nektar::VelocityCorrectionScheme::v_SolvePressure(), Nektar::VCSMapping::v_SolveViscous(), and Nektar::VelocityCorrectionScheme::v_SolveViscous().

std::ofstream Nektar::IncNavierStokes::m_mdlFile

protected

modal energy file

Definition at line 172 of file IncNavierStokes.h.

int Nektar::IncNavierStokes::m_nConvectiveFields

protected

Number of fields to be convected;.

Definition at line 181 of file IncNavierStokes.h.

MultiRegions::ExpListSharedPtr Nektar::IncNavierStokes::m_pressure

protected

Pointer to field holding pressure field.

Definition at line 188 of file IncNavierStokes.h.

Referenced by Nektar::CoupledLinearNS::SetUpCoupledMatrix(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), v_GetPressure(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::VCSMapping::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::CoupledLinearNS::v_Output(), Nektar::VCSMapping::v_SetUpViscousForcing(), Nektar::VelocityCorrectionScheme::v_SetUpViscousForcing(), Nektar::VCSWeakPressure::v_SolvePressure(), Nektar::VCSMapping::v_SolvePressure(), and Nektar::VelocityCorrectionScheme::v_SolvePressure().

bool Nektar::IncNavierStokes::m_SmoothAdvection

protected

bool to identify if advection term smoothing is requested

Definition at line 175 of file IncNavierStokes.h.

Referenced by Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), and Nektar::VelocityCorrectionScheme::v_InitObject().

int Nektar::IncNavierStokes::m_steadyStateSteps

protected

Check for steady state at step interval.

Definition at line 196 of file IncNavierStokes.h.

Referenced by v_InitObject(), and v_PostIntegrate().

NekDouble Nektar::IncNavierStokes::m_steadyStateTol

protected

Tolerance to which steady state should be evaluated at.

Definition at line 198 of file IncNavierStokes.h.

Referenced by CalcSteadyState(), v_InitObject(), and v_PostIntegrate().

Array<OneD, int> Nektar::IncNavierStokes::m_velocity

protected

int which identifies which components of m_fields contains the velocity (u,v,w);

Definition at line 185 of file IncNavierStokes.h.

std::map<int,WomersleyParamsSharedPtr> Nektar::IncNavierStokes::m_womersleyParams

protected

Womersley parameters if required.

Definition at line 246 of file IncNavierStokes.h.

Referenced by SetUpWomersley(), SetWomersleyBoundary(), and v_InitObject().

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation