Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
Nektar::IncNavierStokes Class Referenceabstract

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

#include <IncNavierStokes.h>

Inheritance diagram for Nektar::IncNavierStokes:
Inheritance graph
[legend]
Collaboration diagram for Nektar::IncNavierStokes:
Collaboration graph
[legend]

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 string &s1, const 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, Array< OneD, NekDouble > &wk=NullNekDouble1DArray)
 
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...
 
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)
 
SOLVER_UTILS_EXPORT void CheckForRestartTime (NekDouble &time)
 
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 string &s1, const 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 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...
 
- 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...
 
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...
 
map< std::string, Array< OneD,
Array< OneD, float > > > 		m_interpWeights
 Map of the interpolation weights for a specific filename. More...
 
map< std::string, Array< OneD,
Array< OneD, unsigned int > > > 		m_interpInds
 Map of the interpolation indices for a specific filename. More...
 
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...
 
std::set< std::string > m_loadedFields
 
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...
 
int m_NumMode
 Mode to use in case of single mode analysis. 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 104 of file IncNavierStokes.h.

Constructor & Destructor Documentation

Nektar::IncNavierStokes::~IncNavierStokes ( void  )
virtual

Destructor

Definition at line 243 of file IncNavierStokes.cpp.

244  {
245  }
Nektar::IncNavierStokes::IncNavierStokes ( const LibUtilities::SessionReaderSharedPtr &  pSession)
protected

Constructor.

Constructor. Creates ...

Parameters
param

Definition at line 56 of file IncNavierStokes.cpp.

56  :
57  UnsteadySystem(pSession),
58  AdvectionSystem(pSession),
59  m_SmoothAdvection(false),
60  m_steadyStateSteps(0)
61  {
62  }
Nektar::IncNavierStokes::m_SmoothAdvection
bool m_SmoothAdvection
bool to identify if advection term smoothing is requested
Definition: IncNavierStokes.h:149
Nektar::IncNavierStokes::m_steadyStateSteps
int m_steadyStateSteps
Check for steady state at step interval.
Definition: IncNavierStokes.h:170
Nektar::SolverUtils::AdvectionSystem::AdvectionSystem
SOLVER_UTILS_EXPORT AdvectionSystem(const LibUtilities::SessionReaderSharedPtr &pSession)
Definition: AdvectionSystem.cpp:44
Nektar::SolverUtils::UnsteadySystem::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession)
Initialises UnsteadySystem class members.
Definition: UnsteadySystem.cpp:65

Member Function Documentation

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

Add an additional forcing term programmatically.

Definition at line 526 of file IncNavierStokes.cpp.

References m_forcing.

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

527  {
528  m_forcing.push_back(pForce);
529  }
Nektar::IncNavierStokes::m_forcing
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
Forcing terms.
Definition: IncNavierStokes.h:152
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 537 of file IncNavierStokes.cpp.

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

Referenced by v_PostIntegrate().

538  {
539  static NekDouble previousL2 = 0.0;
540  bool returnval = false;
541 
542  NekDouble L2 = 0.0;
543 
544  // calculate L2 discrete summation
545  int ncoeffs = m_fields[0]->GetNcoeffs();
546 
547  for(int i = 0; i < m_fields.num_elements(); ++i)
548  {
549  L2 += Vmath::Dot(ncoeffs,m_fields[i]->GetCoeffs(),1,m_fields[i]->GetCoeffs(),1);
550  }
551 
552  if(fabs(L2-previousL2) < ncoeffs*m_steadyStateTol)
553  {
554  returnval = true;
555  }
556 
557  previousL2 = L2;
558 
559  return returnval;
560  }
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
Vmath::Dot
T Dot(int n, const T *w, const T *x)
vvtvp (vector times vector times vector): z = w*x*y
Definition: Vmath.cpp:900
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::IncNavierStokes::m_steadyStateTol
NekDouble m_steadyStateTol
Tolerance to which steady state should be evaluated at.
Definition: IncNavierStokes.h:172
void Nektar::IncNavierStokes::EvaluateAdvectionTerms ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
Array< OneD, NekDouble > &  wk = NullNekDouble1DArray 
)
protected

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

Definition at line 312 of file IncNavierStokes.cpp.

References ASSERTL0, Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_halfMode, m_nConvectiveFields, Nektar::SolverUtils::EquationSystem::m_singleMode, 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().

315  {
316  int i;
317  int nqtot = m_fields[0]->GetTotPoints();
318  int VelDim = m_velocity.num_elements();
319  Array<OneD, Array<OneD, NekDouble> > velocity(VelDim);
320  Array<OneD, NekDouble > Deriv;
321 
322  for(i = 0; i < VelDim; ++i)
323  {
324  if(m_fields[i]->GetWaveSpace() && !m_singleMode && !m_halfMode)
325  {
326  velocity[i] = Array<OneD, NekDouble>(nqtot,0.0);
327  m_fields[i]->HomogeneousBwdTrans(inarray[m_velocity[i]],velocity[i]);
328  }
329  else
330  {
331  velocity[i] = inarray[m_velocity[i]];
332  }
333  }
334 
335  // Set up Derivative work space;
336  if(wk.num_elements())
337  {
338  ASSERTL0(wk.num_elements() >= nqtot*VelDim,
339  "Workspace is not sufficient");
340  Deriv = wk;
341  }
342  else
343  {
344  Deriv = Array<OneD, NekDouble> (nqtot*VelDim);
345  }
346 
347  m_advObject->Advect(m_nConvectiveFields, m_fields,
348  velocity, inarray, outarray, m_time);
349  }
Nektar::SolverUtils::EquationSystem::m_singleMode
bool m_singleMode
Flag to determine if single homogeneous mode is used.
Definition: EquationSystem.h:496
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::SolverUtils::AdvectionSystem::m_advObject
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
Definition: AdvectionSystem.h:64
Nektar::SolverUtils::EquationSystem::m_time
NekDouble m_time
Current time of simulation.
Definition: EquationSystem.h:472
Nektar::SolverUtils::EquationSystem::m_halfMode
bool m_halfMode
Flag to determine if half homogeneous mode is used.
Definition: EquationSystem.h:498
Nektar::IncNavierStokes::m_velocity
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: IncNavierStokes.h:159
Nektar::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
NekDouble Nektar::IncNavierStokes::GetCFLEstimate ( int &  elmtid)

