Nektar++
Public Member Functions | Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Static Protected Attributes | Friends | List of all members
Nektar::VelocityCorrectionScheme Class Reference

#include <VelocityCorrectionScheme.h>

Inheritance diagram for Nektar::VelocityCorrectionScheme:
[legend]

Public Member Functions

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, const Array< OneD, const Array< OneD, NekDouble > > &inarray, 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
int GetNConvectiveFields (void)
 
void AddForcing (const SolverUtils::ForcingSharedPtr &pForce)
 
bool DefinedForcing (const std::string &sForce)
 
- Public Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT AdvectionSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
SOLVER_UTILS_EXPORT ~AdvectionSystem () override=default
 
SOLVER_UTILS_EXPORT AdvectionSharedPtr GetAdvObject ()
 Returns the advection object held by this instance. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleGetElmtCFLVals (const bool FlagAcousticCFL=true)
 
SOLVER_UTILS_EXPORT NekDouble GetCFLEstimate (int &elmtid)
 
- Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT ~UnsteadySystem () override=default
 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...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void SetTimeStep (const NekDouble timestep)
 
SOLVER_UTILS_EXPORT void SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeSharedPtrGetTimeIntegrationScheme ()
 Returns the time integration scheme. More...
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeOperatorsGetTimeIntegrationSchemeOperators ()
 Returns the time integration scheme operators. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise (bool dumpInitialConditions=true)
 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 std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
std::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 ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
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 SessionFunctionSharedPtr GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
 Get a SessionFunction by name. 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 NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT NekDouble H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the H1 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. 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 SessionSummary (SummaryList &vSummary)
 Write out a session summary. More...
 
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > & UpdateFields ()
 
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMapUpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTime ()
 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 GetSteps ()
 
SOLVER_UTILS_EXPORT void SetSteps (const int steps)
 
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, const Array< OneD, const NekDouble > &input)
 
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > & UpdatePhysField (const int i)
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void SetModifiedBasis (const bool modbasis)
 
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 int GetInfoSteps ()
 
SOLVER_UTILS_EXPORT void SetInfoSteps (int num)
 
SOLVER_UTILS_EXPORT void SetIterationNumberPIT (int num)
 
SOLVER_UTILS_EXPORT void SetWindowNumberPIT (int num)
 
SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > > GetTraceNormals ()
 
SOLVER_UTILS_EXPORT void SetTime (const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetTimeStep (const NekDouble timestep)
 
SOLVER_UTILS_EXPORT void SetInitialStep (const int step)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
SOLVER_UTILS_EXPORT bool NegatedOp ()
 Identify if operator is negated in DoSolve. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::ALEHelper
virtual ~ALEHelper ()=default
 
virtual SOLVER_UTILS_EXPORT void v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
 
SOLVER_UTILS_EXPORT void InitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
 
virtual SOLVER_UTILS_EXPORT void v_UpdateGridVelocity (const NekDouble &time)
 
virtual SOLVER_UTILS_EXPORT void v_ALEPreMultiplyMass (Array< OneD, Array< OneD, NekDouble > > &fields)
 
SOLVER_UTILS_EXPORT void ALEDoElmtInvMass (Array< OneD, Array< OneD, NekDouble > > &traceNormals, Array< OneD, Array< OneD, NekDouble > > &fields, NekDouble time)
 Update m_fields with u^n by multiplying by inverse mass matrix. That's then used in e.g. checkpoint output and L^2 error calculation. More...
 
SOLVER_UTILS_EXPORT void ALEDoElmtInvMassBwdTrans (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
SOLVER_UTILS_EXPORT void MoveMesh (const NekDouble &time, Array< OneD, Array< OneD, NekDouble > > &traceNormals)
 
const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocity ()
 
SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocityTrace ()
 
SOLVER_UTILS_EXPORT void ExtraFldOutputGridVelocity (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
- Public Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual ~FluidInterface ()=default
 
SOLVER_UTILS_EXPORT void GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)
 Extract array with velocity from physfield. More...
 
SOLVER_UTILS_EXPORT bool HasConstantDensity ()
 
SOLVER_UTILS_EXPORT void GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density)
 Extract array with density from physfield. More...
 
SOLVER_UTILS_EXPORT void GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)
 Extract array with pressure from physfield. More...
 
SOLVER_UTILS_EXPORT void SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step)
 
SOLVER_UTILS_EXPORT bool GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step)
 
SOLVER_UTILS_EXPORT void SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step)
 
SOLVER_UTILS_EXPORT void SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot)
 
SOLVER_UTILS_EXPORT bool GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step)
 
SOLVER_UTILS_EXPORT void SetAeroForce (Array< OneD, NekDouble > forces)
 Set aerodynamic force and moment. More...
 
SOLVER_UTILS_EXPORT void GetAeroForce (Array< OneD, NekDouble > forces)
 Get aerodynamic force and moment. More...
 

Static Public Member Functions

static SolverUtils::EquationSystemSharedPtr create (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Creates an instance of this class. More...
 

Static Public Attributes

static std::string className
 Name of class. More...
 
- Static Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
static std::string cmdSetStartTime
 
static std::string cmdSetStartChkNum
 

Protected Member Functions

 VelocityCorrectionScheme (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
 ~VelocityCorrectionScheme () override=default
 
void v_InitObject (bool DeclareField=true) override
 Initialisation object for EquationSystem. More...
 
void SetupFlowrate (NekDouble aii_dt)
 Set up the Stokes solution used to impose constant flowrate through a boundary. More...
 
NekDouble MeasureFlowrate (const Array< OneD, Array< OneD, NekDouble > > &inarray)
 Measure the volumetric flow rate through the volumetric flow rate reference surface. More...
 
bool v_PostIntegrate (int step) override
 
void v_GenerateSummary (SolverUtils::SummaryList &s) override
 Print a summary of time stepping parameters. More...
 
void v_TransCoeffToPhys (void) override
 Virtual function for transformation to physical space. More...
 
void v_TransPhysToCoeff (void) override
 Virtual function for transformation to coefficient space. More...
 
void v_DoInitialise (bool dumpInitialConditions=true) override
 Sets up initial conditions. More...
 
Array< OneD, bool > v_GetSystemSingularChecks () override
 
int v_GetForceDimension () override
 
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, const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble aii_Dt)
 
virtual void v_SolveUnsteadyStokesSystem (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time, const NekDouble a_iixDt)
 
virtual void v_EvaluateAdvection_SetPressureBCs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 
bool v_RequireFwdTrans () override
 
virtual std::string v_GetExtrapolateStr (void)
 
virtual std::string v_GetSubSteppingExtrapolateStr (const std::string &instr)
 
void SetUpSVV (void)
 
void SetUpExtrapolation (void)
 
void SVVVarDiffCoeff (const NekDouble velmag, Array< OneD, NekDouble > &diffcoeff, const Array< OneD, Array< OneD, NekDouble > > &vel=NullNekDoubleArrayOfArray)
 
void AppendSVVFactors (StdRegions::ConstFactorMap &factors, MultiRegions::VarFactorsMap &varFactorsMap)
 
void ComputeGJPNormalVelocity (const Array< OneD, const Array< OneD, NekDouble > > &inarray, StdRegions::VarCoeffMap &varcoeffs)
 
- Protected Member Functions inherited from Nektar::IncNavierStokes
 IncNavierStokes (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Constructor. More...
 
 ~IncNavierStokes () override=default
 
void v_InitObject (bool DeclareField=true) override
 Initialisation object for EquationSystem. More...
 
void v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure) override
 
void v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density) override
 
bool v_HasConstantDensity () override
 
void v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity) override
 
void v_SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step) override
 
bool v_GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step) override
 
void v_SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step) override
 
void v_SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot) override
 
bool v_GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step) override
 
void v_SetAeroForce (Array< OneD, NekDouble > forces) override
 
void v_GetAeroForce (Array< OneD, NekDouble > forces) override
 
void EvaluateAdvectionTerms (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 
void WriteModalEnergy (void)
 
void SetBoundaryConditions (NekDouble time)
 time dependent boundary conditions updating More...
 
void SetRadiationBoundaryForcing (int fieldid)
 Set Radiation forcing term. More...
 
void SetZeroNormalVelocity ()
 Set Normal Velocity Component to Zero. More...
 
void SetWomersleyBoundary (const int fldid, const int bndid)
 Set Womersley Profile if specified. More...
 
void SetUpWomersley (const int fldid, const int bndid, std::string womstr)
 Set Up Womersley details. More...
 
MultiRegions::ExpListSharedPtr v_GetPressure () override
 
void v_TransCoeffToPhys (void) override
 Virtual function for transformation to physical space. More...
 
void v_TransPhysToCoeff (void) override
 Virtual function for transformation to coefficient space. More...
 
virtual int v_GetForceDimension ()=0
 
Array< OneD, NekDoublev_GetMaxStdVelocity (const NekDouble SpeedSoundFactor) override
 
bool v_PreIntegrate (int step) override
 
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Initialisation object for EquationSystem. More...
 
SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step) override
 
virtual SOLVER_UTILS_EXPORT Array< OneD, NekDoublev_GetMaxStdVelocity (const NekDouble SpeedSoundFactor=1.0)
 
- Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises UnsteadySystem class members. More...
 
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Init object for UnsteadySystem class. More...
 
SOLVER_UTILS_EXPORT void v_DoSolve () override
 Solves an unsteady problem. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintStatusInformation (const int step, const NekDouble cpuTime)
 Print Status Information. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintSummaryStatistics (const NekDouble intTime)
 Print Summary Statistics. More...
 
SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true) override
 Sets up initial conditions. More...
 
SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &s) override
 Print a summary of time stepping parameters. More...
 
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_PreIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_RequireFwdTrans ()
 
virtual SOLVER_UTILS_EXPORT void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
virtual SOLVER_UTILS_EXPORT bool v_UpdateTimeStepCheck ()
 
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control. More...
 
SOLVER_UTILS_EXPORT void CheckForRestartTime (NekDouble &time, int &nchk)
 
SOLVER_UTILS_EXPORT void SVVVarDiffCoeff (const Array< OneD, Array< OneD, NekDouble > > vel, StdRegions::VarCoeffMap &varCoeffMap)
 Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h time velocity. More...
 
SOLVER_UTILS_EXPORT void DoDummyProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Perform dummy projection. More...
 
- Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises EquationSystem class members. More...
 
virtual SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareFeld=true)
 Initialisation object for EquationSystem. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true)
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Virtual function for solve implementation. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Virtual function for the L_inf error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the L_2 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the H_1 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys ()
 Virtual function for transformation to physical space. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space. More...
 
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &l)
 Virtual function for generating summary information. More...
 
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure (void)
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp (void)
 Virtual function to identify if operator is negated in DoSolve. More...
 
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
virtual SOLVER_UTILS_EXPORT void v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)=0
 
virtual SOLVER_UTILS_EXPORT bool v_HasConstantDensity ()=0
 
virtual SOLVER_UTILS_EXPORT void v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density)=0
 
virtual SOLVER_UTILS_EXPORT void v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)=0
 
virtual SOLVER_UTILS_EXPORT void v_SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step)
 
virtual SOLVER_UTILS_EXPORT bool v_GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step)
 
virtual SOLVER_UTILS_EXPORT void v_SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step)
 
virtual SOLVER_UTILS_EXPORT void v_SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot)
 
virtual SOLVER_UTILS_EXPORT bool v_GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step)
 
virtual SOLVER_UTILS_EXPORT void v_SetAeroForce (Array< OneD, NekDouble > forces)
 
virtual SOLVER_UTILS_EXPORT void v_GetAeroForce (Array< OneD, NekDouble > forces)
 

