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

#include <VCSMapping.h>

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

Public Member Functions

 VCSMapping (const LibUtilities::SessionReaderSharedPtr &pSession)
 Constructor. More...
 
void ApplyIncNSMappingForcing (Array< OneD, Array< OneD, NekDouble > > &outarray)
 
virtual ~VCSMapping ()
 
virtual void v_InitObject ()
 Init object for UnsteadySystem class. More...
 
- Public Member Functions inherited from Nektar::VelocityCorrectionScheme
 VelocityCorrectionScheme (const LibUtilities::SessionReaderSharedPtr &pSession)
 Constructor. More...
 
virtual ~VelocityCorrectionScheme ()
 
void SetUpPressureForcing (const Array< OneD, const Array< OneD, NekDouble > > &fields, Array< OneD, Array< OneD, NekDouble > > &Forcing, const NekDouble aii_Dt)
 
void SetUpViscousForcing (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &Forcing, const NekDouble aii_Dt)
 
void SolvePressure (const Array< OneD, NekDouble > &Forcing)
 
void SolveViscous (const Array< OneD, const Array< OneD, NekDouble > > &Forcing, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble aii_Dt)
 
void SolveUnsteadyStokesSystem (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time, const NekDouble a_iixDt)
 
void EvaluateAdvection_SetPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 
- Public Member Functions inherited from Nektar::IncNavierStokes
virtual ~IncNavierStokes ()
 
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...
 

Static Public Member Functions

static
SolverUtils::EquationSystemSharedPtr 		create (const LibUtilities::SessionReaderSharedPtr &pSession)
 Creates an instance of this class. More...
 
- Static Public Member Functions inherited from Nektar::VelocityCorrectionScheme
static
SolverUtils::EquationSystemSharedPtr 		create (const LibUtilities::SessionReaderSharedPtr &pSession)
 Creates an instance of this class. More...
 

Static Public Attributes

static std::string className
 Name of class. More...
 
- Static Public Attributes inherited from Nektar::VelocityCorrectionScheme
static std::string className
 Name of class. More...
 

Protected Member Functions

virtual void v_DoInitialise (void)
 Sets up initial conditions. More...
 
virtual void v_SetUpPressureForcing (const Array< OneD, const Array< OneD, NekDouble > > &fields, Array< OneD, Array< OneD, NekDouble > > &Forcing, const NekDouble aii_Dt)
 
virtual void v_SetUpViscousForcing (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &Forcing, const NekDouble aii_Dt)
 
virtual void v_SolvePressure (const Array< OneD, NekDouble > &Forcing)
 
virtual void v_SolveViscous (const Array< OneD, const Array< OneD, NekDouble > > &Forcing, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble aii_Dt)
 
virtual void v_EvaluateAdvection_SetPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 
- Protected Member Functions inherited from Nektar::VelocityCorrectionScheme
virtual void v_GenerateSummary (SolverUtils::SummaryList &s)
 Print a summary of time stepping parameters. More...
 
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 Array< OneD, bool > v_GetSystemSingularChecks ()
 
virtual int v_GetForceDimension ()
 
- Protected Member Functions inherited from Nektar::IncNavierStokes
 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 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_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

GlobalMapping::MappingSharedPtr m_mapping
 
bool m_verbose
 
bool m_implicitPressure
 
bool m_implicitViscous
 
bool m_neglectViscous
 
NekDouble m_pressureTolerance
 
NekDouble m_viscousTolerance
 
NekDouble m_pressureRelaxation
 
NekDouble m_viscousRelaxation
 
Array< OneD, Array< OneD,
NekDouble > > 		m_gradP
 
- Protected Attributes inherited from Nektar::VelocityCorrectionScheme
bool m_useHomo1DSpecVanVisc
 bool to identify if spectral vanishing viscosity is active. More...
 
bool m_useSpecVanVisc
 bool to identify if spectral vanishing viscosity is active. More...
 
NekDouble m_sVVCutoffRatio
 cutt off ratio from which to start decayhing modes More...
 
NekDouble m_sVVDiffCoeff
 Diffusion coefficient of SVV modes. More...
 
Array< OneD, NekDouble > m_saved_aii_Dt
 Save aiiDt value to use as a trip to reset global matrix setup. More...
 
StdRegions::VarCoeffMap m_varCoeffLap
 Variable Coefficient map for the Laplacian which can be activated as part of SVV or otherwise. More...
 
- Protected Attributes inherited from Nektar::IncNavierStokes
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...
 

Private Member Functions