Definition at line 612 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().

613  {
614  int n_element = m_fields[0]->GetExpSize();
615 
616  Array<OneD, NekDouble> cfl = GetElmtCFLVals();
617 
618  elmtid = Vmath::Imax(n_element,cfl,1);
619  NekDouble CFL,CFL_loc;
620 
621  CFL = CFL_loc = cfl[elmtid];
622  m_comm->AllReduce(CFL,LibUtilities::ReduceMax);
623 
624  // unshuffle elmt id if data is not stored in consecutive order.
625  elmtid = m_fields[0]->GetExp(elmtid)->GetGeom()->GetGlobalID();
626  if(CFL != CFL_loc)
627  {
628  elmtid = -1;
629  }
630 
631  m_comm->AllReduce(elmtid,LibUtilities::ReduceMax);
632 
633  // express element id with respect to plane
634  if(m_HomogeneousType == eHomogeneous1D)
635  {
636  elmtid = elmtid%m_fields[0]->GetPlane(0)->GetExpSize();
637  }
638  return CFL;
639  }
Vmath::Imax
int Imax(int n, const T *x, const int incx)
Return the index of the maximum element in x.
Definition: Vmath.cpp:741
Nektar::SolverUtils::EquationSystem::m_comm
LibUtilities::CommSharedPtr m_comm
Communicator.
Definition: EquationSystem.h:450
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::SolverUtils::EquationSystem::m_HomogeneousType
enum HomogeneousType m_HomogeneousType
Definition: EquationSystem.h:540
Nektar::IncNavierStokes::GetElmtCFLVals
Array< OneD, NekDouble > GetElmtCFLVals(void)
Definition: IncNavierStokes.cpp:565
Array< OneD, NekDouble > Nektar::IncNavierStokes::GetElmtCFLVals ( void  )

Definition at line 565 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().

566  {
567  int n_vel = m_velocity.num_elements();
568  int n_element = m_fields[0]->GetExpSize();
569 
570  const Array<OneD, int> ExpOrder = GetNumExpModesPerExp();
571  Array<OneD, int> ExpOrderList (n_element, ExpOrder);
572 
573  const NekDouble cLambda = 0.2; // Spencer book pag. 317
574 
575  Array<OneD, NekDouble> cfl (n_element, 0.0);
576  Array<OneD, NekDouble> stdVelocity(n_element, 0.0);
577  Array<OneD, Array<OneD, NekDouble> > velfields;
578 
579  if(m_HomogeneousType == eHomogeneous1D) // just do check on 2D info
580  {
581  velfields = Array<OneD, Array<OneD, NekDouble> >(2);
582 
583  for(int i = 0; i < 2; ++i)
584  {
585  velfields[i] = m_fields[m_velocity[i]]->UpdatePhys();
586  }
587  }
588  else
589  {
590  velfields = Array<OneD, Array<OneD, NekDouble> >(n_vel);
591 
592  for(int i = 0; i < n_vel; ++i)
593  {
594  velfields[i] = m_fields[m_velocity[i]]->UpdatePhys();
595  }
596  }
597 
598  stdVelocity = m_extrapolation->GetMaxStdVelocity(velfields);
599 
600  for(int el = 0; el < n_element; ++el)
601  {
602  cfl[el] = m_timestep*(stdVelocity[el] * cLambda *
603  (ExpOrder[el]-1) * (ExpOrder[el]-1));
604  }
605 
606  return cfl;
607  }
Nektar::SolverUtils::EquationSystem::m_timestep
NekDouble m_timestep
Time step size.
Definition: EquationSystem.h:478
Nektar::SolverUtils::EquationSystem::GetNumExpModesPerExp
SOLVER_UTILS_EXPORT const Array< OneD, int > GetNumExpModesPerExp()
Definition: EquationSystem.h:828
Nektar::IncNavierStokes::m_velocity
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: IncNavierStokes.h:159
Nektar::IncNavierStokes::m_extrapolation
ExtrapolateSharedPtr m_extrapolation
Definition: IncNavierStokes.h:143
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::SolverUtils::EquationSystem::m_HomogeneousType
enum HomogeneousType m_HomogeneousType
Definition: EquationSystem.h:540
EquationType Nektar::IncNavierStokes::GetEquationType ( void  )
inlineprotected

Definition at line 191 of file IncNavierStokes.h.

References m_equationType.

192  {
193  return m_equationType;
194  }
Nektar::IncNavierStokes::m_equationType
EquationType m_equationType
equation type;
Definition: IncNavierStokes.h:175
int Nektar::IncNavierStokes::GetNConvectiveFields ( void  )
inline