Protected Attributes

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...
 
bool m_useGJPStabilisation
 bool to identify if GJP semi-implicit is active. More...
 
bool m_useGJPNormalVel
 bool to identify if GJP normal Velocity should be applied in explicit approach More...
 
NekDouble m_GJPJumpScale
 
NekDouble m_sVVCutoffRatio
 cutt off ratio from which to start decayhing modes More...
 
NekDouble m_sVVDiffCoeff
 Diffusion coefficient of SVV modes. More...
 
NekDouble m_sVVCutoffRatioHomo1D
 
NekDouble m_sVVDiffCoeffHomo1D
 Diffusion coefficient of SVV modes in homogeneous 1D Direction. More...
 
Array< OneD, NekDoublem_svvVarDiffCoeff
 Array of coefficient if power kernel is used in SVV. More...
 
bool m_IsSVVPowerKernel
 Identifier for Power Kernel otherwise DG kernel. More...
 
Array< OneD, NekDoublem_diffCoeff
 Diffusion coefficients (will be kinvis for velocities) More...
 
StdRegions::VarCoeffMap m_varCoeffLap
 Variable Coefficient map for the Laplacian which can be activated as part of SVV or otherwise. More...
 
NekDouble m_flowrate
 Desired volumetric flowrate. More...
 
NekDouble m_flowrateArea
 Area of the boundary through which we are measuring the flowrate. More...
 
bool m_homd1DFlowinPlane
 
NekDouble m_greenFlux
 Flux of the Stokes function solution. More...
 
NekDouble m_alpha
 Current flowrate correction. More...
 
int m_flowrateBndID
 Boundary ID of the flowrate reference surface. More...
 
int m_planeID
 Plane ID for cases with homogeneous expansion. More...
 
MultiRegions::ExpListSharedPtr m_flowrateBnd
 Flowrate reference surface. More...
 
Array< OneD, Array< OneD, NekDouble > > m_flowrateStokes
 Stokes solution used to impose flowrate. More...
 
std::ofstream m_flowrateStream
 Output stream to record flowrate. More...
 
int m_flowrateSteps
 Interval at which to record flowrate data. More...
 
NekDouble m_flowrateAiidt
 Value of aii_dt used to compute Stokes flowrate solution. More...
 
Array< OneD, Array< OneD, NekDouble > > m_F
 
- Protected Attributes inherited from Nektar::IncNavierStokes
ExtrapolateSharedPtr m_extrapolation
 
IncBoundaryConditionsSharedPtr m_IncNavierStokesBCs
 
std::ofstream m_mdlFile
 modal energy file More...
 
bool m_SmoothAdvection
 bool to identify if advection term smoothing is requested More...
 
std::vector< SolverUtils::ForcingSharedPtrm_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...
 
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...
 
Array< OneD, NekDoublem_pivotPoint
 pivot point for moving reference frame More...
 
Array< OneD, NekDoublem_aeroForces
 
std::map< int, std::map< int, WomersleyParamsSharedPtr > > m_womersleyParams
 Womersley parameters if required. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem
SolverUtils::AdvectionSharedPtr m_advObject
 Advection term. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
LibUtilities::TimeIntegrationSchemeSharedPtr m_intScheme
 Wrapper to the time integration scheme. More...
 
LibUtilities::TimeIntegrationSchemeOperators m_ode
 The time integration scheme operators to use. More...
 
Array< OneD, Array< OneD, NekDouble > > m_previousSolution
 Storage for previous solution for steady-state check. More...
 
std::vector< int > m_intVariables
 
NekDouble m_cflSafetyFactor
 CFL safety factor (comprise between 0 to 1). More...
 
NekDouble m_CFLGrowth
 CFL growth rate. More...
 
NekDouble m_CFLEnd
 Maximun cfl in cfl growth. More...
 
int m_abortSteps
 Number of steps between checks for abort conditions. More...
 
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...
 
int m_steadyStateSteps
 Check for steady state at step interval. More...
 
NekDouble m_steadyStateTol
 Tolerance to which steady state should be evaluated at. More...
 
int m_filtersInfosteps
 Number of time steps between outputting filters information. More...
 
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
 
bool m_homoInitialFwd
 Flag to determine if simulation should start in homogeneous forward transformed state. More...
 
std::ofstream m_errFile
 
NekDouble m_epsilon
 Diffusion coefficient. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
bool m_verbose
 
LibUtilities::SessionReaderSharedPtr m_session
 The session reader. More...
 
std::map< std::string, SolverUtils::SessionFunctionSharedPtrm_sessionFunctions
 Map of known SessionFunctions. More...
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output. More...
 
Array< OneD, MultiRegions::ExpListSharedPtrm_fields
 Array holding all dependent variables. More...
 
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
 Pointer to boundary conditions object. More...
 
SpatialDomains::MeshGraphSharedPtr m_graph
 Pointer to graph defining mesh. More...
 
std::string m_sessionName
 Name of the session. More...
 
NekDouble m_time
 Current time of simulation. More...
 
int m_initialStep
 Number of the step where the simulation should begin. More...
 
NekDouble m_fintime
 Finish time of the simulation. More...
 
NekDouble m_timestep
 Time step size. More...
 
NekDouble m_lambda
 Lambda constant in real system if one required. More...
 
NekDouble m_checktime
 Time between checkpoints. More...
 
NekDouble m_lastCheckTime
 
NekDouble m_TimeIncrementFactor
 
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_infosteps
 Number of time steps between outputting status information. More...
 
int m_iterPIT = 0
 Number of parallel-in-time time iteration. More...
 
int m_windowPIT = 0
 Index of windows for parallel-in-time time iteration. 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, 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...
 
Array< OneD, NekDoublem_movingFrameData
 Moving reference frame status in the inertial frame X, Y, Z, Theta_x, Theta_y, Theta_z, U, V, W, Omega_x, Omega_y, Omega_z, A_x, A_y, A_z, DOmega_x, DOmega_y, DOmega_z, pivot_x, pivot_y, pivot_z. More...
 
std::vector< std::string > m_strFrameData
 variable name in m_movingFrameData 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...
 
- Protected Attributes inherited from Nektar::SolverUtils::ALEHelper
Array< OneD, MultiRegions::ExpListSharedPtrm_fieldsALE
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocity
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
 
std::vector< ALEBaseShPtrm_ALEs
 
bool m_ALESolver = false
 
bool m_ImplicitALESolver = false
 
NekDouble m_prevStageTime = 0.0
 
int m_spaceDim
 

Static Protected Attributes

static std::string solverTypeLookupId
 
- Static Protected Attributes inherited from Nektar::IncNavierStokes
static std::string eqTypeLookupIds []
 
- Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
static std::string equationSystemTypeLookupIds []
 
static std::string projectionTypeLookupIds []
 

Friends

class MemoryManager< VelocityCorrectionScheme >
 

Additional Inherited Members

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

Detailed Description

Definition at line 42 of file VelocityCorrectionScheme.h.

Constructor & Destructor Documentation

◆ VelocityCorrectionScheme()

Nektar::VelocityCorrectionScheme::VelocityCorrectionScheme ( const LibUtilities::SessionReaderSharedPtr pSession,
const SpatialDomains::MeshGraphSharedPtr pGraph 
)
protected

Constructor. Creates ...

Parameters

param

Definition at line 65 of file VelocityCorrectionScheme.cpp.

68 : UnsteadySystem(pSession, pGraph), IncNavierStokes(pSession, pGraph),
70{
71}
IncNavierStokes(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Constructor.
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
StdRegions::VarCoeffMap m_varCoeffLap
Variable Coefficient map for the Laplacian which can be activated as part of SVV or otherwise.
static VarCoeffMap NullVarCoeffMap
Definition: StdRegions.hpp:376

◆ ~VelocityCorrectionScheme()

Nektar::VelocityCorrectionScheme::~VelocityCorrectionScheme ( )
overrideprotecteddefault

Member Function Documentation

◆ AppendSVVFactors()

void Nektar::VelocityCorrectionScheme::AppendSVVFactors ( StdRegions::ConstFactorMap factors,
MultiRegions::VarFactorsMap varFactorsMap 
)
protected

Definition at line 1154 of file VelocityCorrectionScheme.cpp.

1157{
1158
1159 if (m_useSpecVanVisc)
1160 {
1164 {
1166 {
1169 }
1170 else
1171 {
1174 }
1175 }
1176 }
1177}
NekDouble m_kinvis
Kinematic viscosity.
Array< OneD, NekDouble > m_svvVarDiffCoeff
Array of coefficient if power kernel is used in SVV.
bool m_IsSVVPowerKernel
Identifier for Power Kernel otherwise DG kernel.
NekDouble m_sVVCutoffRatio
cutt off ratio from which to start decayhing modes
NekDouble m_sVVDiffCoeff
Diffusion coefficient of SVV modes.
bool m_useSpecVanVisc
bool to identify if spectral vanishing viscosity is active.
StdRegions::ConstFactorMap factors
static Array< OneD, NekDouble > NullNekDouble1DArray

References Nektar::StdRegions::eFactorSVVCutoffRatio, Nektar::StdRegions::eFactorSVVDGKerDiffCoeff, Nektar::StdRegions::eFactorSVVDiffCoeff, Nektar::StdRegions::eFactorSVVPowerKerDiffCoeff, Nektar::VarcoeffHashingTest::factors, m_IsSVVPowerKernel, Nektar::IncNavierStokes::m_kinvis, m_sVVCutoffRatio, m_sVVDiffCoeff, m_svvVarDiffCoeff, m_useSpecVanVisc, and Nektar::NullNekDouble1DArray.

Referenced by v_SolveViscous(), and Nektar::VCSImplicit::v_SolveViscous().

◆ ComputeGJPNormalVelocity()

void Nektar::VelocityCorrectionScheme::ComputeGJPNormalVelocity ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
StdRegions::VarCoeffMap varcoeffs 
)
protected

Definition at line 1185 of file VelocityCorrectionScheme.cpp.

1188{
1190 {
1192 std::dynamic_pointer_cast<MultiRegions::ContField>(m_fields[0]);
1193
1195 cfield->GetGJPForcing();
1196
1197 int nTracePts = GJPData->GetNumTracePts();
1198 Array<OneD, NekDouble> unorm(nTracePts, 1.0);
1199 Array<OneD, NekDouble> Fwd(nTracePts), Bwd(nTracePts);
1200 Array<OneD, Array<OneD, NekDouble>> traceNormals =
1201 GJPData->GetTraceNormals();
1202
1203 m_fields[0]->GetFwdBwdTracePhys(inarray[0], Fwd, Bwd, true, true);
1204 Vmath::Vmul(nTracePts, Fwd, 1, traceNormals[0], 1, unorm, 1);
1205
1206 // Evaluate u.n on trace
1207 for (int f = 1; f < m_fields[0]->GetCoordim(0); ++f)
1208 {
1209 m_fields[0]->GetFwdBwdTracePhys(inarray[f], Fwd, Bwd, true, true);
1210 Vmath::Vvtvp(nTracePts, Fwd, 1, traceNormals[f], 1, unorm, 1, unorm,
1211 1);
1212 }
1213 Vmath::Vabs(nTracePts, unorm, 1, unorm, 1);
1214 varcoeffs[StdRegions::eVarCoeffGJPNormVel] = unorm;
1215 }
1216}
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
bool m_useGJPNormalVel
bool to identify if GJP normal Velocity should be applied in explicit approach
std::shared_ptr< GJPStabilisation > GJPStabilisationSharedPtr
std::shared_ptr< ContField > ContFieldSharedPtr
Definition: ContField.h:268
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.hpp:72
void Vabs(int n, const T *x, const int incx, T *y, const int incy)
vabs: y = |x|
Definition: Vmath.hpp:352
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.hpp:366