void MappingAdvectionCorrection (const Array< OneD, Array< OneD, NekDouble > > &velPhys, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
void MappingAccelerationCorrection (const Array< OneD, Array< OneD, NekDouble > > &vel, const Array< OneD, Array< OneD, NekDouble > > &velPhys, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
void MappingPressureCorrection (Array< OneD, Array< OneD, NekDouble > > &outarray)
 
void MappingViscousCorrection (const Array< OneD, Array< OneD, NekDouble > > &velPhys, Array< OneD, Array< OneD, NekDouble > > &outarray)
 

Private Attributes

Array< OneD, Array< OneD,
NekDouble > > 		m_presForcingCorrection
 

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

Definition at line 44 of file VCSMapping.h.

Constructor & Destructor Documentation

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

Constructor.

Constructor. Creates ...

Parameters
param

Definition at line 55 of file VCSMapping.cpp.

57  : UnsteadySystem(pSession),
58  VelocityCorrectionScheme(pSession)
59  {
60 
61  }
Nektar::VelocityCorrectionScheme::VelocityCorrectionScheme
VelocityCorrectionScheme(const LibUtilities::SessionReaderSharedPtr &pSession)
Constructor.
Definition: VelocityCorrectionScheme.cpp:55
Nektar::SolverUtils::UnsteadySystem::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession)
Initialises UnsteadySystem class members.
Definition: UnsteadySystem.cpp:65
Nektar::VCSMapping::~VCSMapping ( void  )
virtual

Destructor

Definition at line 141 of file VCSMapping.cpp.

142  {
143  }

Member Function Documentation

void Nektar::VCSMapping::ApplyIncNSMappingForcing ( Array< OneD, Array< OneD, NekDouble > > &  outarray)

Explicit terms of the mapping

Definition at line 739 of file VCSMapping.cpp.

References Nektar::SolverUtils::EquationSystem::m_fields, m_implicitPressure, m_implicitViscous, Nektar::IncNavierStokes::m_kinvis, m_mapping, Nektar::IncNavierStokes::m_nConvectiveFields, m_neglectViscous, MappingAccelerationCorrection(), MappingAdvectionCorrection(), MappingPressureCorrection(), MappingViscousCorrection(), Vmath::Smul(), Vmath::Vadd(), and Vmath::Vcopy().

Referenced by v_EvaluateAdvection_SetPressureBCs().

741  {
742  int physTot = m_fields[0]->GetTotPoints();
743  Array<OneD, Array<OneD, NekDouble> > vel(m_nConvectiveFields);
744  Array<OneD, Array<OneD, NekDouble> > velPhys(m_nConvectiveFields);
745  Array<OneD, Array<OneD, NekDouble> > Forcing(m_nConvectiveFields);
746  Array<OneD, Array<OneD, NekDouble> > tmp(m_nConvectiveFields);
747  for (int i = 0; i < m_nConvectiveFields; ++i)
748  {
749  velPhys[i] = Array<OneD, NekDouble> (physTot, 0.0);
750  Forcing[i] = Array<OneD, NekDouble> (physTot, 0.0);
751  tmp[i] = Array<OneD, NekDouble> (physTot, 0.0);
752  }
753 
754  // Get fields and store velocity in wavespace and physical space
755  if(m_fields[0]->GetWaveSpace())
756  {
757  for (int i = 0; i < m_nConvectiveFields; ++i)
758  {
759  vel[i] = m_fields[i]->GetPhys();
760  m_fields[0]->HomogeneousBwdTrans(vel[i],velPhys[i]);
761  }
762  }
763  else
764  {
765  for (int i = 0; i < m_nConvectiveFields; ++i)
766  {
767  vel[i] = m_fields[i]->GetPhys();
768  Vmath::Vcopy(physTot, m_fields[i]->GetPhys(), 1, velPhys[i], 1);
769  }
770  }
771 
772  //Advection contribution
773  MappingAdvectionCorrection(velPhys, Forcing);
774 
775  // Time-derivative contribution
776  if ( m_mapping->IsTimeDependent() )
777  {
778  MappingAccelerationCorrection(vel, velPhys, tmp);
779  for (int i = 0; i < m_nConvectiveFields; ++i)
780  {
781  Vmath::Vadd(physTot, tmp[i], 1, Forcing[i], 1, Forcing[i], 1);
782  }
783  }
784 
785  // Pressure contribution
786  if (!m_implicitPressure)
787  {
788  MappingPressureCorrection(tmp);
789  for (int i = 0; i < m_nConvectiveFields; ++i)
790  {
791  Vmath::Vadd(physTot, tmp[i], 1, Forcing[i], 1, Forcing[i], 1);
792  }
793  }
794  // Viscous contribution
795  if ( (!m_implicitViscous) && (!m_neglectViscous))
796  {
797  MappingViscousCorrection(velPhys, tmp);
798  for (int i = 0; i < m_nConvectiveFields; ++i)
799  {
800  Vmath::Smul(physTot, m_kinvis, tmp[i], 1, tmp[i], 1);
801  Vmath::Vadd(physTot, tmp[i], 1, Forcing[i], 1, Forcing[i], 1);
802  }
803  }
804 
805  // If necessary, transform to wavespace
806  if(m_fields[0]->GetWaveSpace())
807  {
808  for (int i = 0; i < m_nConvectiveFields; ++i)
809  {
810  m_fields[0]->HomogeneousFwdTrans(Forcing[i],Forcing[i]);
811  }
812  }
813 
814  // Add to outarray
815  for (int i = 0; i < m_nConvectiveFields; ++i)
816  {
817  Vmath::Vadd(physTot, outarray[i], 1, Forcing[i], 1, outarray[i], 1);
818  }
819  }
Nektar::IncNavierStokes::m_kinvis
NekDouble m_kinvis
Kinematic viscosity.
Definition: IncNavierStokes.h:164
Nektar::VCSMapping::MappingAccelerationCorrection
void MappingAccelerationCorrection(const Array< OneD, Array< OneD, NekDouble > > &vel, const Array< OneD, Array< OneD, NekDouble > > &velPhys, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: VCSMapping.cpp:846
Nektar::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
Nektar::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Nektar::VCSMapping::MappingViscousCorrection
void MappingViscousCorrection(const Array< OneD, Array< OneD, NekDouble > > &velPhys, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: VCSMapping.cpp:952
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:199
Nektar::VCSMapping::MappingAdvectionCorrection
void MappingAdvectionCorrection(const Array< OneD, Array< OneD, NekDouble > > &velPhys, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: VCSMapping.cpp:821
Nektar::VCSMapping::MappingPressureCorrection
void MappingPressureCorrection(Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: VCSMapping.cpp:925
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:285
static SolverUtils::EquationSystemSharedPtr Nektar::VCSMapping::create ( const LibUtilities::SessionReaderSharedPtr &  pSession)
inlinestatic

Creates an instance of this class.

Definition at line 49 of file VCSMapping.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

50  {
51  SolverUtils::EquationSystemSharedPtr p =
52  MemoryManager<VCSMapping>::
53  AllocateSharedPtr(pSession);
54  p->InitObject();
55  return p;
56  }
Nektar::MemoryManager::AllocateSharedPtr
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:235
Nektar::SolverUtils::EquationSystemSharedPtr
boost::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.
Definition: EquationSystem.h:56
void Nektar::VCSMapping::MappingAccelerationCorrection ( const Array< OneD, Array< OneD, NekDouble > > &  vel,
const Array< OneD, Array< OneD, NekDouble > > &  velPhys,
Array< OneD, Array< OneD, NekDouble > > &  outarray 
)
private

Definition at line 846 of file VCSMapping.cpp.

References Nektar::MultiRegions::DirCartesianMap, Nektar::SolverUtils::EquationSystem::m_fields, m_mapping, Nektar::IncNavierStokes::m_nConvectiveFields, Vmath::Neg(), Vmath::Vadd(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by ApplyIncNSMappingForcing().

850  {
851  int physTot = m_fields[0]->GetTotPoints();
852  int nvel = m_nConvectiveFields;
853 
854  Array<OneD, Array<OneD, NekDouble> > wk(nvel*nvel);
855  Array<OneD, Array<OneD, NekDouble> > tmp(nvel);
856  Array<OneD, Array<OneD, NekDouble> > coordVel(nvel);
857  for (int i = 0; i< nvel; i++)
858  {
859  tmp[i] = Array<OneD, NekDouble> (physTot, 0.0);
860  coordVel[i] = Array<OneD, NekDouble> (physTot, 0.0);
861  }
862  // Get coordinates velocity in transformed system
863  m_mapping->GetCoordVelocity(tmp);
864  m_mapping->ContravarFromCartesian(tmp, coordVel);
865 
866  // Calculate first term: U^j u^i,j = U^j (du^i/dx^j + {i,kj}u^k)
867  m_mapping->ApplyChristoffelContravar(velPhys, wk);
868  for (int i=0; i< nvel; i++)
869  {
870  Vmath::Zero(physTot,outarray[i],1);
871 
872  m_fields[0]->PhysDeriv(velPhys[i], tmp[0], tmp[1]);
873  for (int j=0; j< nvel; j++)
874  {
875  if (j == 2)
876  {
877  m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[j],
878  vel[i], tmp[2]);
879  if (m_fields[0]->GetWaveSpace())
880  {
881  m_fields[0]->HomogeneousBwdTrans(tmp[2],tmp[2]);
882  }
883  }
884 
885  Vmath::Vadd(physTot,wk[i*nvel+j],1,tmp[j],1,
886  wk[i*nvel+j], 1);
887 
888  Vmath::Vvtvp(physTot, coordVel[j], 1, wk[i*nvel+j], 1,
889  outarray[i], 1, outarray[i], 1);
890  }
891  }
892 
893  // Set wavespace to false and store current value
894  bool wavespace = m_fields[0]->GetWaveSpace();
895  m_fields[0]->SetWaveSpace(false);
896 
897  // Add -u^j U^i,j
898  m_mapping->ApplyChristoffelContravar(coordVel, wk);
899  for (int i=0; i< nvel; i++)
900  {
901  if(nvel == 2)
902  {
903  m_fields[0]->PhysDeriv(coordVel[i], tmp[0], tmp[1]);
904  }
905  else
906  {
907  m_fields[0]->PhysDeriv(coordVel[i], tmp[0], tmp[1], tmp[2]);
908  }
909 
910  for (int j=0; j< nvel; j++)
911  {
912  Vmath::Vadd(physTot,wk[i*nvel+j],1,tmp[j],1,
913  wk[i*nvel+j], 1);
914  Vmath::Neg(physTot, wk[i*nvel+j], 1);
915 
916  Vmath::Vvtvp(physTot, velPhys[j], 1, wk[i*nvel+j], 1,
917  outarray[i], 1, outarray[i], 1);
918  }
919  }
920 
921  // Restore value of wavespace
922  m_fields[0]->SetWaveSpace(wavespace);
923  }
Nektar::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
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::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Vmath::Neg
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
Nektar::MultiRegions::DirCartesianMap
MultiRegions::Direction const DirCartesianMap[]
Definition: ExpList.h:86
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:359
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:285
void Nektar::VCSMapping::MappingAdvectionCorrection ( const Array< OneD, Array< OneD, NekDouble > > &  velPhys,
Array< OneD, Array< OneD, NekDouble > > &  outarray 
)
private

Definition at line 821 of file VCSMapping.cpp.

References Nektar::SolverUtils::EquationSystem::m_fields, m_mapping, Nektar::IncNavierStokes::m_nConvectiveFields, Vmath::Neg(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by ApplyIncNSMappingForcing().

824  {
825  int physTot = m_fields[0]->GetTotPoints();
826  int nvel = m_nConvectiveFields;
827 
828  Array<OneD, Array<OneD, NekDouble> > wk(nvel*nvel);
829 
830  // Apply Christoffel symbols to obtain {i,kj}vel(k)
831  m_mapping->ApplyChristoffelContravar(velPhys, wk);
832 
833  // Calculate correction -U^j*{i,kj}vel(k)
834  for (int i = 0; i< nvel; i++)
835  {
836  Vmath::Zero(physTot,outarray[i],1);
837  for (int j = 0; j< nvel; j++)
838  {
839  Vmath::Vvtvp(physTot,wk[i*nvel+j],1,velPhys[j],1,
840  outarray[i],1,outarray[i],1);
841  }
842  Vmath::Neg(physTot, outarray[i], 1);
843  }
844  }
Nektar::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
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::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Vmath::Neg
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:359
void Nektar::VCSMapping::MappingPressureCorrection ( Array< OneD, Array< OneD, NekDouble > > &  outarray)
private

Definition at line 925 of file VCSMapping.cpp.

References Nektar::SolverUtils::EquationSystem::m_fields, m_gradP, m_mapping, Nektar::IncNavierStokes::m_nConvectiveFields, Vmath::Vdiv(), and Vmath::Vsub().

Referenced by ApplyIncNSMappingForcing().

927  {
928  int physTot = m_fields[0]->GetTotPoints();
929  int nvel = m_nConvectiveFields;
930 
931  // Calculate g^(ij)p_(,j)
932  m_mapping->RaiseIndex(m_gradP, outarray);
933 
934  // Calculate correction = (nabla p)/J - g^(ij)p_,j
935  // (Jac is not required if it is constant)
936  if ( !m_mapping->HasConstantJacobian())
937  {
938  Array<OneD, NekDouble> Jac(physTot, 0.0);
939  m_mapping->GetJacobian(Jac);
940  for(int i = 0; i < nvel; ++i)
941  {
942  Vmath::Vdiv(physTot, m_gradP[i], 1, Jac, 1, m_gradP[i], 1);
943  }
944  }
945  for(int i = 0; i < nvel; ++i)
946  {
947  Vmath::Vsub(physTot, m_gradP[i], 1,outarray[i], 1,
948  outarray[i],1);
949  }
950  }
Nektar::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
Vmath::Vdiv
void Vdiv(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:227
Nektar::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Nektar::VCSMapping::m_gradP
Array< OneD, Array< OneD, NekDouble > > m_gradP
Definition: VCSMapping.h:92
Vmath::Vsub
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:329
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
void Nektar::VCSMapping::MappingViscousCorrection ( const Array< OneD, Array< OneD, NekDouble > > &  velPhys,
Array< OneD, Array< OneD, NekDouble > > &  outarray 
)
private

Definition at line 952 of file VCSMapping.cpp.

References m_mapping.

Referenced by ApplyIncNSMappingForcing().

955  {
956  // L(U) - 1.0*d^2(u^i)/dx^jdx^j
957  m_mapping->VelocityLaplacian(velPhys, outarray, 1.0);
958  }
Nektar::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
void Nektar::VCSMapping::v_DoInitialise ( void  )
protectedvirtual

Sets up initial conditions.

Sets the initial conditions.

Reimplemented from Nektar::VelocityCorrectionScheme.

Definition at line 145 of file VCSMapping.cpp.

References Nektar::MultiRegions::DirCartesianMap, Nektar::SolverUtils::EquationSystem::m_fieldMetaDataMap, Nektar::SolverUtils::EquationSystem::m_fields, m_gradP, Nektar::IncNavierStokes::m_kinvis, m_mapping, Nektar::IncNavierStokes::m_nConvectiveFields, Nektar::IncNavierStokes::m_pressure, and Nektar::SolverUtils::EquationSystem::m_timestep.

146  {
147  UnsteadySystem::v_DoInitialise();
148 
149  // Set up Field Meta Data for output files
150  m_fieldMetaDataMap["Kinvis"] =
151  boost::lexical_cast<std::string>(m_kinvis);
152  m_fieldMetaDataMap["TimeStep"] =
153  boost::lexical_cast<std::string>(m_timestep);
154 
155  // Correct Dirichlet boundary conditions to account for mapping
156  m_mapping->UpdateBCs(0.0);
157  //
158  for(int i = 0; i < m_nConvectiveFields; ++i)
159  {
160  m_fields[i]->LocalToGlobal();
161  m_fields[i]->ImposeDirichletConditions(m_fields[i]->UpdateCoeffs());
162  m_fields[i]->GlobalToLocal();
163  m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
164  m_fields[i]->UpdatePhys());
165  }
166 
167  // Initialise m_gradP
168  int physTot = m_fields[0]->GetTotPoints();
169  m_gradP = Array<OneD, Array<OneD, NekDouble> >(m_nConvectiveFields);
170  for(int i = 0; i < m_nConvectiveFields; ++i)
171  {
172  m_gradP[i] = Array<OneD, NekDouble>(physTot,0.0);
173  m_pressure->PhysDeriv(MultiRegions::DirCartesianMap[i],
174  m_pressure->GetPhys(),
175  m_gradP[i]);
176  if(m_pressure->GetWaveSpace())
177  {
178  m_pressure->HomogeneousBwdTrans(m_gradP[i],m_gradP[i]);
179  }
180  }
181  }
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::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
Nektar::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Nektar::VCSMapping::m_gradP
Array< OneD, Array< OneD, NekDouble > > m_gradP
Definition: VCSMapping.h:92
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::MultiRegions::DirCartesianMap
MultiRegions::Direction const DirCartesianMap[]
Definition: ExpList.h:86
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::IncNavierStokes::m_pressure
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
Definition: IncNavierStokes.h:162
void Nektar::VCSMapping::v_EvaluateAdvection_SetPressureBCs ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protectedvirtual

Explicit part of the method - Advection, Forcing + HOPBCs

Reimplemented from Nektar::VelocityCorrectionScheme.

Definition at line 186 of file VCSMapping.cpp.

References ApplyIncNSMappingForcing(), Nektar::IncNavierStokes::EvaluateAdvectionTerms(), Nektar::IncNavierStokes::m_extrapolation, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::IncNavierStokes::m_forcing, Nektar::IncNavierStokes::m_kinvis, m_mapping, Nektar::IncNavierStokes::m_nConvectiveFields, Nektar::IncNavierStokes::m_pressure, and Nektar::IncNavierStokes::m_SmoothAdvection.

190  {
191  // Update mapping and Deal with Dirichlet boundary conditions
192  if (m_mapping->IsTimeDependent())
193  {
194  if (m_mapping->IsFromFunction())
195  {
196  // If the transformation is explicitly defined, update it here
197  // Otherwise, it will be done somewhere else (ForcingMovingBody)
198  m_mapping->UpdateMapping(time);
199  }
200  m_mapping->UpdateBCs(time);
201  }
202 
203  EvaluateAdvectionTerms(inarray, outarray);
204 
205  // Smooth advection
206  if(m_SmoothAdvection)
207  {
208  for(int i = 0; i < m_nConvectiveFields; ++i)
209  {
210  m_pressure->SmoothField(outarray[i]);
211  }
212  }
213 
214  // Add forcing terms
215  std::vector<SolverUtils::ForcingSharedPtr>::const_iterator x;
216  for (x = m_forcing.begin(); x != m_forcing.end(); ++x)
217  {
218  (*x)->Apply(m_fields, inarray, outarray, time);
219  }
220 
221  // Add mapping terms
222  ApplyIncNSMappingForcing( outarray );
223 
224  // Calculate High-Order pressure boundary conditions
225  m_extrapolation->EvaluatePressureBCs(inarray,outarray,m_kinvis);
226  }
Nektar::VCSMapping::ApplyIncNSMappingForcing
void ApplyIncNSMappingForcing(Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: VCSMapping.cpp:739
Nektar::IncNavierStokes::m_kinvis
NekDouble m_kinvis
Kinematic viscosity.
Definition: IncNavierStokes.h:164
Nektar::IncNavierStokes::m_extrapolation
ExtrapolateSharedPtr m_extrapolation
Definition: IncNavierStokes.h:143
Nektar::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
Nektar::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Nektar::IncNavierStokes::m_forcing
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
Forcing terms.
Definition: IncNavierStokes.h:152
Nektar::IncNavierStokes::m_SmoothAdvection
bool m_SmoothAdvection
bool to identify if advection term smoothing is requested
Definition: IncNavierStokes.h:149
Nektar::IncNavierStokes::EvaluateAdvectionTerms
void EvaluateAdvectionTerms(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, Array< OneD, NekDouble > &wk=NullNekDouble1DArray)
Definition: IncNavierStokes.cpp:312
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::IncNavierStokes::m_pressure
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
Definition: IncNavierStokes.h:162
void Nektar::VCSMapping::v_InitObject ( )
virtual

Init object for UnsteadySystem class.

Initialization object for UnsteadySystem class.

Reimplemented from Nektar::VelocityCorrectionScheme.

Definition at line 63 of file VCSMapping.cpp.

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, >::CreateInstance(), Nektar::LibUtilities::eIMEXOrder1, Nektar::LibUtilities::eIMEXOrder2, Nektar::LibUtilities::eIMEXOrder3, Nektar::GetExtrapolateFactory(), Nektar::GlobalMapping::Mapping::Load(), Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::IncNavierStokes::m_extrapolation, Nektar::SolverUtils::EquationSystem::m_fields, m_implicitPressure, m_implicitViscous, Nektar::SolverUtils::UnsteadySystem::m_intScheme, m_mapping, m_neglectViscous, m_presForcingCorrection, Nektar::IncNavierStokes::m_pressure, m_pressureRelaxation, m_pressureTolerance, Nektar::SolverUtils::EquationSystem::m_session, Nektar::IncNavierStokes::m_velocity, m_verbose, m_viscousRelaxation, m_viscousTolerance, and Nektar::VelocityCorrectionScheme::v_InitObject().

64  {
65  VelocityCorrectionScheme::v_InitObject();
66 
67  m_mapping = GlobalMapping::Mapping::Load(m_session, m_fields);
68  ASSERTL0(m_mapping,
69  "Could not create mapping in VCSMapping.");
70 
71  std::string vExtrapolation = "Mapping";
72  m_extrapolation = GetExtrapolateFactory().CreateInstance(
73  vExtrapolation,
74  m_session,
75  m_fields,
76  m_pressure,
77  m_velocity,
78  m_advObject);
79  m_extrapolation->SubSteppingTimeIntegration(
80  m_intScheme->GetIntegrationMethod(), m_intScheme);
81  m_extrapolation->GenerateHOPBCMap();
82 
83  // Storage to extrapolate pressure forcing
84  int physTot = m_fields[0]->GetTotPoints();
85  int intSteps = 1;
86  int intMethod = m_intScheme->GetIntegrationMethod();
87  switch(intMethod)
88  {
89  case LibUtilities::eIMEXOrder1:
90  {
91  intSteps = 1;
92  }
93  break;
94  case LibUtilities::eIMEXOrder2:
95  {
96  intSteps = 2;
97  }
98  break;
99  case LibUtilities::eIMEXOrder3:
100  {
101  intSteps = 3;
102  }
103  break;
104  }
105  m_presForcingCorrection= Array<OneD, Array<OneD, NekDouble> >(intSteps);
106  for(int i = 0; i < m_presForcingCorrection.num_elements(); i++)
107  {
108  m_presForcingCorrection[i] = Array<OneD, NekDouble>(physTot,0.0);
109  }
110  m_verbose = (m_session->DefinesCmdLineArgument("verbose"))? true :false;
111 
112  // Load solve parameters related to the mapping
113  // Flags determining if pressure/viscous terms should be treated implicitly
114  m_session->MatchSolverInfo("MappingImplicitPressure","True",
115  m_implicitPressure,false);
116  m_session->MatchSolverInfo("MappingImplicitViscous","True",
117  m_implicitViscous,false);
118  m_session->MatchSolverInfo("MappingNeglectViscous","True",
119  m_neglectViscous,false);
120 
121  if (m_neglectViscous)
122  {
123  m_implicitViscous = false;
124  }
125 
126  // Tolerances and relaxation parameters for implicit terms
127  m_session->LoadParameter("MappingPressureTolerance",
128  m_pressureTolerance,1e-12);
129  m_session->LoadParameter("MappingViscousTolerance",
130  m_viscousTolerance,1e-12);
131  m_session->LoadParameter("MappingPressureRelaxation",
132  m_pressureRelaxation,1.0);
133  m_session->LoadParameter("MappingViscousRelaxation",
134  m_viscousRelaxation,1.0);
135 
136  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::VCSMapping::m_pressureTolerance
NekDouble m_pressureTolerance
Definition: VCSMapping.h:86
Nektar::SolverUtils::AdvectionSystem::m_advObject
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
Definition: AdvectionSystem.h:64
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::GetExtrapolateFactory
ExtrapolateFactory & GetExtrapolateFactory()
Definition: Extrapolate.cpp:48
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::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
Nektar::VCSMapping::m_viscousRelaxation
NekDouble m_viscousRelaxation
Definition: VCSMapping.h:89
Nektar::LibUtilities::eIMEXOrder2
IMEX 2nd order scheme using Backward Different Formula & Extrapolation.
Definition: TimeIntegrationScheme.h:82
Nektar::VCSMapping::m_presForcingCorrection
Array< OneD, Array< OneD, NekDouble > > m_presForcingCorrection
Definition: VCSMapping.h:121
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::LibUtilities::eIMEXOrder3
IMEX 3rd order scheme using Backward Different Formula & Extrapolation.
Definition: TimeIntegrationScheme.h:83
Nektar::SolverUtils::UnsteadySystem::m_intScheme
LibUtilities::TimeIntegrationWrapperSharedPtr m_intScheme
Wrapper to the time integration scheme.
Definition: UnsteadySystem.h:65
Nektar::VCSMapping::m_viscousTolerance
NekDouble m_viscousTolerance
Definition: VCSMapping.h:87
Nektar::VelocityCorrectionScheme::v_InitObject
virtual void v_InitObject()
Init object for UnsteadySystem class.
Definition: VelocityCorrectionScheme.cpp:64
Nektar::IncNavierStokes::m_pressure
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
Definition: IncNavierStokes.h:162
Nektar::LibUtilities::eIMEXOrder1
IMEX 1st order scheme using Euler Backwards/Euler Forwards.
Definition: TimeIntegrationScheme.h:81
Nektar::GlobalMapping::Mapping::Load
static GLOBAL_MAPPING_EXPORT MappingSharedPtr Load(const LibUtilities::SessionReaderSharedPtr &pSession, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
Return a pointer to the mapping, creating it on first call.
Definition: Mapping.cpp:264
Nektar::VCSMapping::m_pressureRelaxation
NekDouble m_pressureRelaxation
Definition: VCSMapping.h:88
void Nektar::VCSMapping::v_SetUpPressureForcing ( const Array< OneD, const Array< OneD, NekDouble > > &  fields,
Array< OneD, Array< OneD, NekDouble > > &  Forcing,
const NekDouble  aii_Dt 
)
protectedvirtual

Forcing term for Poisson solver solver

Reimplemented from Nektar::VelocityCorrectionScheme.

Definition at line 232 of file VCSMapping.cpp.

References Nektar::MultiRegions::DirCartesianMap, Nektar::IncNavierStokes::m_extrapolation, Nektar::SolverUtils::EquationSystem::m_fields, m_implicitViscous, Nektar::IncNavierStokes::m_kinvis, m_mapping, Nektar::IncNavierStokes::m_nConvectiveFields, m_presForcingCorrection, Vmath::Smul(), Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vdiv(), Vmath::Vmul(), Vmath::Vsub(), and Vmath::Zero().

236  {
237  if (m_mapping->HasConstantJacobian())
238  {
239  VelocityCorrectionScheme::v_SetUpPressureForcing(fields,
240  Forcing, aii_Dt);
241  }
242  else
243  {
244  int physTot = m_fields[0]->GetTotPoints();
245  int nvel = m_nConvectiveFields;
246  Array<OneD, NekDouble> wk(physTot, 0.0);
247 
248  Array<OneD, NekDouble> Jac(physTot,0.0);
249  m_mapping->GetJacobian(Jac);
250 
251  // Calculate div(J*u/Dt)
252  Vmath::Zero(physTot,Forcing[0],1);
253  for(int i = 0; i < nvel; ++i)
254  {
255  if (m_fields[i]->GetWaveSpace())
256  {
257  m_fields[i]->HomogeneousBwdTrans(fields[i],wk);
258  }
259  else
260  {
261  Vmath::Vcopy(physTot, fields[i], 1, wk, 1);
262  }
263  Vmath::Vmul(physTot,wk,1,Jac,1,wk,1);
264  if (m_fields[i]->GetWaveSpace())
265  {
266  m_fields[i]->HomogeneousFwdTrans(wk,wk);
267  }
268  m_fields[i]->PhysDeriv(MultiRegions::DirCartesianMap[i],wk, wk);
269  Vmath::Vadd(physTot,wk,1,Forcing[0],1,Forcing[0],1);
270  }
271  Vmath::Smul(physTot,1.0/aii_Dt,Forcing[0],1,Forcing[0],1);
272 
273  //
274  // If the mapping viscous terms are being treated explicitly
275  // we need to apply a correction to the forcing
276  if (!m_implicitViscous)
277  {
278  bool wavespace = m_fields[0]->GetWaveSpace();
279  m_fields[0]->SetWaveSpace(false);
280 
281  //
282  // Part 1: div(J*grad(U/J . grad(J)))
283  Array<OneD, Array<OneD, NekDouble> > tmp (nvel);
284  Array<OneD, Array<OneD, NekDouble> > velocity (nvel);
285  for(int i = 0; i < tmp.num_elements(); i++)
286  {
287  tmp[i] = Array<OneD, NekDouble>(physTot,0.0);
288  velocity[i] = Array<OneD, NekDouble>(physTot,0.0);
289  if (wavespace)
290  {
291  m_fields[0]->HomogeneousBwdTrans(m_fields[i]->GetPhys(),
292  velocity[i]);
293  }
294  else
295  {
296  Vmath::Vcopy(physTot, m_fields[i]->GetPhys(), 1,
297  velocity[i], 1);
298  }
299  }
300  // Calculate wk = U.grad(J)
301  m_mapping->DotGradJacobian(velocity, wk);
302  // Calculate wk = (U.grad(J))/J
303  Vmath::Vdiv(physTot, wk, 1, Jac, 1, wk, 1);
304  // J*grad[(U.grad(J))/J]
305  for(int i = 0; i < nvel; ++i)
306  {
307  m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[i],
308  wk, tmp[i]);
309  Vmath::Vmul(physTot, Jac, 1, tmp[i], 1, tmp[i], 1);
310  }
311  // div(J*grad[(U.grad(J))/J])
312  Vmath::Zero(physTot, wk, 1);
313  for(int i = 0; i < nvel; ++i)
314  {
315  m_fields[0]->PhysDeriv(MultiRegions::DirCartesianMap[i],
316  tmp[i], tmp[i]);
317  Vmath::Vadd(physTot, wk, 1, tmp[i], 1, wk, 1);
318  }
319 
320  // Part 2: grad(J) . curl(curl(U))
321  m_mapping->CurlCurlField(velocity, tmp, m_implicitViscous);
322  // dont need velocity any more, so reuse it
323  m_mapping->DotGradJacobian(tmp, velocity[0]);
324 
325  // Add two parts
326  Vmath::Vadd(physTot, velocity[0], 1, wk, 1, wk, 1);
327 
328  // Multiply by kinvis
329  Vmath::Smul(physTot, m_kinvis, wk, 1, wk, 1);
330 
331  // Extrapolate correction
332  m_extrapolation->ExtrapolateArray(m_presForcingCorrection,
333  wk, wk);
334 
335  // Put in wavespace
336  if (wavespace)
337  {
338  m_fields[0]->HomogeneousFwdTrans(wk,wk);
339  }
340  // Apply correction: Forcing = Forcing - correction
341  Vmath::Vsub(physTot, Forcing[0], 1, wk, 1, Forcing[0], 1);
342 
343  m_fields[0]->SetWaveSpace(wavespace);
344  }
345  }
346  }
Nektar::IncNavierStokes::m_kinvis
NekDouble m_kinvis
Kinematic viscosity.
Definition: IncNavierStokes.h:164
Nektar::IncNavierStokes::m_extrapolation
ExtrapolateSharedPtr m_extrapolation
Definition: IncNavierStokes.h:143
Nektar::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
Vmath::Vdiv
void Vdiv(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:227
Nektar::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:199
Nektar::VCSMapping::m_presForcingCorrection
Array< OneD, Array< OneD, NekDouble > > m_presForcingCorrection
Definition: VCSMapping.h:121
Vmath::Vsub
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:329
Nektar::MultiRegions::DirCartesianMap
MultiRegions::Direction const DirCartesianMap[]
Definition: ExpList.h:86
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:359
Nektar::VelocityCorrectionScheme::v_SetUpPressureForcing
virtual void v_SetUpPressureForcing(const Array< OneD, const Array< OneD, NekDouble > > &fields, Array< OneD, Array< OneD, NekDouble > > &Forcing, const NekDouble aii_Dt)
Definition: VelocityCorrectionScheme.cpp:368
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:285
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::VCSMapping::v_SetUpViscousForcing ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  Forcing,
const NekDouble  aii_Dt 
)
protectedvirtual

Forcing term for Helmholtz solver

Reimplemented from Nektar::VelocityCorrectionScheme.

Definition at line 351 of file VCSMapping.cpp.

References Nektar::SolverUtils::EquationSystem::m_fields, m_gradP, m_implicitPressure, Nektar::IncNavierStokes::m_kinvis, m_mapping, Nektar::IncNavierStokes::m_pressure, Nektar::IncNavierStokes::m_velocity, Vmath::Vcopy(), and Vmath::Vdiv().

355  {
356  NekDouble aii_dtinv = 1.0/aii_Dt;
357  int physTot = m_fields[0]->GetTotPoints();
358 
359  // Grad p
360  m_pressure->BwdTrans(m_pressure->GetCoeffs(),m_pressure->UpdatePhys());
361 
362  int nvel = m_velocity.num_elements();
363  if(nvel == 2)
364  {
365  m_pressure->PhysDeriv(m_pressure->GetPhys(), Forcing[0], Forcing[1]);
366  }
367  else
368  {
369  m_pressure->PhysDeriv(m_pressure->GetPhys(), Forcing[0], Forcing[1],
370  Forcing[2]);
371  }
372 
373  // Copy grad p in physical space to m_gradP to reuse later
374  if (m_pressure->GetWaveSpace())
375  {
376  for (int i=0; i<nvel; i++)
377  {
378  m_pressure->HomogeneousBwdTrans(Forcing[i],m_gradP[i]);
379  }
380  }
381  else
382  {
383  for (int i=0; i<nvel; i++)
384  {
385  Vmath::Vcopy(physTot, Forcing[i], 1, m_gradP[i], 1);
386  }
387  }
388 
389  if ( (!m_mapping->HasConstantJacobian()) || m_implicitPressure)
390  {
391  // If pressure terms are treated explicitly, we need to divide by J
392  // if they are implicit, we need to calculate G(p)
393  if (m_implicitPressure)
394  {
395  m_mapping->RaiseIndex(m_gradP, Forcing);
396  }
397  else
398  {
399  Array<OneD, NekDouble> Jac(physTot,0.0);
400  m_mapping->GetJacobian(Jac);
401  for (int i=0; i<nvel; i++)
402  {
403  Vmath::Vdiv(physTot, m_gradP[i], 1, Jac, 1, Forcing[i], 1);
404  }
405  }
406  // Transform back to wavespace
407  if (m_pressure->GetWaveSpace())
408  {
409  for (int i=0; i<nvel; i++)
410  {
411  m_pressure->HomogeneousFwdTrans(Forcing[i],Forcing[i]);
412  }
413  }
414  }
415 
416  // Subtract inarray/(aii_dt) and divide by kinvis. Kinvis will
417  // need to be updated for the convected fields.
418  for(int i = 0; i < nvel; ++i)
419  {
420  Blas::Daxpy(physTot,-aii_dtinv,inarray[i],1,Forcing[i],1);
421  Blas::Dscal(physTot,1.0/m_kinvis,&(Forcing[i])[0],1);
422  }
423  }
Nektar::IncNavierStokes::m_kinvis
NekDouble m_kinvis
Kinematic viscosity.
Definition: IncNavierStokes.h:164
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::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
Vmath::Vdiv
void Vdiv(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:227
Nektar::VCSMapping::m_gradP
Array< OneD, Array< OneD, NekDouble > > m_gradP
Definition: VCSMapping.h:92
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::IncNavierStokes::m_pressure
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
Definition: IncNavierStokes.h:162
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
void Nektar::VCSMapping::v_SolvePressure ( const Array< OneD, NekDouble > &  Forcing)
protectedvirtual

Solve pressure system

Reimplemented from Nektar::VelocityCorrectionScheme.

Definition at line 428 of file VCSMapping.cpp.

References ASSERTL0, Nektar::MultiRegions::DirCartesianMap, Nektar::StdRegions::eFactorLambda, Nektar::IncNavierStokes::m_extrapolation, Nektar::SolverUtils::EquationSystem::m_fields, m_implicitPressure, m_mapping, Nektar::IncNavierStokes::m_nConvectiveFields, Nektar::IncNavierStokes::m_pressure, m_pressureRelaxation, m_pressureTolerance, Nektar::SolverUtils::EquationSystem::m_session, m_verbose, Vmath::Neg(), Nektar::NullFlagList, Vmath::Smul(), Nektar::VelocityCorrectionScheme::v_SolvePressure(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vmul(), and Vmath::Vsub().

430  {
431  if (!m_implicitPressure)
432  {
433  VelocityCorrectionScheme::v_SolvePressure(Forcing);
434  }
435  else
436  {
437  int physTot = m_fields[0]->GetTotPoints();
438  int nvel = m_nConvectiveFields;
439  bool converged = false; // flag to mark if system converged
440  int s = 0; // iteration counter
441  NekDouble error; // L2 error at current iteration
442  NekDouble forcing_L2 = 0.0; // L2 norm of F
443 
444  int maxIter;
445  m_session->LoadParameter("MappingMaxIter",maxIter,5000);
446 
447  // rhs of the equation at current iteration
448  Array< OneD, NekDouble> F_corrected(physTot, 0.0);
449  // Pressure field at previous iteration
450  Array<OneD, NekDouble> previous_iter (physTot, 0.0);
451  // Temporary variables
452  Array<OneD, Array<OneD, NekDouble> > wk1(nvel);
453  Array<OneD, Array<OneD, NekDouble> > wk2(nvel);
454  Array<OneD, Array<OneD, NekDouble> > gradP(nvel);
455  for(int i = 0; i < nvel; ++i)
456  {
457  wk1[i] = Array<OneD, NekDouble> (physTot, 0.0);
458  wk2[i] = Array<OneD, NekDouble> (physTot, 0.0);
459  gradP[i] = Array<OneD, NekDouble> (physTot, 0.0);
460  }
461 
462  // Jacobian
463  Array<OneD, NekDouble> Jac(physTot, 0.0);
464  m_mapping->GetJacobian(Jac);
465 
466  // Factors for Laplacian system
467  StdRegions::ConstFactorMap factors;
468  factors[StdRegions::eFactorLambda] = 0.0;
469 
470  m_pressure->BwdTrans(m_pressure->GetCoeffs(),
471  m_pressure->UpdatePhys());
472  forcing_L2 = m_pressure->L2(Forcing, wk1[0]);
473  while (!converged)
474  {
475  // Update iteration counter and set previous iteration field
476  // (use previous timestep solution for first iteration)
477  s++;
478  ASSERTL0(s < maxIter,
479  "VCSMapping exceeded maximum number of iterations.");
480 
481  Vmath::Vcopy(physTot, m_pressure->GetPhys(), 1,
482  previous_iter, 1);
483 
484  // Correct pressure bc to account for iteration
485  m_extrapolation->CorrectPressureBCs(previous_iter);
486 
487  //
488  // Calculate forcing term for this iteration
489  //
490  for(int i = 0; i < nvel; ++i)
491  {
492  m_pressure->PhysDeriv(MultiRegions::DirCartesianMap[i],
493  previous_iter, gradP[i]);
494  if(m_pressure->GetWaveSpace())
495  {
496  m_pressure->HomogeneousBwdTrans(gradP[i], wk1[i]);
497  }
498  else
499  {
500  Vmath::Vcopy(physTot, gradP[i], 1, wk1[i], 1);
501  }
502  }
503  m_mapping->RaiseIndex(wk1, wk2); // G(p)
504 
505  m_mapping->Divergence(wk2, F_corrected); // div(G(p))
506  if (!m_mapping->HasConstantJacobian())
507  {
508  Vmath::Vmul(physTot, F_corrected, 1,
509  Jac, 1,
510  F_corrected, 1);
511  }
512  // alpha*J*div(G(p))
513  Vmath::Smul(physTot, m_pressureRelaxation, F_corrected, 1,
514  F_corrected, 1);
515  if(m_pressure->GetWaveSpace())
516  {
517  m_pressure->HomogeneousFwdTrans(F_corrected, F_corrected);
518  }
519  // alpha*J*div(G(p)) - p_ii
520  for (int i = 0; i < m_nConvectiveFields; ++i)
521  {
522  m_pressure->PhysDeriv(MultiRegions::DirCartesianMap[i],
523  gradP[i], wk1[0]);
524  Vmath::Vsub(physTot, F_corrected, 1, wk1[0], 1,
525  F_corrected, 1);
526  }
527  // p_i,i - J*div(G(p))
528  Vmath::Neg(physTot, F_corrected, 1);
529  // alpha*F - alpha*J*div(G(p)) + p_i,i
530  Vmath::Smul(physTot, m_pressureRelaxation, Forcing, 1,
531  wk1[0], 1);
532  Vmath::Vadd(physTot, wk1[0], 1, F_corrected, 1, F_corrected, 1);
533 
534  //
535  // Solve system
536  //
537  m_pressure->HelmSolve(F_corrected, m_pressure->UpdateCoeffs(),
538  NullFlagList, factors);
539  m_pressure->BwdTrans(m_pressure->GetCoeffs(),
540  m_pressure->UpdatePhys());
541 
542  //
543  // Test convergence
544  //
545  error = m_pressure->L2(m_pressure->GetPhys(), previous_iter);
546  if ( forcing_L2 != 0)
547  {
548  if ( (error/forcing_L2 < m_pressureTolerance))
549  {
550  converged = true;
551  }
552  }
553  else
554  {
555  if ( error < m_pressureTolerance)
556  {
557  converged = true;
558  }
559  }
560  }
561  if (m_verbose && m_session->GetComm()->GetRank()==0)
562  {
563  std::cout << " Pressure system (mapping) converged in " << s <<
564  " iterations with error = " << error << std::endl;
565  }
566  }
567  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::VCSMapping::m_pressureTolerance
NekDouble m_pressureTolerance
Definition: VCSMapping.h:86
Nektar::IncNavierStokes::m_extrapolation
ExtrapolateSharedPtr m_extrapolation
Definition: IncNavierStokes.h:143
Nektar::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
Nektar::StdRegions::ConstFactorMap
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:251
Nektar::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:199
Vmath::Neg
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
Nektar::VelocityCorrectionScheme::v_SolvePressure
virtual void v_SolvePressure(const Array< OneD, NekDouble > &Forcing)
Definition: VelocityCorrectionScheme.cpp:427
Vmath::Vsub
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:329
Nektar::MultiRegions::DirCartesianMap
MultiRegions::Direction const DirCartesianMap[]
Definition: ExpList.h:86
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::IncNavierStokes::m_pressure
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
Definition: IncNavierStokes.h:162
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:285
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
Nektar::VCSMapping::m_pressureRelaxation
NekDouble m_pressureRelaxation
Definition: VCSMapping.h:88
Nektar::NullFlagList
static FlagList NullFlagList
An empty flag list.
Definition: NektarUnivTypeDefs.hpp:113
void Nektar::VCSMapping::v_SolveViscous ( const Array< OneD, const Array< OneD, NekDouble > > &  Forcing,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  aii_Dt 
)
protectedvirtual

Solve velocity system

Reimplemented from Nektar::VelocityCorrectionScheme.

Definition at line 572 of file VCSMapping.cpp.

References ASSERTL0, Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::eFactorSVVCutoffRatio, Nektar::StdRegions::eFactorSVVDiffCoeff, Nektar::SolverUtils::EquationSystem::m_fields, m_implicitViscous, Nektar::IncNavierStokes::m_kinvis, m_mapping, Nektar::IncNavierStokes::m_nConvectiveFields, Nektar::SolverUtils::EquationSystem::m_session, Nektar::VelocityCorrectionScheme::m_sVVCutoffRatio, Nektar::VelocityCorrectionScheme::m_sVVDiffCoeff, Nektar::VelocityCorrectionScheme::m_useSpecVanVisc, m_verbose, m_viscousRelaxation, m_viscousTolerance, Nektar::NullFlagList, Vmath::Smul(), Nektar::VelocityCorrectionScheme::v_SolveViscous(), Vmath::Vadd(), and Vmath::Vcopy().

576  {
577  if(!m_implicitViscous)
578  {
579  VelocityCorrectionScheme::v_SolveViscous(Forcing, outarray, aii_Dt);
580  }
581  else
582  {
583  int physTot = m_fields[0]->GetTotPoints();
584  int nvel = m_nConvectiveFields;
585  bool converged = false; // flag to mark if system converged
586  int s = 0; // iteration counter
587  NekDouble error, max_error; // L2 error at current iteration
588 
589  int maxIter;
590  m_session->LoadParameter("MappingMaxIter",maxIter,5000);
591 
592  //L2 norm of F
593  Array<OneD, NekDouble> forcing_L2(m_nConvectiveFields,0.0);
594 
595  // rhs of the equation at current iteration
596  Array<OneD, Array<OneD, NekDouble> > F_corrected(nvel);
597  // Solution at previous iteration
598  Array<OneD, Array<OneD, NekDouble> > previous_iter(nvel);
599  // Working space
600  Array<OneD, Array<OneD, NekDouble> > wk(nvel);
601  for(int i = 0; i < nvel; ++i)
602  {
603  F_corrected[i] = Array<OneD, NekDouble> (physTot, 0.0);
604  previous_iter[i] = Array<OneD, NekDouble> (physTot, 0.0);
605  wk[i] = Array<OneD, NekDouble> (physTot, 0.0);
606  }
607 
608  // Factors for Helmholtz system
609  StdRegions::ConstFactorMap factors;
610  factors[StdRegions::eFactorLambda] =
611  1.0*m_viscousRelaxation/aii_Dt/m_kinvis;
612  if(m_useSpecVanVisc)
613  {
614  factors[StdRegions::eFactorSVVCutoffRatio] = m_sVVCutoffRatio;
615  factors[StdRegions::eFactorSVVDiffCoeff] =
616  m_sVVDiffCoeff/m_kinvis;
617  }
618 
619  // Calculate L2-norm of F and set initial solution for iteration
620  for(int i = 0; i < nvel; ++i)
621  {
622  forcing_L2[i] = m_fields[0]->L2(Forcing[i],wk[0]);
623  m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
624  previous_iter[i]);
625  }
626 
627  while (!converged)
628  {
629  converged = true;
630  // Iteration counter
631  s++;
632  ASSERTL0(s < maxIter,
633  "VCSMapping exceeded maximum number of iterations.");
634 
635  max_error = 0.0;
636 
637  //
638  // Calculate forcing term for next iteration
639  //
640 
641  // Calculate L(U)- in this parts all components might be coupled
642  if(m_fields[0]->GetWaveSpace())
643  {
644  for (int i = 0; i < nvel; ++i)
645  {
646  m_fields[0]->HomogeneousBwdTrans(previous_iter[i],
647  wk[i]);
648  }
649  }
650  else
651  {
652  for (int i = 0; i < nvel; ++i)
653  {
654  Vmath::Vcopy(physTot, previous_iter[i], 1, wk[i], 1);
655  }
656  }
657 
658  // (L(U^i) - 1/alpha*U^i_jj)
659  m_mapping->VelocityLaplacian(wk, F_corrected,
660  1.0/m_viscousRelaxation);
661 
662  if(m_fields[0]->GetWaveSpace())
663  {
664  for (int i = 0; i < nvel; ++i)
665  {
666  m_fields[0]->HomogeneousFwdTrans(F_corrected[i],
667  F_corrected[i]);
668  }
669  }
670  else
671  {
672  for (int i = 0; i < nvel; ++i)
673  {
674  Vmath::Vcopy(physTot, F_corrected[i], 1,
675  F_corrected[i], 1);
676  }
677  }
678 
679  // Loop velocity components
680  for (int i = 0; i < nvel; ++i)
681  {
682  // (-alpha*L(U^i) + U^i_jj)
683  Vmath::Smul(physTot, -1.0*m_viscousRelaxation,
684  F_corrected[i], 1,
685  F_corrected[i], 1);
686  // F_corrected = alpha*F + (-alpha*L(U^i) + U^i_jj)
687  Vmath::Smul(physTot, m_viscousRelaxation, Forcing[i], 1,
688  wk[0], 1);
689  Vmath::Vadd(physTot, wk[0], 1, F_corrected[i], 1,
690  F_corrected[i], 1);
691 
692  //
693  // Solve System
694  //
695  m_fields[i]->HelmSolve(F_corrected[i],
696  m_fields[i]->UpdateCoeffs(),
697  NullFlagList, factors);
698  m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),outarray[i]);
699 
700  //
701  // Test convergence
702  //
703  error = m_fields[i]->L2(outarray[i], previous_iter[i]);
704 
705  if ( forcing_L2[i] != 0)
706  {
707  if ( (error/forcing_L2[i] >= m_viscousTolerance))
708  {
709  converged = false;
710  }
711  }
712  else
713  {
714  if ( error >= m_viscousTolerance)
715  {
716  converged = false;
717  }
718  }
719  if (error > max_error)
720  {
721  max_error = error;
722  }
723 
724  // Copy field to previous_iter
725  Vmath::Vcopy(physTot, outarray[i], 1, previous_iter[i], 1);
726  }
727  }
728  if (m_verbose && m_session->GetComm()->GetRank()==0)
729  {
730  std::cout << " Velocity system (mapping) converged in " << s <<
731  " iterations with error = " << max_error << std::endl;
732  }
733  }
734  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::IncNavierStokes::m_kinvis
NekDouble m_kinvis
Kinematic viscosity.
Definition: IncNavierStokes.h:164
Nektar::VelocityCorrectionScheme::m_sVVDiffCoeff
NekDouble m_sVVDiffCoeff
Diffusion coefficient of SVV modes.
Definition: VelocityCorrectionScheme.h:119
Nektar::VCSMapping::m_mapping
GlobalMapping::MappingSharedPtr m_mapping
Definition: VCSMapping.h:75
Nektar::StdRegions::ConstFactorMap
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:251
Nektar::IncNavierStokes::m_nConvectiveFields
int m_nConvectiveFields
Number of fields to be convected;.
Definition: IncNavierStokes.h:155
Nektar::VCSMapping::m_viscousRelaxation
NekDouble m_viscousRelaxation
Definition: VCSMapping.h:89
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:199
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
Nektar::VelocityCorrectionScheme::v_SolveViscous
virtual void v_SolveViscous(const Array< OneD, const Array< OneD, NekDouble > > &Forcing, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble aii_Dt)
Definition: VelocityCorrectionScheme.cpp:442
Nektar::VelocityCorrectionScheme::m_sVVCutoffRatio
NekDouble m_sVVCutoffRatio
cutt off ratio from which to start decayhing modes
Definition: VelocityCorrectionScheme.h:117
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:460
Nektar::VelocityCorrectionScheme::m_useSpecVanVisc
bool m_useSpecVanVisc
bool to identify if spectral vanishing viscosity is active.
Definition: VelocityCorrectionScheme.h:115
Nektar::SolverUtils::EquationSystem::m_session
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Definition: EquationSystem.h:452
Nektar::VCSMapping::m_viscousTolerance
NekDouble m_viscousTolerance
Definition: VCSMapping.h:87
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1047
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:285
Nektar::NullFlagList
static FlagList NullFlagList
An empty flag list.
Definition: NektarUnivTypeDefs.hpp:113

Member Data Documentation

string Nektar::VCSMapping::className
static
Initial value:
=
SolverUtils::GetEquationSystemFactory().RegisterCreatorFunction(
"VCSMapping",
VCSMapping::create)

Name of class.

Definition at line 59 of file VCSMapping.h.

Array<OneD, Array<OneD, NekDouble> > Nektar::VCSMapping::m_gradP
protected

Definition at line 92 of file VCSMapping.h.

Referenced by MappingPressureCorrection(), v_DoInitialise(), and v_SetUpViscousForcing().

bool Nektar::VCSMapping::m_implicitPressure
protected

Definition at line 81 of file VCSMapping.h.

Referenced by ApplyIncNSMappingForcing(), v_InitObject(), v_SetUpViscousForcing(), and v_SolvePressure().

bool Nektar::VCSMapping::m_implicitViscous
protected

Definition at line 82 of file VCSMapping.h.

Referenced by ApplyIncNSMappingForcing(), v_InitObject(), v_SetUpPressureForcing(), and v_SolveViscous().

GlobalMapping::MappingSharedPtr Nektar::VCSMapping::m_mapping
protected

Definition at line 75 of file VCSMapping.h.

Referenced by ApplyIncNSMappingForcing(), MappingAccelerationCorrection(), MappingAdvectionCorrection(), MappingPressureCorrection(), MappingViscousCorrection(), v_DoInitialise(), v_EvaluateAdvection_SetPressureBCs(), v_InitObject(), v_SetUpPressureForcing(), v_SetUpViscousForcing(), v_SolvePressure(), and v_SolveViscous().

bool Nektar::VCSMapping::m_neglectViscous
protected

Definition at line 83 of file VCSMapping.h.

Referenced by ApplyIncNSMappingForcing(), and v_InitObject().

Array<OneD, Array<OneD, NekDouble> > Nektar::VCSMapping::m_presForcingCorrection
private

Definition at line 121 of file VCSMapping.h.

Referenced by v_InitObject(), and v_SetUpPressureForcing().

NekDouble Nektar::VCSMapping::m_pressureRelaxation
protected

Definition at line 88 of file VCSMapping.h.

Referenced by v_InitObject(), and v_SolvePressure().

NekDouble Nektar::VCSMapping::m_pressureTolerance
protected

Definition at line 86 of file VCSMapping.h.

Referenced by v_InitObject(), and v_SolvePressure().

bool Nektar::VCSMapping::m_verbose
protected

Definition at line 77 of file VCSMapping.h.

Referenced by v_InitObject(), v_SolvePressure(), and v_SolveViscous().

NekDouble Nektar::VCSMapping::m_viscousRelaxation
protected

Definition at line 89 of file VCSMapping.h.

Referenced by v_InitObject(), and v_SolveViscous().

NekDouble Nektar::VCSMapping::m_viscousTolerance
protected

Definition at line 87 of file VCSMapping.h.

Referenced by v_InitObject(), and v_SolveViscous().

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