Definition at line 122 of file IncNavierStokes.h.

References m_nConvectiveFields.

123  {
124  return m_nConvectiveFields;
125  }
Nektar::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Array<OneD, int>& Nektar::IncNavierStokes::GetVelocity ( void  )
inline

Definition at line 127 of file IncNavierStokes.h.

References m_velocity.

128  {
129  return m_velocity;
130  }
Nektar::IncNavierStokes::m_velocity
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: IncNavierStokes.h:159
void Nektar::IncNavierStokes::SetBoundaryConditions ( NekDouble  time)
protected

time dependent boundary conditions updating

Time dependent boundary conditions updating

Definition at line 354 of file IncNavierStokes.cpp.

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

Referenced by Nektar::VelocityCorrectionScheme::SolveUnsteadyStokesSystem(), Nektar::CoupledLinearNS::SolveUnsteadyStokesSystem(), and Nektar::VelocityCorrectionScheme::v_DoInitialise().

355  {
356  int i, n;
357  std::string varName;
358  int nvariables = m_fields.num_elements();
359 
360  for (i = 0; i < nvariables; ++i)
361  {
362  for(n = 0; n < m_fields[i]->GetBndConditions().num_elements(); ++n)
363  {
364  if(m_fields[i]->GetBndConditions()[n]->IsTimeDependent())
365  {
366  varName = m_session->GetVariable(i);
367  m_fields[i]->EvaluateBoundaryConditions(time, varName);
368  }
369 
370  }
371 
372  // Set Radiation conditions if required
373  SetRadiationBoundaryForcing(i);
374  }
375 
376  SetZeroNormalVelocity();
377  }
Nektar::IncNavierStokes::SetZeroNormalVelocity
void SetZeroNormalVelocity()
Set Normal Velocity Component to Zero.
Definition: IncNavierStokes.cpp:439
Nektar::IncNavierStokes::SetRadiationBoundaryForcing
void SetRadiationBoundaryForcing(int fieldid)
Set Radiation forcing term.
Definition: IncNavierStokes.cpp:382
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::SolverUtils::EquationSystem::m_session
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Definition: EquationSystem.h:452
void Nektar::IncNavierStokes::SetRadiationBoundaryForcing ( int  fieldid)
protected

Set Radiation forcing term.

Probably should be pushed back into ContField?

Definition at line 382 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().

383  {
384  int i,n;
385 
386  Array<OneD, const SpatialDomains::BoundaryConditionShPtr > BndConds;
387  Array<OneD, MultiRegions::ExpListSharedPtr> BndExp;
388 
389  BndConds = m_fields[fieldid]->GetBndConditions();
390  BndExp = m_fields[fieldid]->GetBndCondExpansions();
391 
392  StdRegions::StdExpansionSharedPtr elmt;
393  StdRegions::StdExpansionSharedPtr Bc;
394 
395  int cnt;
396  int elmtid,nq,offset, boundary;
397  Array<OneD, NekDouble> Bvals, U;
398  int cnt1 = 0;
399 
400  for(cnt = n = 0; n < BndConds.num_elements(); ++n)
401  {
402  std::string type = BndConds[n]->GetUserDefined();
403 
404  if((BndConds[n]->GetBoundaryConditionType() == SpatialDomains::eRobin)&&(boost::iequals(type,"Radiation")))
405  {
406  for(i = 0; i < BndExp[n]->GetExpSize(); ++i,cnt++)
407  {
408  elmtid = m_fieldsBCToElmtID[m_velocity[fieldid]][cnt];
409  elmt = m_fields[fieldid]->GetExp(elmtid);
410  offset = m_fields[fieldid]->GetPhys_Offset(elmtid);
411 
412  U = m_fields[fieldid]->UpdatePhys() + offset;
413  Bc = BndExp[n]->GetExp(i);
414 
415  boundary = m_fieldsBCToTraceID[fieldid][cnt];
416 
417  // Get edge values and put into ubc
418  nq = Bc->GetTotPoints();
419  Array<OneD, NekDouble> ubc(nq);
420  elmt->GetTracePhysVals(boundary,Bc,U,ubc);
421 
422  Vmath::Vmul(nq,&m_fieldsRadiationFactor[fieldid][cnt1 +
423  BndExp[n]->GetPhys_Offset(i)],1,&ubc[0],1,&ubc[0],1);
424 
425  Bvals = BndExp[n]->UpdateCoeffs()+BndExp[n]->GetCoeff_Offset(i);
426 
427  Bc->IProductWRTBase(ubc,Bvals);
428  }
429  cnt1 += BndExp[n]->GetTotPoints();
430  }
431  else
432  {
433  cnt += BndExp[n]->GetExpSize();
434  }
435  }
436  }
Nektar::IncNavierStokes::m_fieldsBCToTraceID
Array< OneD, Array< OneD, int > > m_fieldsBCToTraceID
Mapping from BCs to Elmt Edge IDs.
Definition: IncNavierStokes.h:180
Nektar::IncNavierStokes::m_velocity
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: IncNavierStokes.h:159
Nektar::IncNavierStokes::m_fieldsRadiationFactor
Array< OneD, Array< OneD, NekDouble > > m_fieldsRadiationFactor
RHS Factor for Radiation Condition.
Definition: IncNavierStokes.h:182
Nektar::SolverUtils::EquationSystem::GetPhys_Offset
SOLVER_UTILS_EXPORT int GetPhys_Offset(int n)
Definition: EquationSystem.h:858
Nektar::IncNavierStokes::m_fieldsBCToElmtID
Array< OneD, Array< OneD, int > > m_fieldsBCToElmtID
Mapping from BCs to Elmt IDs.
Definition: IncNavierStokes.h:178
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::StdRegions::StdExpansionSharedPtr
boost::shared_ptr< StdExpansion > StdExpansionSharedPtr
Definition: StdExpansion.h:1873
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:169
void Nektar::IncNavierStokes::SetZeroNormalVelocity ( )
protected