References Nektar::StdRegions::eVarCoeffGJPNormVel, Nektar::SolverUtils::EquationSystem::m_fields, m_useGJPNormalVel, Vmath::Vabs(), Vmath::Vmul(), and Vmath::Vvtvp().

Referenced by v_SolveViscous(), and Nektar::VCSImplicit::v_SolveViscous().

◆ create()

static SolverUtils::EquationSystemSharedPtr Nektar::VelocityCorrectionScheme::create ( const LibUtilities::SessionReaderSharedPtr pSession,
const SpatialDomains::MeshGraphSharedPtr pGraph 
)
inlinestatic

Creates an instance of this class.

Definition at line 48 of file VelocityCorrectionScheme.h.

51 {
54 pGraph);
55 p->InitObject();
56 return p;
57 }
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
std::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.

◆ EvaluateAdvection_SetPressureBCs()

void Nektar::VelocityCorrectionScheme::EvaluateAdvection_SetPressureBCs ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
inline

Definition at line 97 of file VelocityCorrectionScheme.h.

100 {
101 v_EvaluateAdvection_SetPressureBCs(inarray, outarray, time);
102 }
virtual void v_EvaluateAdvection_SetPressureBCs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)

References v_EvaluateAdvection_SetPressureBCs().

Referenced by v_InitObject().

◆ MeasureFlowrate()

NekDouble Nektar::VelocityCorrectionScheme::MeasureFlowrate ( const Array< OneD, Array< OneD, NekDouble > > &  inarray)
protected

Measure the volumetric flow rate through the volumetric flow rate reference surface.

This routine computes the volumetric flow rate

\[ Q(\mathbf{u}) = \frac{1}{\mu(R)} \int_R \mathbf{u} \cdot d\mathbf{s} \]

through the boundary region \( R \).

Definition at line 446 of file VelocityCorrectionScheme.cpp.

448{
449 NekDouble flowrate = 0.0;
450
451 if (m_flowrateBnd && m_flowrateBndID >= 0)
452 {
453 // If we're an actual boundary, calculate the vector flux through
454 // the boundary.
455 Array<OneD, Array<OneD, NekDouble>> boundary(m_spacedim);
456
458 {
459 // General case
460 for (int i = 0; i < m_spacedim; ++i)
461 {
462 m_fields[i]->ExtractPhysToBnd(m_flowrateBndID, inarray[i],
463 boundary[i]);
464 }
465 flowrate = m_flowrateBnd->VectorFlux(boundary);
466 }
467 else if (m_planeID == 0)
468 {
469 // Homogeneous with forcing in plane. Calculate flux only on
470 // the meanmode - calculateFlux necessary for hybrid
471 // parallelisation.
472 for (int i = 0; i < m_spacedim; ++i)
473 {
474 m_fields[i]->GetPlane(m_planeID)->ExtractPhysToBnd(
475 m_flowrateBndID, inarray[i], boundary[i]);
476 }
477
478 // the flowrate is calculated on the mean mode so it needs to be
479 // multiplied by LZ to be consistent with the general case.
480 flowrate = m_flowrateBnd->VectorFlux(boundary) *
481 m_session->GetParameter("LZ");
482 }
483 }
485 {
486 // 3DH1D case with no Flowrate boundary defined: compute flux
487 // through the zero-th (mean) plane.
488 flowrate = m_flowrateBnd->Integral(inarray[2]);
489 }
490
491 // Communication to obtain the total flowrate
493 {
494 m_comm->GetColumnComm()->AllReduce(flowrate, LibUtilities::ReduceSum);
495 }
496 else
497 {
498 m_comm->GetSpaceComm()->AllReduce(flowrate, LibUtilities::ReduceSum);
499 }
500 return flowrate / m_flowrateArea;
501}
int m_spacedim
Spatial dimension (>= expansion dim).
LibUtilities::CommSharedPtr m_comm
Communicator.
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
enum HomogeneousType m_HomogeneousType
MultiRegions::ExpListSharedPtr m_flowrateBnd
Flowrate reference surface.
NekDouble m_flowrateArea
Area of the boundary through which we are measuring the flowrate.
int m_planeID
Plane ID for cases with homogeneous expansion.
int m_flowrateBndID
Boundary ID of the flowrate reference surface.
double NekDouble

References Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::SolverUtils::EquationSystem::m_comm, Nektar::SolverUtils::EquationSystem::m_fields, m_flowrateArea, m_flowrateBnd, m_flowrateBndID, m_homd1DFlowinPlane, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, m_planeID, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, and Nektar::LibUtilities::ReduceSum.

Referenced by SetupFlowrate(), and v_SolveUnsteadyStokesSystem().

◆ SetUpExtrapolation()

void Nektar::VelocityCorrectionScheme::SetUpExtrapolation ( void  )
protected

Definition at line 150 of file VelocityCorrectionScheme.cpp.

151{
152 // creation of the extrapolation object
155 {
156 std::string vExtrapolation = v_GetExtrapolateStr();
157 if (m_session->DefinesSolverInfo("Extrapolation"))
158 {
159 vExtrapolation = v_GetSubSteppingExtrapolateStr(
160 m_session->GetSolverInfo("Extrapolation"));
161 }
163 vExtrapolation, m_session, m_fields, m_pressure, m_velocity,
165
166 m_extrapolation->SetForcing(m_forcing);
167 m_extrapolation->SubSteppingTimeIntegration(m_intScheme);
168 m_extrapolation->GenerateBndElmtExpansion();
169 m_extrapolation->GenerateHOPBCMap(m_session);
173 }
174}
MultiRegions::ExpListSharedPtr m_pressure
Pointer to field holding pressure field.
IncBoundaryConditionsSharedPtr m_IncNavierStokesBCs
ExtrapolateSharedPtr m_extrapolation
Array< OneD, int > m_velocity
int which identifies which components of m_fields contains the velocity (u,v,w);
EquationType m_equationType
equation type;
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
Forcing terms.
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
LibUtilities::TimeIntegrationSchemeSharedPtr m_intScheme
Wrapper to the time integration scheme.
virtual std::string v_GetExtrapolateStr(void)
virtual std::string v_GetSubSteppingExtrapolateStr(const std::string &instr)
@ eUnsteadyStokes
@ eUnsteadyNavierStokes
ExtrapolateFactory & GetExtrapolateFactory()
Definition: Extrapolate.cpp:47

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::eUnsteadyNavierStokes, Nektar::eUnsteadyStokes, Nektar::GetExtrapolateFactory(), Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::IncNavierStokes::m_equationType, Nektar::IncNavierStokes::m_extrapolation, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::IncNavierStokes::m_forcing, Nektar::IncNavierStokes::m_IncNavierStokesBCs, Nektar::SolverUtils::UnsteadySystem::m_intScheme, Nektar::IncNavierStokes::m_pressure, Nektar::SolverUtils::EquationSystem::m_session, Nektar::IncNavierStokes::m_velocity, v_GetExtrapolateStr(), and v_GetSubSteppingExtrapolateStr().

Referenced by v_InitObject().

◆ SetupFlowrate()

void Nektar::VelocityCorrectionScheme::SetupFlowrate ( NekDouble  aii_dt)
protected

Set up the Stokes solution used to impose constant flowrate through a boundary.

This routine solves a Stokes equation using a unit forcing direction, specified by the user to be in the desired flow direction. This field can then be used to correct the end of each timestep to impose a constant volumetric flow rate through a user-defined boundary.

There are three modes of operation:

  • Standard two-dimensional or three-dimensional simulations (e.g. pipes or channels)
  • 3DH1D simulations where the forcing is not in the homogeneous direction (e.g. channel flow, where the y-direction of the 2D mesh is perpendicular to the wall);
  • 3DH1D simulations where the forcing is in the homogeneous direction (e.g. pipe flow in the z-direction).

In the first two cases, the user should define:

  • the Flowrate parameter, which dictates the volumetric flux through the reference area
  • tag a boundary region with the Flowrate user-defined type to define the reference area
  • define a FlowrateForce function with components ForceX, ForceY and ForceZ that defines a unit forcing in the appropriate direction.

In the latter case, the user should define only the Flowrate; the reference area is taken to be the homogeneous plane and the force is assumed to be the unit z-vector \( \hat{e}_z \).

This routine solves a single timestep of the Stokes problem (premultiplied by the backwards difference coefficient):

\[ \frac{\partial\mathbf{u}}{\partial t} = -\nabla p + \nu\nabla^2\mathbf{u} + \mathbf{f} \]

with a zero initial condition to obtain a field \( \mathbf{u}_s \). The flowrate is then corrected at each timestep \( n \) by adding the correction \( \alpha\mathbf{u}_s \) where

\[ \alpha = \frac{\overline{Q} - Q(\mathbf{u^n})}{Q(\mathbf{u}_s)} \]

where \( Q(\cdot)\) is the volumetric flux through the appropriate surface or line, which is implemented in VelocityCorrectionScheme::MeasureFlowrate. For more details, see chapter 3.2 of the thesis of D. Moxey (University of Warwick, 2011).

Definition at line 224 of file VelocityCorrectionScheme.cpp.

225{
226 m_flowrateBndID = -1;
227 m_flowrateArea = 0.0;
228
229 const Array<OneD, const SpatialDomains::BoundaryConditionShPtr> &bcs =
230 m_fields[0]->GetBndConditions();
231
232 std::string forces[] = {"X", "Y", "Z"};
233 Array<OneD, NekDouble> flowrateForce(m_spacedim, 0.0);
234
235 // Set up flowrate forces.
236 bool defined = true;
237 for (int i = 0; i < m_spacedim; ++i)
238 {
239 std::string varName = std::string("Force") + forces[i];
240 defined = m_session->DefinesFunction("FlowrateForce", varName);
241
242 if (!defined && m_HomogeneousType == eHomogeneous1D)
243 {
244 break;
245 }
246
247 ASSERTL0(defined,
248 "A 'FlowrateForce' function must defined with components "
249 "[ForceX, ...] to define direction of flowrate forcing");
250
252 m_session->GetFunction("FlowrateForce", varName);
253 flowrateForce[i] = ffunc->Evaluate();
254 }
255
256 // Define flag for case with homogeneous expansion and forcing not in the
257 // z-direction
258 m_homd1DFlowinPlane = false;
259 if (defined && m_HomogeneousType == eHomogeneous1D)
260 {
261 m_homd1DFlowinPlane = true;
262 }
263
264 // For 3DH1D simulations, if force isn't defined then assume in
265 // z-direction.
266 if (!defined)
267 {
268 flowrateForce[2] = 1.0;
269 }
270
271 // Find the boundary condition that is tagged as the flowrate boundary.
272 for (size_t i = 0; i < bcs.size(); ++i)
273 {
274 if (boost::iequals(bcs[i]->GetUserDefined(), "Flowrate"))
275 {
276 m_flowrateBndID = i;
277 break;
278 }
279 }
280
281 int tmpBr = m_flowrateBndID;
282 m_comm->AllReduce(tmpBr, LibUtilities::ReduceMax);
284 "One boundary region must be marked using the 'Flowrate' "
285 "user-defined type to monitor the volumetric flowrate.");
286
287 // Extract an appropriate expansion list to represents the boundary.
288 if (m_flowrateBndID >= 0)
289 {
290 // For a boundary, extract the boundary itself.
291 m_flowrateBnd = m_fields[0]->GetBndCondExpansions()[m_flowrateBndID];
292 }
294 {
295 // For 3DH1D simulations with no force specified, find the mean
296 // (0th) plane.
297 Array<OneD, unsigned int> zIDs = m_fields[0]->GetZIDs();
298 int tmpId = -1;
299
300 for (size_t i = 0; i < zIDs.size(); ++i)
301 {
302 if (zIDs[i] == 0)
303 {
304 tmpId = i;
305 break;
306 }
307 }
308
309 ASSERTL1(tmpId <= 0, "Should be either at location 0 or -1 if not "
310 "found");
311
312 if (tmpId != -1)
313 {
314 m_flowrateBnd = m_fields[0]->GetPlane(tmpId);
315 }
316 }
317
318 // At this point, some processors may not have m_flowrateBnd
319 // set if they don't contain the appropriate boundary. To
320 // calculate the area, we integrate 1.0 over the boundary
321 // (which has been set up with the appropriate subcommunicator
322 // to avoid deadlock), and then communicate this to the other
323 // processors with an AllReduce.
324 if (m_flowrateBnd)
325 {
326 Array<OneD, NekDouble> inArea(m_flowrateBnd->GetNpoints(), 1.0);
327 m_flowrateArea = m_flowrateBnd->Integral(inArea);
328 }
330
331 // In homogeneous case with forcing not aligned to the z-direction,
332 // redefine m_flowrateBnd so it is a 1D expansion
335 {
336 // For 3DH1D simulations with no force specified, find the mean
337 // (0th) plane.
338 Array<OneD, unsigned int> zIDs = m_fields[0]->GetZIDs();
339 m_planeID = -1;
340
341 for (size_t i = 0; i < zIDs.size(); ++i)
342 {
343 if (zIDs[i] == 0)
344 {
345 m_planeID = i;
346 break;
347 }
348 }
349
350 ASSERTL1(m_planeID <= 0, "Should be either at location 0 or -1 "
351 "if not found");
352
353 if (m_planeID != -1)
354 {
356 m_fields[0]->GetBndCondExpansions()[m_flowrateBndID]->GetPlane(
357 m_planeID);
358 }
359 }
360
361 // Set up some storage for the Stokes solution (to be stored in
362 // m_flowrateStokes) and its initial condition (inTmp), which holds the
363 // unit forcing.
364 int nqTot = m_fields[0]->GetNpoints();
365 Array<OneD, Array<OneD, NekDouble>> inTmp(m_spacedim);
366 m_flowrateStokes = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
367
368 for (int i = 0; i < m_spacedim; ++i)
369 {
370 inTmp[i] = Array<OneD, NekDouble>(nqTot, flowrateForce[i] * aii_dt);
371 m_flowrateStokes[i] = Array<OneD, NekDouble>(nqTot, 0.0);
372
374 {
375 Array<OneD, NekDouble> inTmp2(nqTot);
376 m_fields[i]->HomogeneousFwdTrans(nqTot, inTmp[i], inTmp2);
377 m_fields[i]->SetWaveSpace(true);
378 inTmp[i] = inTmp2;
379 }
380
381 Vmath::Zero(m_fields[i]->GetNcoeffs(), m_fields[i]->UpdateCoeffs(), 1);
382 }
383
384 // Create temporary extrapolation object to avoid issues with
385 // m_extrapolation for HOPBCs using higher order timestepping schemes.
386 // Zero pressure BCs in Neumann boundaries that may have been
387 // set in the advection step.
388 Array<OneD, const SpatialDomains::BoundaryConditionShPtr> PBndConds =
389 m_pressure->GetBndConditions();
390 Array<OneD, MultiRegions::ExpListSharedPtr> PBndExp =
391 m_pressure->GetBndCondExpansions();
392 for (size_t n = 0; n < PBndConds.size(); ++n)
393 {
394 if (PBndConds[n]->GetBoundaryConditionType() ==
396 {
397 Vmath::Zero(PBndExp[n]->GetNcoeffs(), PBndExp[n]->UpdateCoeffs(),
398 1);
399 }
400 }
401
402 // Finally, calculate the solution and the flux of the Stokes
403 // solution. We set m_greenFlux to maximum numeric limit, which signals
404 // to SolveUnsteadyStokesSystem that we don't need to apply a flowrate
405 // force.
406 m_greenFlux = std::numeric_limits<NekDouble>::max();
407 m_flowrateAiidt = aii_dt;
408
409 // Save the number of convective field in case it is not set
410 // to spacedim. Only need velocity components for stokes forcing
411 int SaveNConvectiveFields = m_nConvectiveFields;
413 SolveUnsteadyStokesSystem(inTmp, m_flowrateStokes, 0.0, aii_dt);
414 m_nConvectiveFields = SaveNConvectiveFields;
416
417 // If the user specified IO_FlowSteps, open a handle to store output.
418 if (m_comm->GetRank() == 0 && m_flowrateSteps &&
419 !m_flowrateStream.is_open())
420 {
421 std::string filename = m_session->GetSessionName();
422 filename += ".prs";
423 m_flowrateStream.open(filename.c_str());
424 m_flowrateStream.setf(std::ios::scientific, std::ios::floatfield);
425 m_flowrateStream << "# step time dP" << std::endl
426 << "# -------------------------------------------"
427 << std::endl;
428 }
429
430 // Replace pressure BCs with those evaluated from advection step
431 m_extrapolation->CopyPressureHBCsToPbndExp();
432}
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
int m_nConvectiveFields
Number of fields to be convected;.
SOLVER_UTILS_EXPORT int GetNcoeffs()
NekDouble m_greenFlux
Flux of the Stokes function solution.
NekDouble MeasureFlowrate(const Array< OneD, Array< OneD, NekDouble > > &inarray)
Measure the volumetric flow rate through the volumetric flow rate reference surface.
Array< OneD, Array< OneD, NekDouble > > m_flowrateStokes
Stokes solution used to impose flowrate.
void SolveUnsteadyStokesSystem(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time, const NekDouble a_iixDt)
int m_flowrateSteps
Interval at which to record flowrate data.
std::ofstream m_flowrateStream
Output stream to record flowrate.
NekDouble m_flowrateAiidt
Value of aii_dt used to compute Stokes flowrate solution.
std::shared_ptr< Equation > EquationSharedPtr
Definition: Equation.h:125
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.hpp:273

References ASSERTL0, ASSERTL1, Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::SpatialDomains::eNeumann, Nektar::SolverUtils::EquationSystem::GetNcoeffs(), Nektar::SolverUtils::EquationSystem::m_comm, Nektar::IncNavierStokes::m_extrapolation, Nektar::SolverUtils::EquationSystem::m_fields, m_flowrateAiidt, m_flowrateArea, m_flowrateBnd, m_flowrateBndID, m_flowrateSteps, m_flowrateStokes, m_flowrateStream, m_greenFlux, m_homd1DFlowinPlane, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, Nektar::IncNavierStokes::m_nConvectiveFields, m_planeID, Nektar::IncNavierStokes::m_pressure, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, MeasureFlowrate(), Nektar::LibUtilities::ReduceMax, SolveUnsteadyStokesSystem(), and Vmath::Zero().

Referenced by v_SolveUnsteadyStokesSystem().

◆ SetUpPressureForcing()

void Nektar::VelocityCorrectionScheme::SetUpPressureForcing ( const Array< OneD, const Array< OneD, NekDouble > > &  fields,
Array< OneD, Array< OneD, NekDouble > > &  Forcing,
const NekDouble  aii_Dt 
)
inline

Definition at line 62 of file VelocityCorrectionScheme.h.

65 {
66 v_SetUpPressureForcing(fields, Forcing, aii_Dt);
67 }
virtual void v_SetUpPressureForcing(const Array< OneD, const Array< OneD, NekDouble > > &fields, Array< OneD, Array< OneD, NekDouble > > &Forcing, const NekDouble aii_Dt)

References v_SetUpPressureForcing().

Referenced by v_SolveUnsteadyStokesSystem().

◆ SetUpSVV()

void Nektar::VelocityCorrectionScheme::SetUpSVV ( void  )
protected

Definition at line 926 of file VelocityCorrectionScheme.cpp.