Set Normal Velocity Component to Zero.

Definition at line 439 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().

440  {
441  // use static trip since cannot use UserDefinedTag for zero
442  // velocity and have time dependent conditions
443  static bool Setup = false;
444 
445  if(Setup == true)
446  {
447  return;
448  }
449  Setup = true;
450 
451  int i,n;
452 
453  Array<OneD, Array<OneD, const SpatialDomains::BoundaryConditionShPtr > >
454  BndConds(m_spacedim);
455  Array<OneD, Array<OneD, MultiRegions::ExpListSharedPtr> >
456  BndExp(m_spacedim);
457 
458 
459  for(i = 0; i < m_spacedim; ++i)
460  {
461  BndConds[i] = m_fields[m_velocity[i]]->GetBndConditions();
462  BndExp[i] = m_fields[m_velocity[i]]->GetBndCondExpansions();
463  }
464 
465  StdRegions::StdExpansionSharedPtr elmt,Bc;
466 
467  int cnt;
468  int elmtid,nq, boundary;
469 
470  Array<OneD, Array<OneD, NekDouble> > normals;
471  Array<OneD, NekDouble> Bphys,Bcoeffs;
472 
473  int fieldid = m_velocity[0];
474 
475  for(cnt = n = 0; n < BndConds[0].num_elements(); ++n)
476  {
477  if((BndConds[0][n]->GetBoundaryConditionType() == SpatialDomains::eDirichlet)&& (boost::iequals(BndConds[0][n]->GetUserDefined(),"ZeroNormalComponent")))
478  {
479  for(i = 0; i < BndExp[0][n]->GetExpSize(); ++i,cnt++)
480  {
481  elmtid = m_fieldsBCToElmtID[fieldid][cnt];
482  elmt = m_fields[0]->GetExp(elmtid);
483  boundary = m_fieldsBCToTraceID[fieldid][cnt];
484 
485  normals = elmt->GetSurfaceNormal(boundary);
486 
487  nq = BndExp[0][n]->GetExp(i)->GetTotPoints();
488  Array<OneD, NekDouble> normvel(nq,0.0);
489 
490  for(int k = 0; k < m_spacedim; ++k)
491  {
492  Bphys = BndExp[k][n]->UpdatePhys()+
493  BndExp[k][n]->GetPhys_Offset(i);
494  Bc = BndExp[k][n]->GetExp(i);
495  Vmath::Vvtvp(nq,normals[k],1,Bphys,1,normvel,1,
496  normvel,1);
497  }
498 
499  // negate normvel for next step
500  Vmath::Neg(nq,normvel,1);
501 
502  for(int k = 0; k < m_spacedim; ++k)
503  {
504  Bphys = BndExp[k][n]->UpdatePhys()+
505  BndExp[k][n]->GetPhys_Offset(i);
506  Bcoeffs = BndExp[k][n]->UpdateCoeffs()+
507  BndExp[k][n]->GetCoeff_Offset(i);
508  Bc = BndExp[k][n]->GetExp(i);
509  Vmath::Vvtvp(nq,normvel,1,normals[k],1,Bphys,1,
510  Bphys,1);
511  Bc->FwdTrans_BndConstrained(Bphys,Bcoeffs);
512  }
513  }
514  }
515  else
516  {
517  cnt += BndExp[0][n]->GetExpSize();
518  }
519  }
520  }
Nektar::IncNavierStokes::m_fieldsBCToTraceID
Array< OneD, Array< OneD, int > > m_fieldsBCToTraceID
Mapping from BCs to Elmt Edge IDs.
Definition: IncNavierStokes.h:180
Nektar::IncNavierStokes::m_velocity
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: IncNavierStokes.h:159
Vmath::Vvtvp
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:428
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:492
Vmath::Neg
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
Nektar::IncNavierStokes::m_fieldsBCToElmtID
Array< OneD, Array< OneD, int > > m_fieldsBCToElmtID
Mapping from BCs to Elmt IDs.
Definition: IncNavierStokes.h:178
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::StdRegions::StdExpansionSharedPtr
boost::shared_ptr< StdExpansion > StdExpansionSharedPtr
Definition: StdExpansion.h:1873
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 251 of file IncNavierStokes.cpp.

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

254  {
255  ASSERTL1(flux.num_elements() == m_velocity.num_elements(),"Dimension of flux array and velocity array do not match");
256 
257  for(int j = 0; j < flux.num_elements(); ++j)
258  {
259  Vmath::Vmul(GetNpoints(), physfield[i], 1, m_fields[m_velocity[j]]->GetPhys(), 1, flux[j], 1);
260  }
261  }
Nektar::IncNavierStokes::m_velocity
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: IncNavierStokes.h:159
Nektar::SolverUtils::EquationSystem::GetNpoints
SOLVER_UTILS_EXPORT int GetNpoints()
Definition: EquationSystem.h:878
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:169
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 214 of file IncNavierStokes.h.

References m_pressure.

215  {
216  return m_pressure;
217  }
Nektar::IncNavierStokes::m_pressure
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
Definition: IncNavierStokes.h:162
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 64 of file IncNavierStokes.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::SpatialDomains::eDirichlet, Nektar::eEquationTypeSize, Nektar::eNoEquationType, Nektar::SpatialDomains::eRobin, Nektar::eSteadyLinearisedNS, Nektar::eSteadyNavierStokes, Nektar::eSteadyOseen, Nektar::eSteadyStokes, Nektar::eUnsteadyLinearisedNS, Nektar::eUnsteadyNavierStokes, Nektar::eUnsteadyStokes, Nektar::LibUtilities::Equation::Evaluate(), Nektar::SolverUtils::GetAdvectionFactory(), Nektar::kEquationTypeStr, Nektar::SolverUtils::Forcing::Load(), Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::EquationSystem::m_boundaryConditions, m_cflsteps, m_equationType, Nektar::SolverUtils::EquationSystem::m_fieldMetaDataMap, Nektar::SolverUtils::EquationSystem::m_fields, m_fieldsBCToElmtID, m_fieldsBCToTraceID, m_fieldsRadiationFactor, m_forcing, Nektar::SolverUtils::UnsteadySystem::m_infosteps, m_kinvis, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, m_steadyStateSteps, m_steadyStateTol, Nektar::SolverUtils::EquationSystem::m_time, Nektar::SolverUtils::EquationSystem::m_timestep, m_velocity, and v_GetForceDimension().

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