927{
928
929 m_session->MatchSolverInfo("SpectralVanishingViscosity", "PowerKernel",
930 m_useSpecVanVisc, false);
931
933 {
935 }
936 else
937 {
939
940 m_session->MatchSolverInfo("SpectralVanishingViscositySpectralHP",
941 "PowerKernel", m_useSpecVanVisc, false);
942 }
943
945 {
946 m_IsSVVPowerKernel = true;
947 }
948 else
949 {
950 m_session->MatchSolverInfo("SpectralVanishingViscosity", "DGKernel",
951 m_useSpecVanVisc, false);
953 {
955 }
956 else
957 {
958 m_session->MatchSolverInfo("SpectralVanishingViscositySpectralHP",
959 "DGKernel", m_useSpecVanVisc, false);
960 }
961
963 {
964 m_IsSVVPowerKernel = false;
965 }
966 }
967
968 // set up varcoeff kernel if PowerKernel or DG is specified
970 {
971 Array<OneD, Array<OneD, NekDouble>> SVVVelFields =
973 if (m_session->DefinesFunction("SVVVelocityMagnitude"))
974 {
975 if (m_comm->GetRank() == 0)
976 {
977 std::cout << "Seting up SVV velocity from "
978 "SVVVelocityMagnitude section in session file"
979 << std::endl;
980 }
981 size_t nvel = m_velocity.size();
982 size_t phystot = m_fields[0]->GetTotPoints();
983 SVVVelFields = Array<OneD, Array<OneD, NekDouble>>(nvel);
984 std::vector<std::string> vars;
985 for (size_t i = 0; i < nvel; ++i)
986 {
987 SVVVelFields[i] = Array<OneD, NekDouble>(phystot);
988 vars.push_back(m_session->GetVariable(m_velocity[i]));
989 }
990
991 // Load up files into m_fields;
992 GetFunction("SVVVelocityMagnitude")->Evaluate(vars, SVVVelFields);
993 }
994
995 m_svvVarDiffCoeff = Array<OneD, NekDouble>(m_fields[0]->GetNumElmts());
996 SVVVarDiffCoeff(1.0, m_svvVarDiffCoeff, SVVVelFields);
997 m_session->LoadParameter("SVVDiffCoeff", m_sVVDiffCoeff, 1.0);
998 }
999 else
1000 {
1002 m_session->LoadParameter("SVVDiffCoeff", m_sVVDiffCoeff, 0.1);
1003 }
1004
1005 // Load parameters for Spectral Vanishing Viscosity
1006 if (m_useSpecVanVisc == false)
1007 {
1008 m_session->MatchSolverInfo("SpectralVanishingViscosity", "True",
1009 m_useSpecVanVisc, false);
1010 if (m_useSpecVanVisc == false)
1011 {
1012 m_session->MatchSolverInfo("SpectralVanishingViscosity",
1013 "ExpKernel", m_useSpecVanVisc, false);
1014 }
1016
1017 if (m_useSpecVanVisc == false)
1018 {
1019 m_session->MatchSolverInfo("SpectralVanishingViscositySpectralHP",
1020 "True", m_useSpecVanVisc, false);
1021 if (m_useSpecVanVisc == false)
1022 {
1023 m_session->MatchSolverInfo(
1024 "SpectralVanishingViscositySpectralHP", "ExpKernel",
1025 m_useSpecVanVisc, false);
1026 }
1027 }
1028 }
1029
1030 // Case of only Homo1D kernel
1031 if (m_session->DefinesSolverInfo("SpectralVanishingViscosityHomo1D"))
1032 {
1033 m_session->MatchSolverInfo("SpectralVanishingViscosityHomo1D", "True",
1034 m_useHomo1DSpecVanVisc, false);
1035 if (m_useHomo1DSpecVanVisc == false)
1036 {
1037 m_session->MatchSolverInfo("SpectralVanishingViscosityHomo1D",
1038 "ExpKernel", m_useHomo1DSpecVanVisc,
1039 false);
1040 }
1041 }
1042
1043 m_session->LoadParameter("SVVCutoffRatio", m_sVVCutoffRatio, 0.75);
1044 m_session->LoadParameter("SVVCutoffRatioHomo1D", m_sVVCutoffRatioHomo1D,
1046 m_session->LoadParameter("SVVDiffCoeffHomo1D", m_sVVDiffCoeffHomo1D,
1048
1050 {
1051 ASSERTL0(
1053 "Expect to have three velocity fields with homogenous expansion");
1054
1056 {
1057 Array<OneD, unsigned int> planes;
1058 planes = m_fields[0]->GetZIDs();
1059
1060 size_t num_planes = planes.size();
1061 Array<OneD, NekDouble> SVV(num_planes, 0.0);
1062 NekDouble fac;
1063 size_t kmodes = m_fields[0]->GetHomogeneousBasis()->GetNumModes();
1064 size_t pstart;
1065
1066 pstart = m_sVVCutoffRatioHomo1D * kmodes;
1067
1068 for (size_t n = 0; n < num_planes; ++n)
1069 {
1070 if (planes[n] > pstart)
1071 {
1072 fac = (NekDouble)((planes[n] - kmodes) *
1073 (planes[n] - kmodes)) /
1074 ((NekDouble)((planes[n] - pstart) *
1075 (planes[n] - pstart)));
1076 SVV[n] = m_sVVDiffCoeffHomo1D * exp(-fac) / m_kinvis;
1077 }
1078 }
1079
1080 for (size_t i = 0; i < m_velocity.size(); ++i)
1081 {
1082 m_fields[m_velocity[i]]->SetHomo1DSpecVanVisc(SVV);
1083 }
1084 }
1085 }
1086}
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction(std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
Get a SessionFunction by name.
NekDouble m_sVVDiffCoeffHomo1D
Diffusion coefficient of SVV modes in homogeneous 1D Direction.
void SVVVarDiffCoeff(const NekDouble velmag, Array< OneD, NekDouble > &diffcoeff, const Array< OneD, Array< OneD, NekDouble > > &vel=NullNekDoubleArrayOfArray)
bool m_useHomo1DSpecVanVisc
bool to identify if spectral vanishing viscosity is active.
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray

References ASSERTL0, Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::SolverUtils::EquationSystem::GetFunction(), Nektar::SolverUtils::EquationSystem::m_comm, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, m_IsSVVPowerKernel, Nektar::IncNavierStokes::m_kinvis, Nektar::IncNavierStokes::m_nConvectiveFields, Nektar::SolverUtils::EquationSystem::m_session, m_sVVCutoffRatio, m_sVVCutoffRatioHomo1D, m_sVVDiffCoeff, m_sVVDiffCoeffHomo1D, m_svvVarDiffCoeff, m_useHomo1DSpecVanVisc, m_useSpecVanVisc, Nektar::IncNavierStokes::m_velocity, Nektar::NullNekDouble1DArray, Nektar::NullNekDoubleArrayOfArray, and SVVVarDiffCoeff().

Referenced by v_InitObject().

◆ SetUpViscousForcing()

void Nektar::VelocityCorrectionScheme::SetUpViscousForcing ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  Forcing,
const NekDouble  aii_Dt 
)
inline

Definition at line 69 of file VelocityCorrectionScheme.h.

72 {
73 v_SetUpViscousForcing(inarray, Forcing, aii_Dt);
74 }
virtual void v_SetUpViscousForcing(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &Forcing, const NekDouble aii_Dt)

References v_SetUpViscousForcing().

Referenced by v_SolveUnsteadyStokesSystem().

◆ SolvePressure()

void Nektar::VelocityCorrectionScheme::SolvePressure ( const Array< OneD, NekDouble > &  Forcing)
inline

Definition at line 76 of file VelocityCorrectionScheme.h.

77 {
78 v_SolvePressure(Forcing);
79 }
virtual void v_SolvePressure(const Array< OneD, NekDouble > &Forcing)

References v_SolvePressure().

Referenced by v_SolveUnsteadyStokesSystem().

◆ SolveUnsteadyStokesSystem()

void Nektar::VelocityCorrectionScheme::SolveUnsteadyStokesSystem ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time,
const NekDouble  a_iixDt 
)
inline

Definition at line 89 of file VelocityCorrectionScheme.h.

93 {
94 v_SolveUnsteadyStokesSystem(inarray, outarray, time, a_iixDt);
95 }
virtual void v_SolveUnsteadyStokesSystem(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time, const NekDouble a_iixDt)

References v_SolveUnsteadyStokesSystem().

Referenced by SetupFlowrate(), and v_InitObject().

◆ SolveViscous()

void Nektar::VelocityCorrectionScheme::SolveViscous ( const Array< OneD, const Array< OneD, NekDouble > > &  Forcing,
const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  aii_Dt 
)
inline

Definition at line 81 of file VelocityCorrectionScheme.h.

85 {
86 v_SolveViscous(Forcing, inarray, outarray, aii_Dt);
87 }
virtual void v_SolveViscous(const Array< OneD, const Array< OneD, NekDouble > > &Forcing, const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble aii_Dt)

References v_SolveViscous().

Referenced by v_SolveUnsteadyStokesSystem().

◆ SVVVarDiffCoeff()

void Nektar::VelocityCorrectionScheme::SVVVarDiffCoeff ( const NekDouble  velmag,
Array< OneD, NekDouble > &  diffcoeff,
const Array< OneD, Array< OneD, NekDouble > > &  vel = NullNekDoubleArrayOfArray 
)
protected

Definition at line 1088 of file VelocityCorrectionScheme.cpp.

1091{
1092 size_t phystot = m_fields[0]->GetTotPoints();
1093 size_t nel = m_fields[0]->GetNumElmts();
1094 size_t nvel, cnt;
1095
1096 Array<OneD, NekDouble> tmp;
1097
1098 Vmath::Fill(nel, velmag, diffcoeff, 1);
1099
1100 if (vel != NullNekDoubleArrayOfArray)
1101 {
1102 Array<OneD, NekDouble> Velmag(phystot);
1103 nvel = vel.size();
1104 // calculate magnitude of v
1105 Vmath::Vmul(phystot, vel[0], 1, vel[0], 1, Velmag, 1);
1106 for (size_t n = 1; n < nvel; ++n)
1107 {
1108 Vmath::Vvtvp(phystot, vel[n], 1, vel[n], 1, Velmag, 1, Velmag, 1);
1109 }
1110 Vmath::Vsqrt(phystot, Velmag, 1, Velmag, 1);
1111
1112 cnt = 0;
1113 Array<OneD, NekDouble> tmp;
1114 // calculate mean value of vel mag.
1115 for (size_t i = 0; i < nel; ++i)
1116 {
1117 size_t nq = m_fields[0]->GetExp(i)->GetTotPoints();
1118 tmp = Velmag + cnt;
1119 diffcoeff[i] = m_fields[0]->GetExp(i)->Integral(tmp);
1120 Vmath::Fill(nq, 1.0, tmp, 1);
1121 NekDouble area = m_fields[0]->GetExp(i)->Integral(tmp);
1122 diffcoeff[i] = diffcoeff[i] / area;
1123 cnt += nq;
1124 }
1125 }
1126 else
1127 {
1128 nvel = m_expdim;
1129 }
1130
1131 for (size_t e = 0; e < nel; e++)
1132 {
1133 LocalRegions::ExpansionSharedPtr exp = m_fields[0]->GetExp(e);
1134 NekDouble h = 0;
1135
1136 // Find maximum length of edge.
1137 size_t nEdge = exp->GetGeom()->GetNumEdges();
1138 for (size_t i = 0; i < nEdge; ++i)
1139 {
1140 h = std::max(h, exp->GetGeom()->GetEdge(i)->GetVertex(0)->dist(
1141 *(exp->GetGeom()->GetEdge(i)->GetVertex(1))));
1142 }
1143
1144 int p = 0;
1145 for (int i = 0; i < m_expdim; ++i)
1146 {
1147 p = std::max(p, exp->GetBasisNumModes(i) - 1);
1148 }
1149
1150 diffcoeff[e] *= h / p;
1151 }
1152}
int m_expdim
Expansion dimension.
std::shared_ptr< Expansion > ExpansionSharedPtr
Definition: Expansion.h:66
void Vsqrt(int n, const T *x, const int incx, T *y, const int incy)
sqrt y = sqrt(x)
Definition: Vmath.hpp:340
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.hpp:54

References Vmath::Fill(), Nektar::SolverUtils::EquationSystem::m_expdim, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::NullNekDoubleArrayOfArray, CellMLToNektar.cellml_metadata::p, Vmath::Vmul(), Vmath::Vsqrt(), and Vmath::Vvtvp().

Referenced by SetUpSVV().

◆ v_DoInitialise()

void Nektar::VelocityCorrectionScheme::v_DoInitialise ( bool  dumpInitialConditions = true)
overrideprotectedvirtual

Sets up initial conditions.

Sets the initial conditions.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Reimplemented in Nektar::VCSImplicit.

Definition at line 607 of file VelocityCorrectionScheme.cpp.

608{
609 m_F = Array<OneD, Array<OneD, NekDouble>>(m_nConvectiveFields);
610
611 for (int i = 0; i < m_nConvectiveFields; ++i)
612 {
613 m_F[i] = Array<OneD, NekDouble>(m_fields[0]->GetTotPoints(), 0.0);
614 }
615
616 m_flowrateAiidt = 0.0;
617
618 AdvectionSystem::v_DoInitialise(dumpInitialConditions);
619
620 // Set up Field Meta Data for output files
621 m_fieldMetaDataMap["Kinvis"] = boost::lexical_cast<std::string>(m_kinvis);
622 m_fieldMetaDataMap["TimeStep"] =
623 boost::lexical_cast<std::string>(m_timestep);
624
625 // set boundary conditions here so that any normal component
626 // correction are imposed before they are imposed on initial
627 // field below
629 std::map<std::string, NekDouble> params;
630 params["Time"] = m_time;
631 for (size_t i = 0; i < m_strFrameData.size(); ++i)
632 {
633 if (std::fabs(m_movingFrameData[i + 21]) != 0.)
634 {
635 params[m_strFrameData[i]] = m_movingFrameData[i + 21];
636 }
637 }
638 Array<OneD, Array<OneD, NekDouble>> fields;
639 Array<OneD, Array<OneD, NekDouble>> Adv;
640 m_IncNavierStokesBCs->Update(fields, Adv, params);
641
642 // Ensure the initial conditions have correct BCs
643 for (size_t i = 0; i < m_fields.size(); ++i)
644 {
645 m_fields[i]->ImposeDirichletConditions(m_fields[i]->UpdateCoeffs());
646 m_fields[i]->LocalToGlobal();
647 m_fields[i]->GlobalToLocal();
648 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
649 m_fields[i]->UpdatePhys());
650 }
651}
void SetBoundaryConditions(NekDouble time)
time dependent boundary conditions updating
NekDouble m_timestep
Time step size.
NekDouble m_time
Current time of simulation.
std::vector< std::string > m_strFrameData
variable name in m_movingFrameData
SOLVER_UTILS_EXPORT int GetTotPoints()
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
Map to identify relevant solver info to dump in output fields.
Array< OneD, NekDouble > m_movingFrameData
Moving reference frame status in the inertial frame X, Y, Z, Theta_x, Theta_y, Theta_z,...
SOLVER_UTILS_EXPORT void v_DoInitialise(bool dumpInitialConditions=true) override
Sets up initial conditions.
Array< OneD, Array< OneD, NekDouble > > m_F