65  {
66  AdvectionSystem::v_InitObject();
67 
68  int i,j;
69  int numfields = m_fields.num_elements();
70  std::string velids[] = {"u","v","w"};
71 
72  // Set up Velocity field to point to the first m_expdim of m_fields;
73  m_velocity = Array<OneD,int>(m_spacedim);
74 
75  for(i = 0; i < m_spacedim; ++i)
76  {
77  for(j = 0; j < numfields; ++j)
78  {
79  std::string var = m_boundaryConditions->GetVariable(j);
80  if(boost::iequals(velids[i], var))
81  {
82  m_velocity[i] = j;
83  break;
84  }
85 
86  ASSERTL0(j != numfields, "Failed to find field: " + var);
87  }
88  }
89 
90  // Set up equation type enum using kEquationTypeStr
91  for(i = 0; i < (int) eEquationTypeSize; ++i)
92  {
93  bool match;
94  m_session->MatchSolverInfo("EQTYPE",kEquationTypeStr[i],match,false);
95  if(match)
96  {
97  m_equationType = (EquationType)i;
98  break;
99  }
100  }
101  ASSERTL0(i != eEquationTypeSize,"EQTYPE not found in SOLVERINFO section");
102 
103  // This probably should to into specific implementations
104  // Equation specific Setups
105  switch(m_equationType)
106  {
107  case eSteadyStokes:
108  case eSteadyOseen:
109  case eSteadyNavierStokes:
110  case eSteadyLinearisedNS:
111  break;
112  case eUnsteadyNavierStokes:
113  case eUnsteadyStokes:
114  {
115  m_session->LoadParameter("IO_InfoSteps", m_infosteps, 0);
116  m_session->LoadParameter("IO_CFLSteps", m_cflsteps, 0);
117  m_session->LoadParameter("SteadyStateSteps", m_steadyStateSteps, 0);
118  m_session->LoadParameter("SteadyStateTol", m_steadyStateTol, 1e-6);
119  }
120  break;
121  case eNoEquationType:
122  default:
123  ASSERTL0(false,"Unknown or undefined equation type");
124  }
125 
126  m_session->LoadParameter("Kinvis", m_kinvis);
127 
128  // Default advection type per solver
129  std::string vConvectiveType;
130  switch(m_equationType)
131  {
132  case eUnsteadyStokes:
133  case eSteadyLinearisedNS:
134  vConvectiveType = "NoAdvection";
135  break;
136  case eUnsteadyNavierStokes:
137  case eSteadyNavierStokes:
138  vConvectiveType = "Convective";
139  break;
140  case eUnsteadyLinearisedNS:
141  vConvectiveType = "Linearised";
142  break;
143  default:
144  break;
145  }
146 
147  // Check if advection type overridden
148  if (m_session->DefinesTag("AdvectiveType") && m_equationType != eUnsteadyStokes &&
149  m_equationType != eSteadyLinearisedNS)
150  {
151  vConvectiveType = m_session->GetTag("AdvectiveType");
152  }
153 
154  // Initialise advection
155  m_advObject = SolverUtils::GetAdvectionFactory().CreateInstance(vConvectiveType, vConvectiveType);
156  m_advObject->InitObject( m_session, m_fields);
157 
158  // Forcing terms
159  m_forcing = SolverUtils::Forcing::Load(m_session, m_fields,
160  v_GetForceDimension());
161 
162  // check to see if any Robin boundary conditions and if so set
163  // up m_field to boundary condition maps;
164  m_fieldsBCToElmtID = Array<OneD, Array<OneD, int> >(numfields);
165  m_fieldsBCToTraceID = Array<OneD, Array<OneD, int> >(numfields);
166  m_fieldsRadiationFactor = Array<OneD, Array<OneD, NekDouble> > (numfields);
167 
168  for (i = 0; i < m_fields.num_elements(); ++i)
169  {
170  bool Set = false;
171 
172  Array<OneD, const SpatialDomains::BoundaryConditionShPtr > BndConds;
173  Array<OneD, MultiRegions::ExpListSharedPtr> BndExp;
174  int radpts = 0;
175 
176  BndConds = m_fields[i]->GetBndConditions();
177  BndExp = m_fields[i]->GetBndCondExpansions();
178  for(int n = 0; n < BndConds.num_elements(); ++n)
179  {
180  if(boost::iequals(BndConds[n]->GetUserDefined(),"Radiation"))
181  {
182  ASSERTL0(BndConds[n]->GetBoundaryConditionType() == SpatialDomains::eRobin,
183  "Radiation boundary condition must be of type Robin <R>");
184 
185  if(Set == false)
186  {
187  m_fields[i]->GetBoundaryToElmtMap(m_fieldsBCToElmtID[i],m_fieldsBCToTraceID[i]);
188  Set = true;
189  }
190  radpts += BndExp[n]->GetTotPoints();
191  }
192  if(boost::iequals(BndConds[n]->GetUserDefined(),"ZeroNormalComponent"))
193  {
194  ASSERTL0(BndConds[n]->GetBoundaryConditionType() == SpatialDomains::eDirichlet,
195  "Zero Normal Component boundary condition option must be of type Dirichlet <D>");
196 
197  if(Set == false)
198  {
199  m_fields[i]->GetBoundaryToElmtMap(m_fieldsBCToElmtID[i],m_fieldsBCToTraceID[i]);
200  Set = true;
201  }
202  }
203  }
204 
205  m_fieldsRadiationFactor[i] = Array<OneD, NekDouble>(radpts);
206 
207  radpts = 0; // reset to use as a counter
208 
209  for(int n = 0; n < BndConds.num_elements(); ++n)
210  {
211  if(boost::iequals(BndConds[n]->GetUserDefined(),"Radiation"))
212  {
213 
214  int npoints = BndExp[n]->GetNpoints();
215  Array<OneD, NekDouble> x0(npoints,0.0);
216  Array<OneD, NekDouble> x1(npoints,0.0);
217  Array<OneD, NekDouble> x2(npoints,0.0);
218  Array<OneD, NekDouble> tmpArray;
219 
220  BndExp[n]->GetCoords(x0,x1,x2);
221 
222  LibUtilities::Equation coeff =
223  boost::static_pointer_cast<
224  SpatialDomains::RobinBoundaryCondition
225  >(BndConds[n])->m_robinPrimitiveCoeff;
226 
227  coeff.Evaluate(x0,x1,x2,m_time,
228  tmpArray = m_fieldsRadiationFactor[i]+ radpts);
229  //Vmath::Neg(npoints,tmpArray = m_fieldsRadiationFactor[i]+ radpts,1);
230  radpts += npoints;
231  }
232  }
233  }
234 
235  // Set up Field Meta Data for output files
236  m_fieldMetaDataMap["Kinvis"] = boost::lexical_cast<std::string>(m_kinvis);
237  m_fieldMetaDataMap["TimeStep"] = boost::lexical_cast<std::string>(m_timestep);
238  }
Nektar::IncNavierStokes::m_equationType
EquationType m_equationType
equation type;
Definition: IncNavierStokes.h:175
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::IncNavierStokes::m_fieldsBCToTraceID
Array< OneD, Array< OneD, int > > m_fieldsBCToTraceID
Mapping from BCs to Elmt Edge IDs.
Definition: IncNavierStokes.h:180
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey BOOST_PP_COMMA_IF(MAX_PARAM) BOOST_PP_ENUM_BINARY_PARAMS(MAX_PARAM, tParam, x))
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:162
Nektar::SolverUtils::AdvectionSystem::m_advObject
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
Definition: AdvectionSystem.h:64
Nektar::SolverUtils::EquationSystem::m_time
NekDouble m_time
Current time of simulation.
Definition: EquationSystem.h:472
Nektar::IncNavierStokes::m_kinvis
NekDouble m_kinvis
Kinematic viscosity.
Definition: IncNavierStokes.h:164
Nektar::SolverUtils::EquationSystem::m_timestep
NekDouble m_timestep
Time step size.
Definition: EquationSystem.h:478
Nektar::IncNavierStokes::m_velocity
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: IncNavierStokes.h:159
Nektar::SolverUtils::Forcing::Load
static SOLVER_UTILS_EXPORT std::vector< ForcingSharedPtr > Load(const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields=0)
Definition: Forcing.cpp:84
Nektar::IncNavierStokes::m_fieldsRadiationFactor
Array< OneD, Array< OneD, NekDouble > > m_fieldsRadiationFactor
RHS Factor for Radiation Condition.
Definition: IncNavierStokes.h:182
Nektar::IncNavierStokes::m_cflsteps
int m_cflsteps
dump cfl estimate
Definition: IncNavierStokes.h:168
Nektar::IncNavierStokes::m_forcing
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
Forcing terms.
Definition: IncNavierStokes.h:152
Nektar::LibUtilities::Equation::Evaluate
NekDouble Evaluate() const
Definition: Equation.h:102
Nektar::IncNavierStokes::m_steadyStateSteps
int m_steadyStateSteps
Check for steady state at step interval.
Definition: IncNavierStokes.h:170
Nektar::SolverUtils::EquationSystem::m_boundaryConditions
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
Pointer to boundary conditions object.
Definition: EquationSystem.h:466
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:492
Nektar::SolverUtils::EquationSystem::m_fieldMetaDataMap
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
Map to identify relevant solver info to dump in output fields.
Definition: EquationSystem.h:524
Nektar::SolverUtils::GetAdvectionFactory
AdvectionFactory & GetAdvectionFactory()
Gets the factory for initialising advection objects.
Definition: Advection.cpp:46
Nektar::IncNavierStokes::m_fieldsBCToElmtID
Array< OneD, Array< OneD, int > > m_fieldsBCToElmtID
Mapping from BCs to Elmt IDs.
Definition: IncNavierStokes.h:178
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::SolverUtils::EquationSystem::m_session
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Definition: EquationSystem.h:452
Nektar::kEquationTypeStr
const std::string kEquationTypeStr[]
Definition: IncNavierStokes.h:63
Nektar::SolverUtils::UnsteadySystem::m_infosteps
int m_infosteps
Number of time steps between outputting status information.
Definition: UnsteadySystem.h:63
Nektar::IncNavierStokes::m_steadyStateTol
NekDouble m_steadyStateTol
Tolerance to which steady state should be evaluated at.
Definition: IncNavierStokes.h:172
Nektar::IncNavierStokes::v_GetForceDimension
virtual int v_GetForceDimension()=0
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 266 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().