References Nektar::SolverUtils::EquationSystem::GetTotPoints(), m_F, Nektar::SolverUtils::EquationSystem::m_fieldMetaDataMap, Nektar::SolverUtils::EquationSystem::m_fields, m_flowrateAiidt, Nektar::IncNavierStokes::m_IncNavierStokesBCs, Nektar::IncNavierStokes::m_kinvis, Nektar::SolverUtils::EquationSystem::m_movingFrameData, Nektar::IncNavierStokes::m_nConvectiveFields, Nektar::SolverUtils::EquationSystem::m_strFrameData, Nektar::SolverUtils::EquationSystem::m_time, Nektar::SolverUtils::EquationSystem::m_timestep, Nektar::IncNavierStokes::SetBoundaryConditions(), and Nektar::SolverUtils::UnsteadySystem::v_DoInitialise().

Referenced by Nektar::VCSImplicit::v_DoInitialise().

◆ v_EvaluateAdvection_SetPressureBCs()

void Nektar::VelocityCorrectionScheme::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 in Nektar::VCSMapping, and Nektar::VCSImplicit.

Definition at line 704 of file VelocityCorrectionScheme.cpp.

707{
708 LibUtilities::Timer timer;
709 timer.Start();
710 EvaluateAdvectionTerms(inarray, outarray, time);
711 timer.Stop();
712 timer.AccumulateRegion("Advection Terms");
713
714 // Smooth advection
716 {
717 for (int i = 0; i < m_nConvectiveFields; ++i)
718 {
719 m_pressure->SmoothField(outarray[i]);
720 }
721 }
722
723 // Add forcing terms
724 for (auto &x : m_forcing)
725 {
726 x->Apply(m_fields, inarray, outarray, time);
727 }
728
729 // Calculate High-Order pressure boundary conditions
730 timer.Start();
731 std::map<std::string, NekDouble> params;
732 params["Kinvis"] = m_kinvis;
733 params["Time"] = time + m_timestep;
734 for (size_t i = 0; i < m_strFrameData.size(); ++i)
735 {
736 if (std::fabs(m_movingFrameData[i + 21]) != 0.)
737 {
738 params[m_strFrameData[i]] = m_movingFrameData[i + 21];
739 }
740 }
741 m_extrapolation->EvaluatePressureBCs(inarray, outarray, m_kinvis);
742 m_IncNavierStokesBCs->Update(inarray, outarray, params);
743 timer.Stop();
744 timer.AccumulateRegion("Pressure BCs");
745}
bool m_SmoothAdvection
bool to identify if advection term smoothing is requested
void EvaluateAdvectionTerms(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)

References Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::IncNavierStokes::EvaluateAdvectionTerms(), Nektar::IncNavierStokes::m_extrapolation, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::IncNavierStokes::m_forcing, Nektar::IncNavierStokes::m_IncNavierStokesBCs, Nektar::IncNavierStokes::m_kinvis, Nektar::SolverUtils::EquationSystem::m_movingFrameData, Nektar::IncNavierStokes::m_nConvectiveFields, Nektar::IncNavierStokes::m_pressure, Nektar::IncNavierStokes::m_SmoothAdvection, Nektar::SolverUtils::EquationSystem::m_strFrameData, Nektar::SolverUtils::EquationSystem::m_timestep, Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by EvaluateAdvection_SetPressureBCs().

◆ v_GenerateSummary()

void Nektar::VelocityCorrectionScheme::v_GenerateSummary ( SolverUtils::SummaryList s)
overrideprotectedvirtual

Print a summary of time stepping parameters.

Prints a summary with some information regards the time-stepping.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Reimplemented in Nektar::VCSImplicit, and Nektar::VCSWeakPressure.

Definition at line 520 of file VelocityCorrectionScheme.cpp.

521{
523 SolverUtils::AddSummaryItem(s, "Splitting Scheme",
524 "Velocity correction (strong press. form)");
525
526 if (m_extrapolation->GetSubStepName().size())
527 {
528 SolverUtils::AddSummaryItem(s, "Substepping",
529 m_extrapolation->GetSubStepName());
530 }
531
532 std::string dealias = m_homogen_dealiasing ? "Homogeneous1D" : "";
534 {
535 dealias += (dealias == "" ? "" : " + ") + std::string("spectral/hp");
536 }
537 if (dealias != "")
538 {
539 SolverUtils::AddSummaryItem(s, "Dealiasing", dealias);
540 }
541
542 std::string smoothing = m_useSpecVanVisc ? "spectral/hp" : "";
543 if (smoothing != "")
544 {
546 {
548 s, "Smoothing-SpecHP",
549 "SVV (" + smoothing + " Exp Kernel(cut-off = " +
550 boost::lexical_cast<std::string>(m_sVVCutoffRatio) +
551 ", diff coeff = " +
552 boost::lexical_cast<std::string>(m_sVVDiffCoeff) + "))");
553 }
554 else
555 {
557 {
559 s, "Smoothing-SpecHP",
560 "SVV (" + smoothing + " Power Kernel (Power ratio =" +
561 boost::lexical_cast<std::string>(m_sVVCutoffRatio) +
562 ", diff coeff = " +
563 boost::lexical_cast<std::string>(m_sVVDiffCoeff) +
564 "*Uh/p))");
565 }
566 else
567 {
569 s, "Smoothing-SpecHP",
570 "SVV (" + smoothing + " DG Kernel (diff coeff = " +
571 boost::lexical_cast<std::string>(m_sVVDiffCoeff) +
572 "*Uh/p))");
573 }
574 }
575 }
576
578 {
580 s, "Smoothing-Homo1D",
581 "SVV (Homogeneous1D - Exp Kernel(cut-off = " +
582 boost::lexical_cast<std::string>(m_sVVCutoffRatioHomo1D) +
583 ", diff coeff = " +
584 boost::lexical_cast<std::string>(m_sVVDiffCoeffHomo1D) + "))");
585 }
586
588 {
590 s, "GJP Stab. Impl. ",
591 m_session->GetSolverInfo("GJPStabilisation"));
592 SolverUtils::AddSummaryItem(s, "GJP Stab. JumpScale", m_GJPJumpScale);
593
594 if (boost::iequals(m_session->GetSolverInfo("GJPStabilisation"),
595 "Explicit"))
596 {
598 s, "GJP Normal Velocity",
599 m_session->GetSolverInfo("GJPNormalVelocity"));
600 }
601 }
602}
bool m_specHP_dealiasing
Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
bool m_homogen_dealiasing
Flag to determine if dealiasing is used for homogeneous simulations.
SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s) override
Print a summary of time stepping parameters.
bool m_useGJPStabilisation
bool to identify if GJP semi-implicit is active.
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
Definition: Misc.cpp:47

References Nektar::SolverUtils::AddSummaryItem(), Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::IncNavierStokes::m_extrapolation, m_GJPJumpScale, Nektar::SolverUtils::EquationSystem::m_homogen_dealiasing, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, m_IsSVVPowerKernel, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_specHP_dealiasing, m_sVVCutoffRatio, m_sVVCutoffRatioHomo1D, m_sVVDiffCoeff, m_sVVDiffCoeffHomo1D, m_svvVarDiffCoeff, m_useGJPStabilisation, m_useHomo1DSpecVanVisc, m_useSpecVanVisc, Nektar::NullNekDouble1DArray, and Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary().

Referenced by Nektar::SmoothedProfileMethod::v_GenerateSummary().

◆ v_GetExtrapolateStr()

virtual std::string Nektar::VelocityCorrectionScheme::v_GetExtrapolateStr ( void  )
inlineprotectedvirtual

Reimplemented in Nektar::VCSImplicit, and Nektar::VCSWeakPressure.

Definition at line 219 of file VelocityCorrectionScheme.h.

220 {
221 return "Standard";
222 }

Referenced by SetUpExtrapolation().

◆ v_GetForceDimension()

int Nektar::VelocityCorrectionScheme::v_GetForceDimension ( void  )
overrideprotectedvirtual

Implements Nektar::IncNavierStokes.

Definition at line 696 of file VelocityCorrectionScheme.cpp.

697{
698 return m_session->GetVariables().size() - 1;
699}

References Nektar::SolverUtils::EquationSystem::m_session.

◆ v_GetSubSteppingExtrapolateStr()

virtual std::string Nektar::VelocityCorrectionScheme::v_GetSubSteppingExtrapolateStr ( const std::string &  instr)
inlineprotectedvirtual

Reimplemented in Nektar::VCSWeakPressure.

Definition at line 224 of file VelocityCorrectionScheme.h.

225 {
226 return instr;
227 }

Referenced by SetUpExtrapolation().

◆ v_GetSystemSingularChecks()

Array< OneD, bool > Nektar::VelocityCorrectionScheme::v_GetSystemSingularChecks ( )
overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 685 of file VelocityCorrectionScheme.cpp.

686{
687 int vVar = m_session->GetVariables().size();
688 Array<OneD, bool> vChecks(vVar, false);
689 vChecks[vVar - 1] = true;
690 return vChecks;
691}

References Nektar::SolverUtils::EquationSystem::m_session.

◆ v_InitObject()

void Nektar::VelocityCorrectionScheme::v_InitObject ( bool  DeclareFeld = true)
overrideprotectedvirtual

Initialisation object for EquationSystem.

Continuous field

Setting up the normals

Setting up the normals

Reimplemented from Nektar::IncNavierStokes.

Definition at line 73 of file VelocityCorrectionScheme.cpp.

74{
75 int n;
76
78 m_explicitDiffusion = false;
79
80 // Set m_pressure to point to last field of m_fields;
81 if (boost::iequals(m_session->GetVariable(m_fields.size() - 1), "p"))
82 {
83 m_nConvectiveFields = m_fields.size() - 1;
85 }
86 else
87 {
88 ASSERTL0(false, "Need to set up pressure field definition");
89 }
90
91 // Determine diffusion coefficients for each field
92 m_diffCoeff = Array<OneD, NekDouble>(m_nConvectiveFields, m_kinvis);
93 for (n = 0; n < m_nConvectiveFields; ++n)
94 {
95 std::string varName = m_session->GetVariable(n);
96 if (m_session->DefinesFunction("DiffusionCoefficient", varName))
97 {
99 m_session->GetFunction("DiffusionCoefficient", varName);
100 m_diffCoeff[n] = ffunc->Evaluate();
101 }
102 }
103
104 // Integrate only the convective fields
105 for (n = 0; n < m_nConvectiveFields; ++n)
106 {
107 m_intVariables.push_back(n);
108 }
109
111 SetUpSVV();
112
113 // check to see if it is explicity turned off
114 m_session->MatchSolverInfo("GJPStabilisation", "False",
116
117 // if GJPStabilisation set to False bool will be true and
118 // if not false so negate/revese bool
120
121 m_session->MatchSolverInfo("GJPNormalVelocity", "True", m_useGJPNormalVel,
122 false);
123
125 {
126 ASSERTL0(boost::iequals(m_session->GetSolverInfo("GJPStabilisation"),
127 "Explicit"),
128 "Can only specify GJPNormalVelocity with"
129 " GJPStabilisation set to Explicit currently");
130 }
131
132 m_session->LoadParameter("GJPJumpScale", m_GJPJumpScale, 1.0);
133
134 m_session->MatchSolverInfo("SmoothAdvection", "True", m_SmoothAdvection,
135 false);
136
137 // set explicit time-intregration class operators
140
141 // set implicit time-intregration class operators
144
145 // Set up bits for flowrate.
146 m_session->LoadParameter("Flowrate", m_flowrate, 0.0);
147 m_session->LoadParameter("IO_FlowSteps", m_flowrateSteps, 0);
148}
void v_InitObject(bool DeclareField=true) override
Initialisation object for EquationSystem.
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
NekDouble m_flowrate
Desired volumetric flowrate.
void EvaluateAdvection_SetPressureBCs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Array< OneD, NekDouble > m_diffCoeff
Diffusion coefficients (will be kinvis for velocities)

References ASSERTL0, Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineImplicitSolve(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), EvaluateAdvection_SetPressureBCs(), m_diffCoeff, Nektar::SolverUtils::UnsteadySystem::m_explicitDiffusion, Nektar::SolverUtils::EquationSystem::m_fields, m_flowrate, m_flowrateSteps, m_GJPJumpScale, Nektar::SolverUtils::UnsteadySystem::m_intVariables, Nektar::IncNavierStokes::m_kinvis, Nektar::IncNavierStokes::m_nConvectiveFields, Nektar::SolverUtils::UnsteadySystem::m_ode, Nektar::IncNavierStokes::m_pressure, Nektar::SolverUtils::EquationSystem::m_session, Nektar::IncNavierStokes::m_SmoothAdvection, m_useGJPNormalVel, m_useGJPStabilisation, SetUpExtrapolation(), SetUpSVV(), SolveUnsteadyStokesSystem(), and Nektar::IncNavierStokes::v_InitObject().

Referenced by Nektar::SmoothedProfileMethod::v_InitObject(), and Nektar::VCSMapping::v_InitObject().

◆ v_PostIntegrate()

bool Nektar::VelocityCorrectionScheme::v_PostIntegrate ( int  step)
overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::AdvectionSystem.

Definition at line 503 of file VelocityCorrectionScheme.cpp.

504{
505 if (m_flowrateSteps > 0)
506 {
507 if (m_comm->GetRank() == 0 && (step + 1) % m_flowrateSteps == 0)
508 {
509 m_flowrateStream << std::setw(8) << step << std::setw(16) << m_time
510 << std::setw(16) << m_alpha << std::endl;
511 }
512 }
513
515}
SOLVER_UTILS_EXPORT bool v_PostIntegrate(int step) override
NekDouble m_alpha
Current flowrate correction.

References m_alpha, Nektar::SolverUtils::EquationSystem::m_comm, m_flowrateSteps, m_flowrateStream, Nektar::SolverUtils::EquationSystem::m_time, and Nektar::SolverUtils::AdvectionSystem::v_PostIntegrate().

◆ v_RequireFwdTrans()

bool Nektar::VelocityCorrectionScheme::v_RequireFwdTrans ( void  )
inlineoverrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 214 of file VelocityCorrectionScheme.h.

215 {
216 return false;
217 }

◆ v_SetUpPressureForcing()

void Nektar::VelocityCorrectionScheme::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 in Nektar::VCSMapping, Nektar::VCSImplicit, and Nektar::VCSWeakPressure.

Definition at line 817 of file VelocityCorrectionScheme.cpp.

820{
821 size_t i;
822 size_t physTot = m_fields[0]->GetTotPoints();
823 size_t nvel = m_velocity.size();
824
825 m_fields[0]->PhysDeriv(eX, fields[0], Forcing[0]);
826
827 for (i = 1; i < nvel; ++i)
828 {
829 // Use Forcing[1] as storage since it is not needed for the pressure
830 m_fields[i]->PhysDeriv(DirCartesianMap[i], fields[i], Forcing[1]);
831 Vmath::Vadd(physTot, Forcing[1], 1, Forcing[0], 1, Forcing[0], 1);
832 }
833
834 Vmath::Smul(physTot, 1.0 / aii_Dt, Forcing[0], 1, Forcing[0], 1);
835}
MultiRegions::Direction const DirCartesianMap[]
Definition: ExpList.h:87
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.hpp:180
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.hpp:100

References Nektar::MultiRegions::DirCartesianMap, Nektar::MultiRegions::eX, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::IncNavierStokes::m_velocity, Vmath::Smul(), and Vmath::Vadd().

Referenced by SetUpPressureForcing(), and Nektar::VCSMapping::v_SetUpPressureForcing().

◆ v_SetUpViscousForcing()

void Nektar::VelocityCorrectionScheme::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 in Nektar::VCSMapping, and Nektar::VCSImplicit.

Definition at line 840 of file VelocityCorrectionScheme.cpp.

843{
844 NekDouble aii_dtinv = 1.0 / aii_Dt;
845 size_t phystot = m_fields[0]->GetTotPoints();
846
847 // Grad p
848 m_pressure->BwdTrans(m_pressure->GetCoeffs(), m_pressure->UpdatePhys());
849
850 int nvel = m_velocity.size();
851 if (nvel == 2)
852 {
853 m_pressure->PhysDeriv(m_pressure->GetPhys(), Forcing[m_velocity[0]],
854 Forcing[m_velocity[1]]);
855 }
856 else
857 {
858 m_pressure->PhysDeriv(m_pressure->GetPhys(), Forcing[m_velocity[0]],
859 Forcing[m_velocity[1]], Forcing[m_velocity[2]]);
860 }
861
862 // zero convective fields.
863 for (int i = nvel; i < m_nConvectiveFields; ++i)
864 {
865 Vmath::Zero(phystot, Forcing[i], 1);
866 }
867
868 // Subtract inarray/(aii_dt) and divide by kinvis. Kinvis will
869 // need to be updated for the convected fields.
870 for (int i = 0; i < m_nConvectiveFields; ++i)
871 {
872 Blas::Daxpy(phystot, -aii_dtinv, inarray[i], 1, Forcing[i], 1);
873 Blas::Dscal(phystot, 1.0 / m_diffCoeff[i], &(Forcing[i])[0], 1);
874 }
875}
static void Dscal(const int &n, const double &alpha, double *x, const int &incx)
BLAS level 1: x = alpha x.
Definition: Blas.hpp:149
static void Daxpy(const int &n, const double &alpha, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: y = alpha x plus y.
Definition: Blas.hpp:135

References Blas::Daxpy(), Blas::Dscal(), m_diffCoeff, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::IncNavierStokes::m_nConvectiveFields, Nektar::IncNavierStokes::m_pressure, Nektar::IncNavierStokes::m_velocity, and Vmath::Zero().

Referenced by SetUpViscousForcing().

◆ v_SolvePressure()

void Nektar::VelocityCorrectionScheme::v_SolvePressure ( const Array< OneD, NekDouble > &  Forcing)
protectedvirtual

Solve pressure system

Reimplemented in Nektar::VCSMapping, Nektar::VCSImplicit, and Nektar::VCSWeakPressure.

Definition at line 880 of file VelocityCorrectionScheme.cpp.

882{
884 // Setup coefficient for equation
886
887 // Solver Pressure Poisson Equation
888 m_pressure->HelmSolve(Forcing, m_pressure->UpdateCoeffs(), factors);
889
890 // Add presure to outflow bc if using convective like BCs
891 m_extrapolation->AddPressureToOutflowBCs(m_kinvis);
892}
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:430

References Nektar::StdRegions::eFactorLambda, Nektar::VarcoeffHashingTest::factors, Nektar::IncNavierStokes::m_extrapolation, Nektar::IncNavierStokes::m_kinvis, and Nektar::IncNavierStokes::m_pressure.

Referenced by SolvePressure(), and Nektar::VCSMapping::v_SolvePressure().

◆ v_SolveUnsteadyStokesSystem()

void Nektar::VelocityCorrectionScheme::v_SolveUnsteadyStokesSystem ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time,
const NekDouble  aii_Dt 
)
protectedvirtual

Implicit part of the method - Poisson + nConv*Helmholtz

Reimplemented in Nektar::SmoothedProfileMethod.

Definition at line 750 of file VelocityCorrectionScheme.cpp.

754{
755 // Set up flowrate if we're starting for the first time or the value of
756 // aii_Dt has changed.
757 if (m_flowrate > 0.0 && (aii_Dt != m_flowrateAiidt))
758 {
759 SetupFlowrate(aii_Dt);
760 }
761
762 size_t physTot = m_fields[0]->GetTotPoints();
763
764 // Substep the pressure boundary condition if using substepping
765 m_extrapolation->SubStepSetPressureBCs(inarray, aii_Dt, m_kinvis);
766
767 // Set up forcing term for pressure Poisson equation
768 LibUtilities::Timer timer;
769 timer.Start();
770 SetUpPressureForcing(inarray, m_F, aii_Dt);
771 timer.Stop();
772 timer.AccumulateRegion("Pressure Forcing");
773
774 // Solve Pressure System
775 timer.Start();
776 SolvePressure(m_F[0]);
777 timer.Stop();
778 timer.AccumulateRegion("Pressure Solve");
779
780 // Set up forcing term for Helmholtz problems
781 timer.Start();
782 SetUpViscousForcing(inarray, m_F, aii_Dt);
783 timer.Stop();
784 timer.AccumulateRegion("Viscous Forcing");
785
786 // Solve velocity system
787 timer.Start();
788 SolveViscous(m_F, inarray, outarray, aii_Dt);
789 timer.Stop();
790 timer.AccumulateRegion("Viscous Solve");
791
792 // Apply flowrate correction
793 if (m_flowrate > 0.0 &&
794 m_greenFlux != std::numeric_limits<NekDouble>::max())
795 {
796 NekDouble currentFlux = MeasureFlowrate(outarray);
797 m_alpha = (m_flowrate - currentFlux) / m_greenFlux;
798
799 for (int i = 0; i < m_spacedim; ++i)
800 {
801 Vmath::Svtvp(physTot, m_alpha, m_flowrateStokes[i], 1, outarray[i],
802 1, outarray[i], 1);
803 // Enusre coeff space is updated for next time step
804 m_fields[i]->FwdTransLocalElmt(outarray[i],
805 m_fields[i]->UpdateCoeffs());
806 // Impsoe symmetry of flow on coeff space (good to enfore
807 // periodicity).
808 m_fields[i]->LocalToGlobal();
809 m_fields[i]->GlobalToLocal();
810 }
811 }
812}
void SetUpViscousForcing(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &Forcing, const NekDouble aii_Dt)
void SetupFlowrate(NekDouble aii_dt)
Set up the Stokes solution used to impose constant flowrate through a boundary.
void SetUpPressureForcing(const Array< OneD, const Array< OneD, NekDouble > > &fields, Array< OneD, Array< OneD, NekDouble > > &Forcing, const NekDouble aii_Dt)
void SolveViscous(const Array< OneD, const Array< OneD, NekDouble > > &Forcing, const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble aii_Dt)
void SolvePressure(const Array< OneD, NekDouble > &Forcing)
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Svtvp (scalar times vector plus vector): z = alpha*x + y.
Definition: Vmath.hpp:396

References Nektar::LibUtilities::Timer::AccumulateRegion(), m_alpha, Nektar::IncNavierStokes::m_extrapolation, m_F, Nektar::SolverUtils::EquationSystem::m_fields, m_flowrate, m_flowrateAiidt, m_flowrateStokes, m_greenFlux, Nektar::IncNavierStokes::m_kinvis, Nektar::SolverUtils::EquationSystem::m_spacedim, MeasureFlowrate(), SetupFlowrate(), SetUpPressureForcing(), SetUpViscousForcing(), SolvePressure(), SolveViscous(), Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Vmath::Svtvp().

Referenced by SolveUnsteadyStokesSystem(), and Nektar::SmoothedProfileMethod::v_SolveUnsteadyStokesSystem().

◆ v_SolveViscous()

void Nektar::VelocityCorrectionScheme::v_SolveViscous ( const Array< OneD, const Array< OneD, NekDouble > > &  Forcing,
const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  aii_Dt 
)
protectedvirtual

Solve velocity system

Reimplemented in Nektar::VCSMapping, and Nektar::VCSImplicit.

Definition at line 897 of file VelocityCorrectionScheme.cpp.

901{
905
906 AppendSVVFactors(factors, varFactorsMap);
907 ComputeGJPNormalVelocity(inarray, varCoeffMap);
908
909 // Solve Helmholtz system and put in Physical space
910 for (int i = 0; i < m_nConvectiveFields; ++i)
911 {
912 // Add diffusion coefficient to GJP matrix operator (Implicit part)
914 {
916 }
917
918 // Setup coefficients for equation
919 factors[StdRegions::eFactorLambda] = 1.0 / aii_Dt / m_diffCoeff[i];
920 m_fields[i]->HelmSolve(Forcing[i], m_fields[i]->UpdateCoeffs(), factors,
921 varCoeffMap, varFactorsMap);
922 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(), outarray[i]);
923 }
924}
void AppendSVVFactors(StdRegions::ConstFactorMap &factors, MultiRegions::VarFactorsMap &varFactorsMap)
void ComputeGJPNormalVelocity(const Array< OneD, const Array< OneD, NekDouble > > &inarray, StdRegions::VarCoeffMap &varcoeffs)
static VarFactorsMap NullVarFactorsMap
std::map< StdRegions::ConstFactorType, Array< OneD, NekDouble > > VarFactorsMap
std::map< StdRegions::VarCoeffType, VarCoeffEntry > VarCoeffMap
Definition: StdRegions.hpp:375