268  {
269  /// Counter variable
270  int i;
271 
272  /// Number of trace points
273  int nTracePts = GetTraceNpoints();
274 
275  /// Number of spatial dimensions
276  int nDimensions = m_spacedim;
277 
278  /// Forward state array
279  Array<OneD, NekDouble> Fwd(2*nTracePts);
280 
281  /// Backward state array
282  Array<OneD, NekDouble> Bwd = Fwd + nTracePts;
283 
284  /// Normal velocity array
285  Array<OneD, NekDouble> Vn (nTracePts, 0.0);
286 
287  // Extract velocity field along the trace space and multiply by trace normals
288  for(i = 0; i < nDimensions; ++i)
289  {
290  m_fields[0]->ExtractTracePhys(m_fields[m_velocity[i]]->GetPhys(), Fwd);
291  Vmath::Vvtvp(nTracePts, m_traceNormals[i], 1, Fwd, 1, Vn, 1, Vn, 1);
292  }
293 
294  /// Compute the numerical fluxes at the trace points
295  for(i = 0; i < numflux.num_elements(); ++i)
296  {
297  /// Extract forwards/backwards trace spaces
298  m_fields[i]->GetFwdBwdTracePhys(physfield[i], Fwd, Bwd);
299 
300  /// Upwind between elements
301  m_fields[i]->GetTrace()->Upwind(Vn, Fwd, Bwd, numflux[i]);
302 
303  /// Calculate the numerical fluxes multipling Fwd or Bwd
304  /// by the normal advection velocity
305  Vmath::Vmul(nTracePts, numflux[i], 1, Vn, 1, numflux[i], 1);
306  }
307  }
Nektar::IncNavierStokes::m_velocity
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
Definition: IncNavierStokes.h:159
Vmath::Vvtvp
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:428
Nektar::SolverUtils::EquationSystem::m_traceNormals
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Array holding trace normals for DG simulations in the forwards direction.
Definition: EquationSystem.h:516
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:492
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::SolverUtils::EquationSystem::GetTraceNpoints
SOLVER_UTILS_EXPORT int GetTraceNpoints()
Definition: EquationSystem.h:848
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:169
bool Nektar::IncNavierStokes::v_PostIntegrate ( int  step)
protectedvirtual

Estimate CFL and perform steady-state check

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 656 of file IncNavierStokes.cpp.

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

657  {
658  if(m_cflsteps && !((step+1)%m_cflsteps))
659  {
660  int elmtid;
661  NekDouble cfl = GetCFLEstimate(elmtid);
662 
663  if(m_comm->GetRank() == 0)
664  {
665  cout << "CFL (zero plane): "<< cfl << " (in elmt "
666  << elmtid << ")" << endl;
667  }
668  }
669 
670  if(m_steadyStateSteps && step && (!((step+1)%m_steadyStateSteps)))
671  {
672  if(CalcSteadyState() == true)
673  {
674  cout << "Reached Steady State to tolerance "
675  << m_steadyStateTol << endl;
676  return true;
677  }
678  }
679 
680  return false;
681  }
Nektar::IncNavierStokes::CalcSteadyState
bool CalcSteadyState(void)
evaluate steady state
Definition: IncNavierStokes.cpp:537
Nektar::SolverUtils::EquationSystem::m_comm
LibUtilities::CommSharedPtr m_comm
Communicator.
Definition: EquationSystem.h:450
Nektar::IncNavierStokes::m_cflsteps
int m_cflsteps
dump cfl estimate
Definition: IncNavierStokes.h:168
Nektar::IncNavierStokes::m_steadyStateSteps
int m_steadyStateSteps
Check for steady state at step interval.
Definition: IncNavierStokes.h:170
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
Nektar::IncNavierStokes::m_steadyStateTol
NekDouble m_steadyStateTol
Tolerance to which steady state should be evaluated at.
Definition: IncNavierStokes.h:172
Nektar::IncNavierStokes::GetCFLEstimate
NekDouble GetCFLEstimate(int &elmtid)
Definition: IncNavierStokes.cpp:612
bool Nektar::IncNavierStokes::v_PreIntegrate ( int  step)
protectedvirtual