References AppendSVVFactors(), ComputeGJPNormalVelocity(), Nektar::StdRegions::eFactorGJP, Nektar::StdRegions::eFactorLambda, Nektar::VarcoeffHashingTest::factors, m_diffCoeff, Nektar::SolverUtils::EquationSystem::m_fields, m_GJPJumpScale, Nektar::IncNavierStokes::m_nConvectiveFields, m_useGJPStabilisation, Nektar::StdRegions::NullVarCoeffMap, and Nektar::MultiRegions::NullVarFactorsMap.

Referenced by SolveViscous(), and Nektar::VCSMapping::v_SolveViscous().

◆ v_TransCoeffToPhys()

void Nektar::VelocityCorrectionScheme::v_TransCoeffToPhys ( void  )
overrideprotectedvirtual

Virtual function for transformation to physical space.

Reimplemented from Nektar::IncNavierStokes.

Definition at line 656 of file VelocityCorrectionScheme.cpp.

657{
658 size_t nfields = m_fields.size() - 1;
659 for (size_t k = 0; k < nfields; ++k)
660 {
661 // Backward Transformation in physical space for time evolution
662 m_fields[k]->BwdTrans(m_fields[k]->GetCoeffs(),
663 m_fields[k]->UpdatePhys());
664 }
665}

References Nektar::SolverUtils::EquationSystem::m_fields.

◆ v_TransPhysToCoeff()

void Nektar::VelocityCorrectionScheme::v_TransPhysToCoeff ( void  )
overrideprotectedvirtual

Virtual function for transformation to coefficient space.

Reimplemented from Nektar::IncNavierStokes.

Definition at line 670 of file VelocityCorrectionScheme.cpp.

671{
672
673 size_t nfields = m_fields.size() - 1;
674 for (size_t k = 0; k < nfields; ++k)
675 {
676 // Forward Transformation in physical space for time evolution
677 m_fields[k]->FwdTransLocalElmt(m_fields[k]->GetPhys(),
678 m_fields[k]->UpdateCoeffs());
679 }
680}

References Nektar::SolverUtils::EquationSystem::m_fields.

Friends And Related Function Documentation

◆ MemoryManager< VelocityCorrectionScheme >

friend class MemoryManager< VelocityCorrectionScheme >
friend

Definition at line 247 of file VelocityCorrectionScheme.h.

Member Data Documentation

◆ className

std::string Nektar::VelocityCorrectionScheme::className
static
Initial value:
=
"VelocityCorrectionScheme", VelocityCorrectionScheme::create)
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
static SolverUtils::EquationSystemSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Creates an instance of this class.
EquationSystemFactory & GetEquationSystemFactory()

Name of class.

Definition at line 60 of file VelocityCorrectionScheme.h.

◆ m_alpha

NekDouble Nektar::VelocityCorrectionScheme::m_alpha
protected

Current flowrate correction.

Definition at line 143 of file VelocityCorrectionScheme.h.

Referenced by v_PostIntegrate(), and v_SolveUnsteadyStokesSystem().

◆ m_diffCoeff

Array<OneD, NekDouble> Nektar::VelocityCorrectionScheme::m_diffCoeff
protected

◆ m_F

Array<OneD, Array<OneD, NekDouble> > Nektar::VelocityCorrectionScheme::m_F
protected

◆ m_flowrate

NekDouble Nektar::VelocityCorrectionScheme::m_flowrate
protected

Desired volumetric flowrate.

Definition at line 135 of file VelocityCorrectionScheme.h.

Referenced by v_InitObject(), and v_SolveUnsteadyStokesSystem().

◆ m_flowrateAiidt

NekDouble Nektar::VelocityCorrectionScheme::m_flowrateAiidt
protected

Value of aii_dt used to compute Stokes flowrate solution.

Definition at line 157 of file VelocityCorrectionScheme.h.

Referenced by SetupFlowrate(), v_DoInitialise(), and v_SolveUnsteadyStokesSystem().

◆ m_flowrateArea

NekDouble Nektar::VelocityCorrectionScheme::m_flowrateArea
protected

Area of the boundary through which we are measuring the flowrate.

Definition at line 137 of file VelocityCorrectionScheme.h.

Referenced by MeasureFlowrate(), and SetupFlowrate().

◆ m_flowrateBnd

MultiRegions::ExpListSharedPtr Nektar::VelocityCorrectionScheme::m_flowrateBnd
protected

Flowrate reference surface.

Definition at line 149 of file VelocityCorrectionScheme.h.

Referenced by MeasureFlowrate(), and SetupFlowrate().

◆ m_flowrateBndID

int Nektar::VelocityCorrectionScheme::m_flowrateBndID
protected

Boundary ID of the flowrate reference surface.

Definition at line 145 of file VelocityCorrectionScheme.h.

Referenced by MeasureFlowrate(), and SetupFlowrate().

◆ m_flowrateSteps

int Nektar::VelocityCorrectionScheme::m_flowrateSteps
protected

Interval at which to record flowrate data.

Definition at line 155 of file VelocityCorrectionScheme.h.

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

◆ m_flowrateStokes

Array<OneD, Array<OneD, NekDouble> > Nektar::VelocityCorrectionScheme::m_flowrateStokes
protected

Stokes solution used to impose flowrate.

Definition at line 151 of file VelocityCorrectionScheme.h.

Referenced by SetupFlowrate(), and v_SolveUnsteadyStokesSystem().

◆ m_flowrateStream

std::ofstream Nektar::VelocityCorrectionScheme::m_flowrateStream
protected

Output stream to record flowrate.

Definition at line 153 of file VelocityCorrectionScheme.h.

Referenced by SetupFlowrate(), and v_PostIntegrate().

◆ m_GJPJumpScale

NekDouble Nektar::VelocityCorrectionScheme::m_GJPJumpScale
protected

◆ m_greenFlux

NekDouble Nektar::VelocityCorrectionScheme::m_greenFlux
protected

Flux of the Stokes function solution.

Definition at line 141 of file VelocityCorrectionScheme.h.

Referenced by SetupFlowrate(), and v_SolveUnsteadyStokesSystem().

◆ m_homd1DFlowinPlane

bool Nektar::VelocityCorrectionScheme::m_homd1DFlowinPlane
protected

Definition at line 139 of file VelocityCorrectionScheme.h.

Referenced by MeasureFlowrate(), and SetupFlowrate().

◆ m_IsSVVPowerKernel

bool Nektar::VelocityCorrectionScheme::m_IsSVVPowerKernel
protected

Identifier for Power Kernel otherwise DG kernel.

Definition at line 126 of file VelocityCorrectionScheme.h.

Referenced by AppendSVVFactors(), SetUpSVV(), v_GenerateSummary(), and Nektar::VCSImplicit::v_GenerateSummary().

◆ m_planeID

int Nektar::VelocityCorrectionScheme::m_planeID
protected

Plane ID for cases with homogeneous expansion.

Definition at line 147 of file VelocityCorrectionScheme.h.

Referenced by MeasureFlowrate(), and SetupFlowrate().

◆ m_sVVCutoffRatio

NekDouble Nektar::VelocityCorrectionScheme::m_sVVCutoffRatio
protected

◆ m_sVVCutoffRatioHomo1D

NekDouble Nektar::VelocityCorrectionScheme::m_sVVCutoffRatioHomo1D
protected

◆ m_sVVDiffCoeff

NekDouble Nektar::VelocityCorrectionScheme::m_sVVDiffCoeff
protected

◆ m_sVVDiffCoeffHomo1D

NekDouble Nektar::VelocityCorrectionScheme::m_sVVDiffCoeffHomo1D
protected

Diffusion coefficient of SVV modes in homogeneous 1D Direction.

Definition at line 122 of file VelocityCorrectionScheme.h.

Referenced by SetUpSVV(), v_GenerateSummary(), and Nektar::VCSImplicit::v_GenerateSummary().

◆ m_svvVarDiffCoeff

Array<OneD, NekDouble> Nektar::VelocityCorrectionScheme::m_svvVarDiffCoeff
protected

Array of coefficient if power kernel is used in SVV.

Definition at line 124 of file VelocityCorrectionScheme.h.

Referenced by AppendSVVFactors(), SetUpSVV(), v_GenerateSummary(), and Nektar::VCSImplicit::v_GenerateSummary().

◆ m_useGJPNormalVel

bool Nektar::VelocityCorrectionScheme::m_useGJPNormalVel
protected

bool to identify if GJP normal Velocity should be applied in explicit approach

Definition at line 113 of file VelocityCorrectionScheme.h.

Referenced by ComputeGJPNormalVelocity(), and v_InitObject().

◆ m_useGJPStabilisation

bool Nektar::VelocityCorrectionScheme::m_useGJPStabilisation
protected

◆ m_useHomo1DSpecVanVisc

bool Nektar::VelocityCorrectionScheme::m_useHomo1DSpecVanVisc
protected

bool to identify if spectral vanishing viscosity is active.

Definition at line 106 of file VelocityCorrectionScheme.h.

Referenced by SetUpSVV(), v_GenerateSummary(), Nektar::VCSImplicit::v_GenerateSummary(), and Nektar::VCSWeakPressure::v_GenerateSummary().

◆ m_useSpecVanVisc

bool Nektar::VelocityCorrectionScheme::m_useSpecVanVisc
protected

◆ m_varCoeffLap

StdRegions::VarCoeffMap Nektar::VelocityCorrectionScheme::m_varCoeffLap
protected

Variable Coefficient map for the Laplacian which can be activated as part of SVV or otherwise.

Definition at line 132 of file VelocityCorrectionScheme.h.

◆ solverTypeLookupId

std::string Nektar::VelocityCorrectionScheme::solverTypeLookupId
staticprotected
Initial value:
=
"SolverType", "VelocityCorrectionScheme", eVelocityCorrectionScheme)
static std::string RegisterEnumValue(std::string pEnum, std::string pString, int pEnumValue)
Registers an enumeration value.
@ eVelocityCorrectionScheme

Definition at line 161 of file VelocityCorrectionScheme.h.