Perform the extrapolation.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 645 of file IncNavierStokes.cpp.

References m_extrapolation, Nektar::SolverUtils::UnsteadySystem::m_intSoln, and Nektar::SolverUtils::EquationSystem::m_time.

646  {
647  m_extrapolation->SubStepSaveFields(step);
648  m_extrapolation->SubStepAdvance(m_intSoln,step,m_time);
649  return false;
650  }
Nektar::SolverUtils::EquationSystem::m_time
NekDouble m_time
Current time of simulation.
Definition: EquationSystem.h:472
Nektar::IncNavierStokes::m_extrapolation
ExtrapolateSharedPtr m_extrapolation
Definition: IncNavierStokes.h:143
Nektar::SolverUtils::UnsteadySystem::m_intSoln
LibUtilities::TimeIntegrationSolutionSharedPtr m_intSoln
Definition: UnsteadySystem.h:69
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 219 of file IncNavierStokes.h.

References ASSERTL0.

220  {
221  ASSERTL0(false,"This method is not defined in this class");
222  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
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 224 of file IncNavierStokes.h.

References ASSERTL0.

225  {
226  ASSERTL0(false,"This method is not defined in this class");
227  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
void Nektar::IncNavierStokes::WriteModalEnergy ( void  )
protected

Member Data Documentation

int Nektar::IncNavierStokes::m_cflsteps
protected

dump cfl estimate

Definition at line 168 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 166 of file IncNavierStokes.h.

EquationType Nektar::IncNavierStokes::m_equationType
protected

equation type;

Definition at line 175 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 143 of file IncNavierStokes.h.

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

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

Mapping from BCs to Elmt IDs.

Definition at line 178 of file IncNavierStokes.h.

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

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

Mapping from BCs to Elmt Edge IDs.

Definition at line 180 of file IncNavierStokes.h.

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

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

RHS Factor for Radiation Condition.

Definition at line 182 of file IncNavierStokes.h.

Referenced by SetRadiationBoundaryForcing(), and v_InitObject().

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

Forcing terms.

Definition at line 152 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 186 of file IncNavierStokes.h.

NekDouble Nektar::IncNavierStokes::m_kinvis
protected

Kinematic viscosity.

Definition at line 164 of file IncNavierStokes.h.

Referenced by Nektar::VCSMapping::ApplyIncNSMappingForcing(), Nektar::CoupledLinearNS::Continuation(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), 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::VelocityCorrectionScheme::v_SetUpViscousForcing(), Nektar::VCSMapping::v_SolveViscous(), and Nektar::VelocityCorrectionScheme::v_SolveViscous().

std::ofstream Nektar::IncNavierStokes::m_mdlFile
protected

modal energy file

Definition at line 146 of file IncNavierStokes.h.

int Nektar::IncNavierStokes::m_nConvectiveFields
protected

Number of fields to be convected;.

Definition at line 155 of file IncNavierStokes.h.

Referenced by Nektar::VCSMapping::ApplyIncNSMappingForcing(), EvaluateAdvectionTerms(), GetNConvectiveFields(), Nektar::VCSMapping::MappingAccelerationCorrection(), Nektar::VCSMapping::MappingAdvectionCorrection(), Nektar::VCSMapping::MappingPressureCorrection(), Nektar::VelocityCorrectionScheme::SolveUnsteadyStokesSystem(), Nektar::CoupledLinearNS::SolveUnsteadyStokesSystem(), Nektar::VCSMapping::v_DoInitialise(), Nektar::VelocityCorrectionScheme::v_DoInitialise(), Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs(), Nektar::VelocityCorrectionScheme::v_EvaluateAdvection_SetPressureBCs(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), Nektar::VCSMapping::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SolvePressure(), Nektar::VCSMapping::v_SolveViscous(), and Nektar::VelocityCorrectionScheme::v_SolveViscous().

MultiRegions::ExpListSharedPtr Nektar::IncNavierStokes::m_pressure
protected

Pointer to field holding pressure field.

Definition at line 162 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::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 149 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 170 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 172 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 159 of file IncNavierStokes.h.

Referenced by Nektar::CoupledLinearNS::Continuation(), Nektar::CoupledLinearNS::DefineForcingTerm(), EvaluateAdvectionTerms(), Nektar::CoupledLinearNS::EvaluateNewtonRHS(), GetElmtCFLVals(), GetVelocity(), Nektar::CoupledLinearNS::InfNorm(), Nektar::CoupledLinearNS::L2Norm(), SetRadiationBoundaryForcing(), Nektar::CoupledLinearNS::SetUpCoupledMatrix(), SetZeroNormalVelocity(), Nektar::CoupledLinearNS::Solve(), Nektar::CoupledLinearNS::SolveLinearNS(), Nektar::CoupledLinearNS::SolveSteadyNavierStokes(), Nektar::CoupledLinearNS::SolveUnsteadyStokesSystem(), Nektar::CoupledLinearNS::v_DoInitialise(), v_GetFluxVector(), Nektar::VelocityCorrectionScheme::v_InitObject(), Nektar::VCSMapping::v_InitObject(), v_InitObject(), Nektar::CoupledLinearNS::v_InitObject(), v_NumericalFlux(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Nektar::VCSMapping::v_SetUpViscousForcing(), and Nektar::VelocityCorrectionScheme::v_SetUpViscousForcing().

Generated on Wed Mar 23 2016 20:14:28 for Nektar++ by   doxygen 1.8.8