Nektar++
Loading...
Searching...
No Matches
Static Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | Friends | List of all members
Nektar::NavierStokesCFE Class Reference

#include <NavierStokesCFE.h>

Inheritance diagram for Nektar::NavierStokesCFE:
[legend]

Static Public Member Functions

static SolverUtils::EquationSystemSharedPtr create (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 

Static Public Attributes

static std::string className
 
- Static Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
static std::string cmdSetStartTime
 
static std::string cmdSetStartChkNum
 

Protected Member Functions

 NavierStokesCFE (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
 ~NavierStokesCFE () override=default
 
void GetViscousFluxVectorConservVar (const size_t nDim, const Array< OneD, Array< OneD, NekDouble > > &inarray, const TensorOfArray3D< NekDouble > &qfields, TensorOfArray3D< NekDouble > &outarray, Array< OneD, int > &nonZeroIndex=NullInt1DArray, const Array< OneD, Array< OneD, NekDouble > > &normal=NullNekDoubleArrayOfArray)
 
void GetViscousSymmtrFluxConservVar (const size_t nSpaceDim, const Array< OneD, Array< OneD, NekDouble > > &inaverg, const Array< OneD, Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &outarray, Array< OneD, int > &nonZeroIndex, const Array< OneD, Array< OneD, NekDouble > > &normals)
 Calculate and return the Symmetric flux in IP method.
 
void SpecialBndTreat (Array< OneD, Array< OneD, NekDouble > > &consvar)
 For very special treatment. For general boundaries it does nothing But for WallViscous and WallAdiabatic, special treatment is needed because they get the same Bwd value, special treatment is needed for boundary treatment of diffusion flux Note: This special treatment could be removed by seperating WallViscous and WallAdiabatic into two different classes.
 
void GetArtificialViscosity (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &muav)
 
void CalcViscosity (const Array< OneD, const Array< OneD, NekDouble > > &inaverg, Array< OneD, NekDouble > &mu)
 
void InitObject_Explicit ()
 
void v_InitObject (bool DeclareField=true) override
 Initialization object for CompressibleFlowSystem class.
 
void v_DoDiffusion (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd) override
 
virtual void v_GetViscousFluxVector (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &derivatives, TensorOfArray3D< NekDouble > &viscousTensor)
 Return the flux vector for the LDG diffusion problem.
 
virtual void v_GetViscousFluxVectorDeAlias (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &derivatives, TensorOfArray3D< NekDouble > &viscousTensor)
 Return the flux vector for the LDG diffusion problem.
 
void GetPhysicalAV (const Array< OneD, const Array< OneD, NekDouble > > &physfield)
 
void Ducros (Array< OneD, NekDouble > &field)
 
void C0Smooth (Array< OneD, NekDouble > &field)
 
virtual void v_GetFluxPenalty (const Array< OneD, const Array< OneD, NekDouble > > &uFwd, const Array< OneD, const Array< OneD, NekDouble > > &uBwd, Array< OneD, Array< OneD, NekDouble > > &penaltyCoeff)
 Return the penalty vector for the LDGNS diffusion problem.
 
void GetViscosityAndThermalCondFromTemp (const Array< OneD, NekDouble > &temperature, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &thermalCond)
 Update viscosity todo: add artificial viscosity here.
 
void GetDivCurlSquared (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &cnsVar, Array< OneD, NekDouble > &div, Array< OneD, NekDouble > &curlSquare, const Array< OneD, Array< OneD, NekDouble > > &cnsVarFwd, const Array< OneD, Array< OneD, NekDouble > > &cnsVarBwd)
 Get divergence and curl squared.
 
void GetDivCurlFromDvelT (const TensorOfArray3D< NekDouble > &pVarDer, Array< OneD, NekDouble > &div, Array< OneD, NekDouble > &curlSquare)
 Get divergence and curl from velocity derivative tensor.
 
void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables) override
 
template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>
void GetViscosityAndThermalCondFromTempKernel (const T &temperature, T &mu, T &thermalCond)
 
template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>
void GetViscosityFromTempKernel (const T &temperature, T &mu)
 
template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>
void GetViscousFluxBilinearFormKernel (const unsigned short nDim, const unsigned short FluxDirection, const unsigned short DerivDirection, const T *inaverg, const T *injumpp, const T &mu, T *outarray)
 Calculate diffusion flux using the Jacobian form.
 
template<bool IS_TRACE>
void GetViscousFluxVectorConservVar (const size_t nDim, const Array< OneD, Array< OneD, NekDouble > > &inarray, const TensorOfArray3D< NekDouble > &qfields, TensorOfArray3D< NekDouble > &outarray, Array< OneD, int > &nonZeroIndex, const Array< OneD, Array< OneD, NekDouble > > &normal)
 Return the flux vector for the IP diffusion problem, based on conservative variables.
 
bool v_SupportsShockCaptType (const std::string type) const override
 
- Protected Member Functions inherited from Nektar::CompressibleFlowSystem
 CompressibleFlowSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
 ~CompressibleFlowSystem () override=default
 
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_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields) override
 
void InitialiseParameters ()
 Load CFS parameters from the session file.
 
void InitAdvection ()
 Create advection and diffusion objects for CFS.
 
void DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Compute the right-hand side.
 
void DoOdeProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Compute the projection and call the method for imposing the boundary conditions in case of discontinuous projection.
 
void DoAdvection (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)
 Compute the advection terms for the right-hand side.
 
void DoDiffusion (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)
 Add the diffusions terms to the right-hand side.
 
void GetFluxVector (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &flux)
 Return the flux vector for the compressible Euler equations.
 
void GetFluxVectorDeAlias (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &flux)
 Return the flux vector for the compressible Euler equations by using the de-aliasing technique.
 
void SetBoundaryConditions (Array< OneD, Array< OneD, NekDouble > > &physarray, NekDouble time)
 
void SetBoundaryConditionsBwdWeight ()
 Set up a weight on physical boundaries for boundary condition applications.
 
void GetElmtTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &tstep)
 Calculate the maximum timestep on each element subject to CFL restrictions.
 
NekDouble v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray) override
 Calculate the maximum timestep subject to CFL restrictions.
 
void v_GenerateSummary (SolverUtils::SummaryList &s) override
 Print a summary of time stepping parameters.
 
void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) override
 Set up logic for residual calculation.
 
void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time=0.0) override
 
NekDouble GetGamma ()
 
const Array< OneD, const Array< OneD, NekDouble > > & GetVecLocs ()
 
const Array< OneD, const Array< OneD, NekDouble > > & GetNormals ()
 
MultiRegions::ExpListSharedPtr v_GetPressure () override
 
Array< OneD, NekDouble > v_GetMaxStdVelocity (const NekDouble SpeedSoundFactor) override
 Compute the advection velocity in the standard space for each element of the expansion.
 
void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2) override
 
- Protected Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step) override
 
- Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises UnsteadySystem class members.
 
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Init object for UnsteadySystem class.
 
SOLVER_UTILS_EXPORT void v_DoSolve () override
 Solves an unsteady problem.
 
virtual SOLVER_UTILS_EXPORT void v_PrintStatusInformation (const int step, const NekDouble cpuTime)
 Print Status Information.
 
virtual SOLVER_UTILS_EXPORT void v_PrintSummaryStatistics (const NekDouble intTime)
 Print Summary Statistics.
 
SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true) override
 Sets up initial conditions.
 
SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &s) override
 Print a summary of time stepping parameters.
 
virtual SOLVER_UTILS_EXPORT bool v_PreIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_RequireFwdTrans ()
 
virtual SOLVER_UTILS_EXPORT bool v_UpdateTimeStepCheck ()
 
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control.
 
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.
 
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.
 
- Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises EquationSystem class members.
 
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.
 
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.
 
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.
 
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys ()
 Virtual function for transformation to physical space.
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space.
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp (void)
 Virtual function to identify if operator is negated in DoSolve.
 
- Protected Member Functions inherited from Nektar::SolverUtils::FluidInterface
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

std::string m_ViscosityType
 
bool m_is_mu_variable {false}
 flag to switch between constant viscosity and Sutherland an enum could be added for more options
 
bool m_is_diffIP {false}
 flag to switch between IP and LDG an enum could be added for more options
 
bool m_is_shockCaptPhys {false}
 flag for shock capturing switch on/off an enum could be added for more options
 
NekDouble m_Cp
 
NekDouble m_Cv
 
NekDouble m_Prandtl
 
std::string m_physicalSensorType
 
std::string m_smoothing
 
MultiRegions::ContFieldSharedPtr m_C0ProjectExp
 
EquationOfStateSharedPtr m_eos
 Equation of system for computing temperature.
 
NekDouble m_Twall
 
NekDouble m_muRef
 
NekDouble m_thermalConductivityRef
 
- Protected Attributes inherited from Nektar::CompressibleFlowSystem
SolverUtils::DiffusionSharedPtr m_diffusion
 
ArtificialDiffusionSharedPtr m_artificialDiffusion
 
Array< OneD, Array< OneD, NekDouble > > m_vecLocs
 
NekDouble m_gamma
 
std::string m_shockCaptureType
 
NekDouble m_filterAlpha
 
NekDouble m_filterExponent
 
NekDouble m_filterCutoff
 
bool m_useFiltering
 
bool m_useLocalTimeStep
 
Array< OneD, NekDouble > m_muav
 
Array< OneD, NekDouble > m_muavTrace
 
VariableConverterSharedPtr m_varConv
 
std::vector< CFSBndCondSharedPtr > m_bndConds
 
NekDouble m_bndEvaluateTime
 
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
 
- Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem
SolverUtils::AdvectionSharedPtr m_advObject
 Advection term.
 
- Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
LibUtilities::TimeIntegrationSchemeSharedPtr m_intScheme
 Wrapper to the time integration scheme.
 
LibUtilities::TimeIntegrationSchemeOperators m_ode
 The time integration scheme operators to use.
 
Array< OneD, Array< OneD, NekDouble > > m_previousSolution
 Storage for previous solution for steady-state check.
 
std::vector< int > m_intVariables
 
NekDouble m_cflSafetyFactor
 CFL safety factor (comprise between 0 to 1).
 
NekDouble m_CFLGrowth
 CFL growth rate.
 
NekDouble m_CFLEnd
 Maximun cfl in cfl growth.
 
int m_abortSteps
 Number of steps between checks for abort conditions.
 
bool m_explicitDiffusion
 Indicates if explicit or implicit treatment of diffusion is used.
 
bool m_explicitAdvection
 Indicates if explicit or implicit treatment of advection is used.
 
bool m_explicitReaction
 Indicates if explicit or implicit treatment of reaction is used.
 
int m_steadyStateSteps
 Check for steady state at step interval.
 
NekDouble m_steadyStateTol
 Tolerance to which steady state should be evaluated at.
 
int m_filtersInfosteps
 Number of time steps between outputting filters information.
 
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
 
bool m_homoInitialFwd
 Flag to determine if simulation should start in homogeneous forward transformed state.
 
std::ofstream m_errFile
 
NekDouble m_epsilon
 Diffusion coefficient.
 
- Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr m_comm
 Communicator.
 
bool m_verbose
 
LibUtilities::SessionReaderSharedPtr m_session
 The session reader.
 
std::map< std::string, SolverUtils::SessionFunctionSharedPtr > m_sessionFunctions
 Map of known SessionFunctions.
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output.
 
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
 Array holding all dependent variables.
 
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
 Pointer to boundary conditions object.
 
SpatialDomains::MeshGraphSharedPtr m_graph
 Pointer to graph defining mesh.
 
std::string m_sessionName
 Name of the session.
 
NekDouble m_time
 Current time of simulation.
 
int m_initialStep
 Number of the step where the simulation should begin.
 
NekDouble m_fintime
 Finish time of the simulation.
 
NekDouble m_timestep
 Time step size.
 
NekDouble m_lambda
 Lambda constant in real system if one required.
 
NekDouble m_checktime
 Time between checkpoints.
 
NekDouble m_lastCheckTime
 
NekDouble m_TimeIncrementFactor
 
int m_nchk
 Number of checkpoints written so far.
 
int m_steps
 Number of steps to take.
 
int m_checksteps
 Number of steps between checkpoints.
 
int m_infosteps
 Number of time steps between outputting status information.
 
int m_iterPIT = 0
 Number of parallel-in-time time iteration.
 
int m_windowPIT = 0
 Index of windows for parallel-in-time time iteration.
 
int m_spacedim
 Spatial dimension (>= expansion dim).
 
int m_expdim
 Expansion dimension.
 
bool m_singleMode
 Flag to determine if single homogeneous mode is used.
 
bool m_halfMode
 Flag to determine if half homogeneous mode is used.
 
bool m_multipleModes
 Flag to determine if use multiple homogenenous modes are used.
 
bool m_useFFT
 Flag to determine if FFT is used for homogeneous transform.
 
bool m_homogen_dealiasing
 Flag to determine if dealiasing is used for homogeneous simulations.
 
bool m_specHP_dealiasing
 Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
 
enum MultiRegions::ProjectionType m_projectionType
 Type of projection; e.g continuous or discontinuous.
 
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
 Array holding trace normals for DG simulations in the forwards direction.
 
Array< OneD, bool > m_checkIfSystemSingular
 Flag to indicate if the fields should be checked for singularity.
 
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, 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.
 
std::vector< std::string > m_strFrameData
 variable name in m_movingFrameData
 
int m_NumQuadPointsError
 Number of Quadrature points used to work out the error.
 
enum HomogeneousType m_HomogeneousType
 
NekDouble m_LhomX
 physical length in X direction (if homogeneous)
 
NekDouble m_LhomY
 physical length in Y direction (if homogeneous)
 
NekDouble m_LhomZ
 physical length in Z direction (if homogeneous)
 
int m_npointsX
 number of points in X direction (if homogeneous)
 
int m_npointsY
 number of points in Y direction (if homogeneous)
 
int m_npointsZ
 number of points in Z direction (if homogeneous)
 
int m_HomoDirec
 number of homogenous directions
 
- Protected Attributes inherited from Nektar::SolverUtils::ALEHelper
Array< OneD, MultiRegions::ExpListSharedPtr > m_fieldsALE
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocity
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
 
std::vector< ALEBaseShPtr > m_ALEs
 
bool m_ALESolver = false
 
bool m_meshDistorted = false
 
bool m_implicitALESolver = false
 
bool m_updateNormals = false
 
NekDouble m_prevStageTime = 0.0
 
int m_spaceDim
 

Friends

class MemoryManager< NavierStokesCFE >
 

Additional Inherited Members

- Public Member Functions inherited from Nektar::CompressibleFlowSystem
NekDouble GetStabilityLimit (int n)
 Function to calculate the stability limit for DG/CG.
 
Array< OneD, NekDouble > GetStabilityLimitVector (const Array< OneD, int > &ExpOrder)
 Function to calculate the stability limit for DG/CG (a vector of them).
 
- 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.
 
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > GetElmtCFLVals (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.
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Calculate the larger time-step mantaining the problem stable.
 
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::TimeIntegrationSchemeSharedPtr & GetTimeIntegrationScheme ()
 Returns the time integration scheme.
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeOperators & GetTimeIntegrationSchemeOperators ()
 Returns the time integration scheme operators.
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor.
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object.
 
SOLVER_UTILS_EXPORT void DoInitialise (bool dumpInitialConditions=true)
 Perform any initialisation necessary before solving the problem.
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem.
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space.
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space.
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve.
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name.
 
template<class T >
std::shared_ptr< T > as ()
 
SOLVER_UTILS_EXPORT void ResetSessionName (std::string newname)
 Reset Session name.
 
SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr GetSession ()
 Get Session name.
 
SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr GetPressure ()
 Get pressure field if available.
 
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.
 
SOLVER_UTILS_EXPORT void SetLambda (NekDouble lambda)
 Set parameter m_lambda.
 
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
 Get a SessionFunction by name.
 
SOLVER_UTILS_EXPORT void SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Initialise the data in the dependent fields.
 
SOLVER_UTILS_EXPORT void EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 Evaluates an exact solution.
 
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.
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, bool Normalised=false)
 Compute the L2 error of the fields.
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation.
 
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.
 
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > ErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf].
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n)
 Write checkpoint file of m_fields.
 
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.
 
SOLVER_UTILS_EXPORT void Checkpoint_BaseFlow (const int n)
 Write base flow file of m_fields.
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname)
 Write field data to the given filename.
 
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.
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
 Input field data from the given file.
 
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.
 
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.
 
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.
 
SOLVER_UTILS_EXPORT void SessionSummary (SummaryList &vSummary)
 Write out a session summary.
 
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > & UpdateFields ()
 
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMap & UpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated.
 
SOLVER_UTILS_EXPORT NekDouble GetTime ()
 Return final time.
 
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.
 
SOLVER_UTILS_EXPORT bool NegatedOp ()
 Identify if operator is negated in DoSolve.
 
- Public Member Functions inherited from Nektar::SolverUtils::ALEHelper
virtual ~ALEHelper ()=default
 
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.
 
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)
 
SOLVER_UTILS_EXPORT void ResetMatricesNormal (Array< OneD, Array< OneD, NekDouble > > &traceNormals)
 
SOLVER_UTILS_EXPORT void UpdateNormalsFlag ()
 
const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocity ()
 
bool & GetUpdateNormalsFlag ()
 
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)
 
SOLVER_UTILS_EXPORT void ExtraFldOutputGrid (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.
 
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.
 
SOLVER_UTILS_EXPORT void GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)
 Extract array with pressure from physfield.
 
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.
 
SOLVER_UTILS_EXPORT void GetAeroForce (Array< OneD, NekDouble > forces)
 Get aerodynamic force and moment.
 
- Protected Types inherited from Nektar::SolverUtils::EquationSystem
enum  HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous }
 Parameter for homogeneous expansions. More...
 
- Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
static std::string equationSystemTypeLookupIds []
 
static std::string projectionTypeLookupIds []
 

Detailed Description

Definition at line 50 of file NavierStokesCFE.h.

Constructor & Destructor Documentation

◆ NavierStokesCFE()

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

Definition at line 45 of file NavierStokesCFE.cpp.

48 : UnsteadySystem(pSession, pGraph), CompressibleFlowSystem(pSession, pGraph)
49{
50}
Nektar::SolverUtils::UnsteadySystem
Base class for unsteady solvers.
Definition UnsteadySystem.h:47

◆ ~NavierStokesCFE()

Nektar::NavierStokesCFE::~NavierStokesCFE ( )
overrideprotecteddefault

Member Function Documentation

◆ C0Smooth()

void Nektar::NavierStokesCFE::C0Smooth ( Array< OneD, NekDouble > &  field)
protected

◆ CalcViscosity()

void Nektar::NavierStokesCFE::CalcViscosity ( const Array< OneD, const Array< OneD, NekDouble > > &  inaverg,
Array< OneD, NekDouble > &  mu 
)
protected

◆ create()

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

Definition at line 56 of file NavierStokesCFE.h.

59 {
60 SolverUtils::EquationSystemSharedPtr p =
61 MemoryManager<NavierStokesCFE>::AllocateSharedPtr(pSession, pGraph);
62 p->InitObject();
63 return p;
64 }
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition NekMemoryManager.hpp:166
Nektar::SolverUtils::EquationSystemSharedPtr
std::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.
Definition EquationSystem.h:65
Nektar::UnitTests::p
std::vector< double > p(NPUPPER)

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

◆ Ducros()

void Nektar::NavierStokesCFE::Ducros ( Array< OneD, NekDouble > &  field)
protected

◆ GetArtificialViscosity()

void Nektar::NavierStokesCFE::GetArtificialViscosity ( const Array< OneD, Array< OneD, NekDouble > > &  inarray,
Array< OneD, NekDouble > &  muav 
)
protected

◆ GetDivCurlFromDvelT()

void Nektar::NavierStokesCFE::GetDivCurlFromDvelT ( const TensorOfArray3D< NekDouble > &  pVarDer,
Array< OneD, NekDouble > &  div,
Array< OneD, NekDouble > &  curlSquare 
)
protected

Get divergence and curl from velocity derivative tensor.

Definition at line 785 of file NavierStokesCFE.cpp.

788{
789 size_t nDim = pVarDer.size();
790 size_t nPts = div.size();
791
792 // div velocity
793 for (size_t p = 0; p < nPts; ++p)
794 {
795 NekDouble divTmp = 0;
796 for (unsigned short j = 0; j < nDim; ++j)
797 {
798 divTmp += pVarDer[j][j][p];
799 }
800 div[p] = divTmp;
801 }
802
803 // |curl velocity| ** 2
804 if (nDim > 2)
805 {
806 for (size_t p = 0; p < nPts; ++p)
807 {
808 // curl[0] 3/2 - 2/3
809 NekDouble curl032 = pVarDer[2][1][p]; // load 1x
810 NekDouble curl023 = pVarDer[1][2][p]; // load 1x
811 NekDouble curl0 = curl032 - curl023;
812 // square curl[0]
813 NekDouble curl0sqr = curl0 * curl0;
814
815 // curl[1] 3/1 - 1/3
816 NekDouble curl131 = pVarDer[2][0][p]; // load 1x
817 NekDouble curl113 = pVarDer[0][2][p]; // load 1x
818 NekDouble curl1 = curl131 - curl113;
819 // square curl[1]
820 NekDouble curl1sqr = curl1 * curl1;
821
822 // curl[2] 1/2 - 2/1
823 NekDouble curl212 = pVarDer[0][1][p]; // load 1x
824 NekDouble curl221 = pVarDer[1][0][p]; // load 1x
825 NekDouble curl2 = curl212 - curl221;
826 // square curl[2]
827 NekDouble curl2sqr = curl2 * curl2;
828
829 // reduce
830 curl0sqr += curl1sqr + curl2sqr;
831 // store
832 curlSquare[p] = curl0sqr; // store 1x
833 }
834 }
835 else if (nDim > 1)
836 {
837 for (size_t p = 0; p < nPts; ++p)
838 {
839 // curl[2] 1/2
840 NekDouble c212 = pVarDer[0][1][p]; // load 1x
841 // curl[2] 2/1
842 NekDouble c221 = pVarDer[1][0][p]; // load 1x
843 // curl[2] 1/2 - 2/1
844 NekDouble curl = c212 - c221;
845 // square curl[2]
846 curlSquare[p] = curl * curl; // store 1x
847 }
848 }
849 else
850 {
851 Vmath::Fill(nPts, 0.0, curlSquare, 1);
852 }
853}
Vmath::Fill
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().

Referenced by GetDivCurlSquared().

◆ GetDivCurlSquared()

void Nektar::NavierStokesCFE::GetDivCurlSquared ( const Array< OneD, MultiRegions::ExpListSharedPtr > &  fields,
const Array< OneD, Array< OneD, NekDouble > > &  cnsVar,
Array< OneD, NekDouble > &  div,
Array< OneD, NekDouble > &  curlSquare,
const Array< OneD, Array< OneD, NekDouble > > &  cnsVarFwd,
const Array< OneD, Array< OneD, NekDouble > > &  cnsVarBwd 
)
protected

Get divergence and curl squared.

Parameters
inputfields -> expansion list pointer cnsVar -> conservative variables cnsVarFwd -> forward trace of conservative variables cnsVarBwd -> backward trace of conservative variables @paran output divSquare -> divergence curlSquare -> curl squared

Definition at line 717 of file NavierStokesCFE.cpp.

723{
724 size_t nDim = fields[0]->GetCoordim(0);
725 size_t nVar = cnsVar.size();
726 size_t nPts = cnsVar[0].size();
727 size_t nPtsTrc = cnsVarFwd[0].size();
728
729 // These should be allocated once
730 Array<OneD, Array<OneD, NekDouble>> primVar(nVar - 1), primVarFwd(nVar - 1),
731 primVarBwd(nVar - 1);
732
733 for (unsigned short d = 0; d < nVar - 2; ++d)
734 {
735 primVar[d] = Array<OneD, NekDouble>(nPts, 0.0);
736 primVarFwd[d] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
737 primVarBwd[d] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
738 }
739 size_t ergLoc = nVar - 2;
740 primVar[ergLoc] = Array<OneD, NekDouble>(nPts, 0.0);
741 primVarFwd[ergLoc] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
742 primVarBwd[ergLoc] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
743
744 // Get primitive variables [u,v,w,T=0]
745 // Possibly should be changed to [rho,u,v,w,T] to make IP and LDGNS more
746 // consistent with each other
747 for (unsigned short d = 0; d < nVar - 2; ++d)
748 {
749 // Volume
750 for (size_t p = 0; p < nPts; ++p)
751 {
752 primVar[d][p] = cnsVar[d + 1][p] / cnsVar[0][p];
753 }
754 // Trace
755 for (size_t p = 0; p < nPtsTrc; ++p)
756 {
757 primVarFwd[d][p] = cnsVarFwd[d + 1][p] / cnsVarFwd[0][p];
758 primVarBwd[d][p] = cnsVarBwd[d + 1][p] / cnsVarBwd[0][p];
759 }
760 }
761
762 // this should be allocated once
763 Array<OneD, Array<OneD, Array<OneD, NekDouble>>> primVarDer(nDim);
764 for (unsigned short j = 0; j < nDim; ++j)
765 {
766 primVarDer[j] = Array<OneD, Array<OneD, NekDouble>>(nVar - 1);
767 for (unsigned short i = 0; i < nVar - 1; ++i)
768 {
769 primVarDer[j][i] = Array<OneD, NekDouble>(nPts, 0.0);
770 }
771 }
772
773 // Get derivative tensor
774 m_diffusion->DiffuseCalcDerivative(fields, primVar, primVarDer, primVarFwd,
775 primVarBwd);
776
777 // Get div curl squared
778 GetDivCurlFromDvelT(primVarDer, div, curlSquare);
779}
Nektar::CompressibleFlowSystem::m_diffusion
SolverUtils::DiffusionSharedPtr m_diffusion
Definition CompressibleFlowSystem.h:71
Nektar::NavierStokesCFE::GetDivCurlFromDvelT
void GetDivCurlFromDvelT(const TensorOfArray3D< NekDouble > &pVarDer, Array< OneD, NekDouble > &div, Array< OneD, NekDouble > &curlSquare)
Get divergence and curl from velocity derivative tensor.
Definition NavierStokesCFE.cpp:785
Nektar::UnitTests::d
std::vector< double > d(NPUPPER *NPUPPER)

References GetDivCurlFromDvelT(), and Nektar::CompressibleFlowSystem::m_diffusion.

Referenced by v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), and v_ExtraFldOutput().

◆ GetPhysicalAV()

void Nektar::NavierStokesCFE::GetPhysicalAV ( const Array< OneD, const Array< OneD, NekDouble > > &  physfield)
protected

◆ GetViscosityAndThermalCondFromTemp()

void Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTemp ( const Array< OneD, NekDouble > &  temperature,
Array< OneD, NekDouble > &  mu,
Array< OneD, NekDouble > &  thermalCond 
)
protected

Update viscosity todo: add artificial viscosity here.

Definition at line 672 of file NavierStokesCFE.cpp.

675{
676 size_t nPts = temperature.size();
677
678 for (size_t p = 0; p < nPts; ++p)
679 {
680 GetViscosityAndThermalCondFromTempKernel(temperature[p], mu[p],
681 thermalCond[p]);
682 }
683
684 // Add artificial viscosity if wanted
685 // move this above and add in kernel
686 if (m_is_shockCaptPhys)
687 {
688 size_t nTracePts = m_fields[0]->GetTrace()->GetTotPoints();
689 if (nPts != nTracePts)
690 {
691 Vmath::Vadd(nPts, mu, 1, m_varConv->GetAv(), 1, mu, 1);
692 }
693 else
694 {
695 Vmath::Vadd(nPts, mu, 1, m_varConv->GetAvTrace(), 1, mu, 1);
696 }
697
698 // Update thermal conductivity
699 NekDouble tRa = m_Cp / m_Prandtl;
700 Vmath::Smul(nPts, tRa, mu, 1, thermalCond, 1);
701 }
702}
Nektar::CompressibleFlowSystem::m_varConv
VariableConverterSharedPtr m_varConv
Definition CompressibleFlowSystem.h:93
Nektar::NavierStokesCFE::m_is_shockCaptPhys
bool m_is_shockCaptPhys
flag for shock capturing switch on/off an enum could be added for more options
Definition NavierStokesCFE.h:78
Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTempKernel
void GetViscosityAndThermalCondFromTempKernel(const T &temperature, T &mu, T &thermalCond)
Definition NavierStokesCFE.h:176
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition EquationSystem.h:467
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition Vmath.hpp:180
Vmath::Smul
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 GetViscosityAndThermalCondFromTempKernel(), m_Cp, Nektar::SolverUtils::EquationSystem::m_fields, m_is_shockCaptPhys, m_Prandtl, Nektar::CompressibleFlowSystem::m_varConv, Vmath::Smul(), and Vmath::Vadd().

Referenced by GetViscousFluxVectorConservVar(), GetViscousSymmtrFluxConservVar(), Nektar::NavierStokesImplicitCFE::v_CalcMuDmuDT(), Nektar::NavierStokesImplicitCFE::v_GetFluxDerivJacDirctn(), Nektar::NavierStokesImplicitCFE::v_GetFluxDerivJacDirctn(), v_GetFluxPenalty(), v_GetViscousFluxVector(), Nektar::NavierStokesCFEAxisym::v_GetViscousFluxVector(), and v_GetViscousFluxVectorDeAlias().

◆ GetViscosityAndThermalCondFromTempKernel()

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>
void Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTempKernel ( const T &  temperature,
T &  mu,
T &  thermalCond 
)
inlineprotected

Definition at line 176 of file NavierStokesCFE.h.

178 {
179 GetViscosityFromTempKernel(temperature, mu);
180 NekDouble tRa = m_Cp / m_Prandtl;
181 thermalCond = tRa * mu;
182 }
Nektar::NavierStokesCFE::GetViscosityFromTempKernel
void GetViscosityFromTempKernel(const T &temperature, T &mu)
Definition NavierStokesCFE.h:187

References GetViscosityFromTempKernel(), m_Cp, and m_Prandtl.

Referenced by GetViscosityAndThermalCondFromTemp().

◆ GetViscosityFromTempKernel()

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>
void Nektar::NavierStokesCFE::GetViscosityFromTempKernel ( const T &  temperature,
T &  mu 
)
inlineprotected

Definition at line 187 of file NavierStokesCFE.h.

188 {
189 // Variable viscosity through the Sutherland's law
190 if (m_is_mu_variable)
191 {
192 mu = m_varConv->GetDynamicViscosity(temperature);
193 }
194 else
195 {
196 mu = m_muRef;
197 }
198 }
Nektar::NavierStokesCFE::m_is_mu_variable
bool m_is_mu_variable
flag to switch between constant viscosity and Sutherland an enum could be added for more options
Definition NavierStokesCFE.h:72

References m_is_mu_variable, m_muRef, and Nektar::CompressibleFlowSystem::m_varConv.

Referenced by GetViscosityAndThermalCondFromTempKernel().

◆ GetViscousFluxBilinearFormKernel()

template<class T , typename = typename std::enable_if< std::is_floating_point_v<T> || tinysimd::is_vector_floating_point_v<T>>::type>
void Nektar::NavierStokesCFE::GetViscousFluxBilinearFormKernel ( const unsigned short  nDim,
const unsigned short  FluxDirection,
const unsigned short  DerivDirection,
const T *  inaverg,
const T *  injumpp,
const T &  mu,
T *  outarray 
)
inlineprotected

Calculate diffusion flux using the Jacobian form.

Parameters
in
outoutarray[nvars] flux

Definition at line 211 of file NavierStokesCFE.h.

216 {
217 // Constants
218 unsigned short nDim_plus_one = nDim + 1;
219 unsigned short FluxDirection_plus_one = FluxDirection + 1;
220 unsigned short DerivDirection_plus_one = DerivDirection + 1;
221
222 NekDouble gammaoPr = m_gamma / m_Prandtl;
223 NekDouble one_minus_gammaoPr = 1.0 - gammaoPr;
224
225 constexpr NekDouble OneThird = 1. / 3.;
226 constexpr NekDouble TwoThird = 2. * OneThird;
227 constexpr NekDouble FourThird = 4. * OneThird;
228
229 if (DerivDirection == FluxDirection)
230 {
231 // rho flux always zero
232 outarray[0] = 0.0; // store 1x
233
234 // load 1/rho
235 T oneOrho = 1.0 / inaverg[0]; // load 1x
236 // get vel, vel^2, sum of vel^2
237 std::array<T, 3> u = {{0.0, 0.0, 0.0}};
238 std::array<T, 3> u2 = {{0.0, 0.0, 0.0}};
239 T u2sum{};
240 for (unsigned short d = 0; d < nDim; ++d)
241 {
242 u[d] = inaverg[d + 1] * oneOrho; // load 1x
243 u2[d] = u[d] * u[d];
244 u2sum += u2[d];
245 }
246
247 // get E - sum v^2
248 T E_minus_u2sum = inaverg[nDim_plus_one]; // load 1x
249 E_minus_u2sum *= oneOrho;
250 E_minus_u2sum -= u2sum;
251
252 // get nu = mu/rho
253 T nu = mu * oneOrho; // load 1x
254
255 // ^^^^ above is almost the same for both loops
256
257 T tmp1 = OneThird * u2[FluxDirection] + u2sum;
258 tmp1 += gammaoPr * E_minus_u2sum;
259 tmp1 *= injumpp[0]; // load 1x
260
261 T tmp2 = gammaoPr * injumpp[nDim_plus_one] - tmp1; // load 1x
262
263 // local var for energy output
264 T outTmpE = 0.0;
265 for (unsigned short d = 0; d < nDim; ++d)
266 {
267 unsigned short d_plus_one = d + 1;
268 // flux[rhou, rhov, rhow]
269 T outTmpD = injumpp[d_plus_one] - u[d] * injumpp[0];
270 outTmpD *= nu;
271 // flux rhoE
272 T tmp3 = one_minus_gammaoPr * u[d];
273 outTmpE += tmp3 * injumpp[d_plus_one];
274
275 if (d == FluxDirection)
276 {
277 outTmpD *= FourThird;
278 T tmp4 = OneThird * u[FluxDirection];
279 outTmpE += tmp4 * injumpp[FluxDirection_plus_one];
280 }
281
282 outarray[d_plus_one] = outTmpD; // store 1x
283 }
284
285 outTmpE += tmp2;
286 outTmpE *= nu;
287 outarray[nDim_plus_one] = outTmpE; // store 1x
288 }
289 else
290 {
291 // rho flux always zero
292 outarray[0] = 0.0; // store 1x
293
294 // load 1/rho
295 T oneOrho = 1.0 / inaverg[0]; // load 1x
296 // get vel, vel^2, sum of vel^2
297 std::array<T, 3> u, u2;
298 T u2sum{};
299 for (unsigned short d = 0; d < nDim; ++d)
300 {
301 unsigned short d_plus_one = d + 1;
302 u[d] = inaverg[d_plus_one] * oneOrho; // load 1x
303 u2[d] = u[d] * u[d];
304 u2sum += u2[d];
305 // Not all directions are set
306 // one could work out the one that is not set
307 outarray[d_plus_one] = 0.0; // store 1x
308 }
309
310 // get E - sum v^2
311 T E_minus_u2sum = inaverg[nDim_plus_one]; // load 1x
312 E_minus_u2sum *= oneOrho;
313 E_minus_u2sum -= u2sum;
314
315 // get nu = mu/rho
316 T nu = mu * oneOrho; // load 1x
317
318 // ^^^^ above is almost the same for both loops
319
320 T tmp1 = u[DerivDirection] * injumpp[0] -
321 injumpp[DerivDirection_plus_one]; // load 2x
322 tmp1 *= TwoThird;
323 outarray[FluxDirection_plus_one] = nu * tmp1; // store 1x
324
325 tmp1 =
326 injumpp[FluxDirection_plus_one] - u[FluxDirection] * injumpp[0];
327 outarray[DerivDirection_plus_one] = nu * tmp1; // store 1x
328
329 tmp1 = OneThird * u[FluxDirection] * u[DerivDirection];
330 tmp1 *= injumpp[0];
331
332 T tmp2 =
333 TwoThird * u[FluxDirection] * injumpp[DerivDirection_plus_one];
334
335 tmp1 += tmp2;
336
337 tmp1 = u[DerivDirection] * injumpp[FluxDirection_plus_one] - tmp1;
338 outarray[nDim_plus_one] = nu * tmp1; // store 1x
339 }
340 }

References Nektar::CompressibleFlowSystem::m_gamma, and m_Prandtl.

Referenced by GetViscousFluxVectorConservVar(), and GetViscousSymmtrFluxConservVar().

◆ GetViscousFluxVectorConservVar() [1/2]

template<bool IS_TRACE>
void Nektar::NavierStokesCFE::GetViscousFluxVectorConservVar ( const size_t  nDim,
const Array< OneD, Array< OneD, NekDouble > > &  inarray,
const TensorOfArray3D< NekDouble > &  qfields,
TensorOfArray3D< NekDouble > &  outarray,
Array< OneD, int > &  nonZeroIndex,
const Array< OneD, Array< OneD, NekDouble > > &  normal 
)
inlineprotected

Return the flux vector for the IP diffusion problem, based on conservative variables.

Definition at line 347 of file NavierStokesCFE.h.

352 {
353 size_t nConvectiveFields = inarray.size();
354 size_t nPts = inarray[0].size();
355 size_t n_nonZero = nConvectiveFields - 1;
356
357 // max outfield dimensions
358 constexpr unsigned short nOutMax = 3 - 2 * IS_TRACE;
359 constexpr unsigned short nVarMax = 5;
360 constexpr unsigned short nDimMax = 3;
361
362 // Update viscosity and thermal conductivity
363 // unfortunately the artificial viscosity is difficult to vectorize
364 // with the current implementation
365 Array<OneD, NekDouble> temperature(nPts, 0.0);
366 Array<OneD, NekDouble> mu(nPts, 0.0);
367 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
368 m_varConv->GetTemperature(inarray, temperature);
369 GetViscosityAndThermalCondFromTemp(temperature, mu,
370 thermalConductivity);
371
372 // vector loop
373 using namespace tinysimd;
374 using vec_t = simd<NekDouble>;
375 size_t sizeVec = (nPts / vec_t::width) * vec_t::width;
376 size_t p = 0;
377
378 for (; p < sizeVec; p += vec_t::width)
379 {
380 // there is a significant penalty to use std::vector
381 alignas(vec_t::alignment) std::array<vec_t, nVarMax> inTmp,
382 qfieldsTmp, outTmp;
383 alignas(vec_t::alignment) std::array<vec_t, nDimMax> normalTmp;
384 alignas(vec_t::alignment) std::array<vec_t, nVarMax * nOutMax>
385 outArrTmp{{}};
386
387 // rearrenge and load data
388 for (size_t f = 0; f < nConvectiveFields; ++f)
389 {
390 inTmp[f].load(&(inarray[f][p]), is_not_aligned);
391 // zero output vector
392 if (IS_TRACE)
393 {
394 outArrTmp[f] = 0.0;
395 }
396 else
397 {
398 for (size_t d = 0; d < nDim; ++d)
399 {
400 outArrTmp[f + nConvectiveFields * d] = 0.0;
401 }
402 }
403 }
404 if (IS_TRACE)
405 {
406 for (size_t d = 0; d < nDim; ++d)
407 {
408 normalTmp[d].load(&(normal[d][p]), is_not_aligned);
409 }
410 }
411
412 // get viscosity
413 vec_t muV{};
414 muV.load(&(mu[p]), is_not_aligned);
415
416 for (size_t nderiv = 0; nderiv < nDim; ++nderiv)
417 {
418 // rearrenge and load data
419 for (size_t f = 0; f < nConvectiveFields; ++f)
420 {
421 qfieldsTmp[f].load(&(qfields[nderiv][f][p]),
422 is_not_aligned);
423 }
424
425 for (size_t d = 0; d < nDim; ++d)
426 {
427 GetViscousFluxBilinearFormKernel(
428 nDim, d, nderiv, inTmp.data(), qfieldsTmp.data(), muV,
429 outTmp.data());
430
431 if (IS_TRACE)
432 {
433 for (size_t f = 0; f < nConvectiveFields; ++f)
434 {
435 outArrTmp[f] += normalTmp[d] * outTmp[f];
436 }
437 }
438 else
439 {
440 for (size_t f = 0; f < nConvectiveFields; ++f)
441 {
442 outArrTmp[f + nConvectiveFields * d] += outTmp[f];
443 }
444 }
445 }
446 }
447
448 // store data
449 if (IS_TRACE)
450 {
451 for (size_t f = 0; f < nConvectiveFields; ++f)
452 {
453 outArrTmp[f].store(&(outarray[0][f][p]), is_not_aligned);
454 }
455 }
456 else
457 {
458 for (size_t d = 0; d < nDim; ++d)
459 {
460 for (size_t f = 0; f < nConvectiveFields; ++f)
461 {
462 outArrTmp[f + nConvectiveFields * d].store(
463 &(outarray[d][f][p]), is_not_aligned);
464 }
465 }
466 }
467 }
468
469 // scalar loop
470 for (; p < nPts; ++p)
471 {
472 std::array<NekDouble, nVarMax> inTmp, qfieldsTmp, outTmp;
473 std::array<NekDouble, nDimMax> normalTmp;
474 std::array<NekDouble, nVarMax * nOutMax> outArrTmp{{}};
475 // rearrenge and load data
476 for (size_t f = 0; f < nConvectiveFields; ++f)
477 {
478 inTmp[f] = inarray[f][p];
479 // zero output vector
480 if (IS_TRACE)
481 {
482 outArrTmp[f] = 0.0;
483 }
484 else
485 {
486 for (size_t d = 0; d < nDim; ++d)
487 {
488 outArrTmp[f + nConvectiveFields * d] = 0.0;
489 }
490 }
491 }
492
493 if (IS_TRACE)
494 {
495 for (size_t d = 0; d < nDim; ++d)
496 {
497 normalTmp[d] = normal[d][p];
498 }
499 }
500
501 // get viscosity
502 NekDouble muS = mu[p];
503
504 for (size_t nderiv = 0; nderiv < nDim; ++nderiv)
505 {
506 // rearrenge and load data
507 for (size_t f = 0; f < nConvectiveFields; ++f)
508 {
509 qfieldsTmp[f] = qfields[nderiv][f][p];
510 }
511
512 for (size_t d = 0; d < nDim; ++d)
513 {
514 GetViscousFluxBilinearFormKernel(
515 nDim, d, nderiv, inTmp.data(), qfieldsTmp.data(), muS,
516 outTmp.data());
517
518 if (IS_TRACE)
519 {
520 for (size_t f = 0; f < nConvectiveFields; ++f)
521 {
522 outArrTmp[f] += normalTmp[d] * outTmp[f];
523 }
524 }
525 else
526 {
527 for (size_t f = 0; f < nConvectiveFields; ++f)
528 {
529 outArrTmp[f + nConvectiveFields * d] += outTmp[f];
530 }
531 }
532 }
533 }
534
535 // store data
536 if (IS_TRACE)
537 {
538 for (size_t f = 0; f < nConvectiveFields; ++f)
539 {
540 outarray[0][f][p] = outArrTmp[f];
541 }
542 }
543 else
544 {
545 for (size_t d = 0; d < nDim; ++d)
546 {
547 for (size_t f = 0; f < nConvectiveFields; ++f)
548 {
549 outarray[d][f][p] =
550 outArrTmp[f + nConvectiveFields * d];
551 }
552 }
553 }
554 }
555
556 // this is always the same, it should be initialized with the IP class
557 nonZeroIndex = Array<OneD, int>{n_nonZero, 0};
558 for (int i = 1; i < n_nonZero + 1; ++i)
559 {
560 nonZeroIndex[n_nonZero - i] = nConvectiveFields - i;
561 }
562 }
Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTemp
void GetViscosityAndThermalCondFromTemp(const Array< OneD, NekDouble > &temperature, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &thermalCond)
Update viscosity todo: add artificial viscosity here.
Definition NavierStokesCFE.cpp:672
Nektar::NavierStokesCFE::GetViscousFluxBilinearFormKernel
void GetViscousFluxBilinearFormKernel(const unsigned short nDim, const unsigned short FluxDirection, const unsigned short DerivDirection, const T *inaverg, const T *injumpp, const T &mu, T *outarray)
Calculate diffusion flux using the Jacobian form.
Definition NavierStokesCFE.h:211
Nektar::vec_t
tinysimd::simd< NekDouble > vec_t
Definition EquationOfState.h:60
tinysimd::is_not_aligned
static constexpr struct tinysimd::is_not_aligned_t is_not_aligned
tinysimd::simd
typename abi< ScalarType, width >::type simd
Definition tinysimd.hpp:80

References GetViscosityAndThermalCondFromTemp(), GetViscousFluxBilinearFormKernel(), tinysimd::is_not_aligned, and Nektar::CompressibleFlowSystem::m_varConv.

◆ GetViscousFluxVectorConservVar() [2/2]

void Nektar::NavierStokesCFE::GetViscousFluxVectorConservVar ( const size_t  nDim,
const Array< OneD, Array< OneD, NekDouble > > &  inarray,
const TensorOfArray3D< NekDouble > &  qfields,
TensorOfArray3D< NekDouble > &  outarray,
Array< OneD, int > &  nonZeroIndex = NullInt1DArray,
const Array< OneD, Array< OneD, NekDouble > > &  normal = NullNekDoubleArrayOfArray 
)
protected

◆ GetViscousSymmtrFluxConservVar()

void Nektar::NavierStokesCFE::GetViscousSymmtrFluxConservVar ( const size_t  nSpaceDim,
const Array< OneD, Array< OneD, NekDouble > > &  inaverg,
const Array< OneD, Array< OneD, NekDouble > > &  inarray,
TensorOfArray3D< NekDouble > &  outarray,
Array< OneD, int > &  nonZeroIndex,
const Array< OneD, Array< OneD, NekDouble > > &  normals 
)
protected

Calculate and return the Symmetric flux in IP method.

Definition at line 578 of file NavierStokesCFE.cpp.

583{
584 size_t nConvectiveFields = inarray.size();
585 size_t nPts = inaverg[nConvectiveFields - 1].size();
586 nonZeroIndex = Array<OneD, int>{nConvectiveFields - 1, 0};
587 for (size_t i = 0; i < nConvectiveFields - 1; ++i)
588 {
589 nonZeroIndex[i] = i + 1;
590 }
591
592 Array<OneD, NekDouble> mu(nPts, 0.0);
593 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
594 Array<OneD, NekDouble> temperature(nPts, 0.0);
595 m_varConv->GetTemperature(inaverg, temperature);
596 GetViscosityAndThermalCondFromTemp(temperature, mu, thermalConductivity);
597
598 std::vector<NekDouble> inAvgTmp(nConvectiveFields);
599 std::vector<NekDouble> inTmp(nConvectiveFields);
600 std::vector<NekDouble> outTmp(nConvectiveFields);
601 for (size_t d = 0; d < nDim; ++d)
602 {
603 for (size_t nderiv = 0; nderiv < nDim; ++nderiv)
604 {
605 for (size_t p = 0; p < nPts; ++p)
606 {
607 // rearrenge data
608 for (size_t f = 0; f < nConvectiveFields; ++f)
609 {
610 inAvgTmp[f] = inaverg[f][p];
611 inTmp[f] = inarray[f][p];
612 }
613
614 GetViscousFluxBilinearFormKernel(nDim, d, nderiv,
615 inAvgTmp.data(), inTmp.data(),
616 mu[p], outTmp.data());
617
618 for (size_t f = 0; f < nConvectiveFields; ++f)
619 {
620 outarray[d][f][p] += normal[nderiv][p] * outTmp[f];
621 }
622 }
623 }
624 }
625}

References GetViscosityAndThermalCondFromTemp(), GetViscousFluxBilinearFormKernel(), and Nektar::CompressibleFlowSystem::m_varConv.

Referenced by InitObject_Explicit().

◆ InitObject_Explicit()

void Nektar::NavierStokesCFE::InitObject_Explicit ( )
protected

Definition at line 64 of file NavierStokesCFE.cpp.

65{
66 // Get gas constant from session file and compute Cp
67 NekDouble gasConstant;
68 m_session->LoadParameter("GasConstant", gasConstant, 287.058);
69 m_Cp = m_gamma / (m_gamma - 1.0) * gasConstant;
70 m_Cv = m_Cp / m_gamma;
71
72 m_session->LoadParameter("Twall", m_Twall, 300.15);
73
74 // Viscosity
75 m_session->LoadSolverInfo("ViscosityType", m_ViscosityType, "Constant");
76 m_session->LoadParameter("mu", m_muRef, 1.78e-05);
77 if (m_ViscosityType == "Variable")
78 {
79 m_is_mu_variable = true;
80 }
81
82 // Thermal conductivity or Prandtl
83 if (m_session->DefinesParameter("thermalConductivity"))
84 {
85 ASSERTL0(!m_session->DefinesParameter("Pr"),
86 "Cannot define both Pr and thermalConductivity.");
87
88 m_session->LoadParameter("thermalConductivity",
89 m_thermalConductivityRef);
90 m_Prandtl = m_Cp * m_muRef / m_thermalConductivityRef;
91 }
92 else
93 {
94 m_session->LoadParameter("Pr", m_Prandtl, 0.72);
95 m_thermalConductivityRef = m_Cp * m_muRef / m_Prandtl;
96 }
97
98 if (m_shockCaptureType == "Physical")
99 {
100 m_is_shockCaptPhys = true;
101 }
102
103 std::string diffName;
104 m_session->LoadSolverInfo("DiffusionType", diffName, "LDGNS");
105
106 m_diffusion =
107 SolverUtils::GetDiffusionFactory().CreateInstance(diffName, diffName);
108 if ("InteriorPenalty" == diffName)
109 {
110 m_is_diffIP = true;
111 SetBoundaryConditionsBwdWeight();
112 }
113
114 if ("LDGNS" == diffName || "LDGNS3DHomogeneous1D" == diffName)
115 {
116 m_diffusion->SetFluxPenaltyNS(&NavierStokesCFE::v_GetFluxPenalty, this);
117 }
118
119 if (m_specHP_dealiasing)
120 {
121 m_diffusion->SetFluxVectorNS(
122 &NavierStokesCFE::v_GetViscousFluxVectorDeAlias, this);
123 }
124 else
125 {
126 m_diffusion->SetFluxVectorNS(&NavierStokesCFE::v_GetViscousFluxVector,
127 this);
128 }
129
130 m_diffusion->SetDiffusionFluxCons(
131 &NavierStokesCFE::GetViscousFluxVectorConservVar<false>, this);
132
133 m_diffusion->SetDiffusionFluxConsTrace(
134 &NavierStokesCFE::GetViscousFluxVectorConservVar<true>, this);
135
136 m_diffusion->SetSpecialBndTreat(&NavierStokesCFE::SpecialBndTreat, this);
137
138 m_diffusion->SetDiffusionSymmFluxCons(
139 &NavierStokesCFE::GetViscousSymmtrFluxConservVar, this);
140
141 // Concluding initialisation of diffusion operator
142 m_diffusion->InitObject(m_session, m_fields);
143 m_diffusion->SetGridVelocityTrace(
144 m_gridVelocityTrace); // If not ALE and movement this is just 0s
145}
ASSERTL0
#define ASSERTL0(condition, msg)
Definition ErrorUtil.hpp:216
Nektar::CompressibleFlowSystem::SetBoundaryConditionsBwdWeight
void SetBoundaryConditionsBwdWeight()
Set up a weight on physical boundaries for boundary condition applications.
Definition CompressibleFlowSystem.cpp:434
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition BasicUtils/NekFactory.hpp:142
Nektar::NavierStokesCFE::SpecialBndTreat
void SpecialBndTreat(Array< OneD, Array< OneD, NekDouble > > &consvar)
For very special treatment. For general boundaries it does nothing But for WallViscous and WallAdiaba...
Definition NavierStokesCFE.cpp:489
Nektar::NavierStokesCFE::GetViscousSymmtrFluxConservVar
void GetViscousSymmtrFluxConservVar(const size_t nSpaceDim, const Array< OneD, Array< OneD, NekDouble > > &inaverg, const Array< OneD, Array< OneD, NekDouble > > &inarray, TensorOfArray3D< NekDouble > &outarray, Array< OneD, int > &nonZeroIndex, const Array< OneD, Array< OneD, NekDouble > > &normals)
Calculate and return the Symmetric flux in IP method.
Definition NavierStokesCFE.cpp:578
Nektar::NavierStokesCFE::v_GetViscousFluxVector
virtual void v_GetViscousFluxVector(const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &derivatives, TensorOfArray3D< NekDouble > &viscousTensor)
Return the flux vector for the LDG diffusion problem.
Definition NavierStokesCFE.cpp:276
Nektar::NavierStokesCFE::v_GetFluxPenalty
virtual void v_GetFluxPenalty(const Array< OneD, const Array< OneD, NekDouble > > &uFwd, const Array< OneD, const Array< OneD, NekDouble > > &uBwd, Array< OneD, Array< OneD, NekDouble > > &penaltyCoeff)
Return the penalty vector for the LDGNS diffusion problem.
Definition NavierStokesCFE.cpp:630
Nektar::NavierStokesCFE::m_is_diffIP
bool m_is_diffIP
flag to switch between IP and LDG an enum could be added for more options
Definition NavierStokesCFE.h:75
Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias
virtual void v_GetViscousFluxVectorDeAlias(const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &derivatives, TensorOfArray3D< NekDouble > &viscousTensor)
Return the flux vector for the LDG diffusion problem.
Definition NavierStokesCFE.cpp:359
Nektar::SolverUtils::ALEHelper::m_gridVelocityTrace
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
Definition ALEHelper.h:142
Nektar::SolverUtils::EquationSystem::m_specHP_dealiasing
bool m_specHP_dealiasing
Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
Definition EquationSystem.h:524
Nektar::SolverUtils::EquationSystem::m_session
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Definition EquationSystem.h:460
Nektar::SolverUtils::GetDiffusionFactory
DiffusionFactory & GetDiffusionFactory()
Definition Diffusion.cpp:39

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::SolverUtils::GetDiffusionFactory(), GetViscousSymmtrFluxConservVar(), m_Cp, m_Cv, Nektar::CompressibleFlowSystem::m_diffusion, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::CompressibleFlowSystem::m_gamma, Nektar::SolverUtils::ALEHelper::m_gridVelocityTrace, m_is_diffIP, m_is_mu_variable, m_is_shockCaptPhys, m_muRef, m_Prandtl, Nektar::SolverUtils::EquationSystem::m_session, Nektar::CompressibleFlowSystem::m_shockCaptureType, Nektar::SolverUtils::EquationSystem::m_specHP_dealiasing, m_thermalConductivityRef, m_Twall, m_ViscosityType, Nektar::CompressibleFlowSystem::SetBoundaryConditionsBwdWeight(), SpecialBndTreat(), v_GetFluxPenalty(), v_GetViscousFluxVector(), and v_GetViscousFluxVectorDeAlias().

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

◆ SpecialBndTreat()

void Nektar::NavierStokesCFE::SpecialBndTreat ( Array< OneD, Array< OneD, NekDouble > > &  consvar)
protected

For very special treatment. For general boundaries it does nothing But for WallViscous and WallAdiabatic, special treatment is needed because they get the same Bwd value, special treatment is needed for boundary treatment of diffusion flux Note: This special treatment could be removed by seperating WallViscous and WallAdiabatic into two different classes.

Definition at line 489 of file NavierStokesCFE.cpp.

491{
492 size_t nConvectiveFields = consvar.size();
493 size_t ndens = 0;
494 size_t nengy = nConvectiveFields - 1;
495
496 Array<OneD, Array<OneD, NekDouble>> bndCons{nConvectiveFields};
497 Array<OneD, NekDouble> bndTotEngy;
498 Array<OneD, NekDouble> bndPressure;
499 Array<OneD, NekDouble> bndRho;
500 Array<OneD, NekDouble> bndIntEndy;
501 size_t nLengthArray = 0;
502
503 size_t cnt = 0;
504 size_t nBndRegions = m_fields[nengy]->GetBndCondExpansions().size();
505 for (size_t j = 0; j < nBndRegions; ++j)
506 {
507 if (m_fields[nengy]
508 ->GetBndConditions()[j]
509 ->GetBoundaryConditionType() == SpatialDomains::ePeriodic)
510 {
511 continue;
512 }
513
514 size_t nBndEdges =
515 m_fields[nengy]->GetBndCondExpansions()[j]->GetExpSize();
516 for (size_t e = 0; e < nBndEdges; ++e)
517 {
518 size_t nBndEdgePts = m_fields[nengy]
519 ->GetBndCondExpansions()[j]
520 ->GetExp(e)
521 ->GetTotPoints();
522
523 int id2 = m_fields[0]->GetTrace()->GetPhys_Offset(
524 m_fields[0]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt++));
525
526 // Imposing Temperature Twall at the wall
527 if (boost::iequals(
528 m_fields[nengy]->GetBndConditions()[j]->GetUserDefined(),
529 "WallViscous"))
530 {
531 if (nBndEdgePts != nLengthArray)
532 {
533 for (size_t i = 0; i < nConvectiveFields; ++i)
534 {
535 bndCons[i] = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
536 }
537 bndTotEngy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
538 bndPressure = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
539 bndRho = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
540 bndIntEndy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
541 nLengthArray = nBndEdgePts;
542 }
543 else
544 {
545 Vmath::Zero(nLengthArray, bndPressure, 1);
546 Vmath::Zero(nLengthArray, bndRho, 1);
547 Vmath::Zero(nLengthArray, bndIntEndy, 1);
548 }
549
550 Array<OneD, NekDouble> tmp;
551
552 for (size_t k = 0; k < nConvectiveFields; ++k)
553 {
554 Vmath::Vcopy(nBndEdgePts, tmp = consvar[k] + id2, 1,
555 bndCons[k], 1);
556 }
557
558 m_varConv->GetPressure(bndCons, bndPressure);
559 Vmath::Fill(nLengthArray, m_Twall, bndTotEngy, 1);
560 m_varConv->GetRhoFromPT(bndPressure, bndTotEngy, bndRho);
561 m_varConv->GetEFromRhoP(bndRho, bndPressure, bndIntEndy);
562 m_varConv->GetDynamicEnergy(bndCons, bndTotEngy);
563
564 Vmath::Vvtvp(nBndEdgePts, bndIntEndy, 1, bndCons[ndens], 1,
565 bndTotEngy, 1, bndTotEngy, 1);
566
567 Vmath::Vcopy(nBndEdgePts, bndTotEngy, 1,
568 tmp = consvar[nengy] + id2, 1);
569 }
570 }
571 }
572}
Vmath::Vvtvp
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition Vmath.hpp:366
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition Vmath.hpp:273
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition Vmath.hpp:825

References Nektar::SpatialDomains::ePeriodic, Vmath::Fill(), Nektar::SolverUtils::EquationSystem::m_fields, m_Twall, Nektar::CompressibleFlowSystem::m_varConv, Vmath::Vcopy(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by InitObject_Explicit().

◆ v_DoDiffusion()

void Nektar::NavierStokesCFE::v_DoDiffusion ( const Array< OneD, Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const Array< OneD, Array< OneD, NekDouble > > &  pFwd,
const Array< OneD, Array< OneD, NekDouble > > &  pBwd 
)
overrideprotectedvirtual

Implements Nektar::CompressibleFlowSystem.

Reimplemented in Nektar::NavierStokesImplicitCFE, and Nektar::NavierStokesCFEAxisym.

Definition at line 147 of file NavierStokesCFE.cpp.

152{
153 size_t nvariables = inarray.size();
154 size_t npointsIn = GetNpoints();
155 size_t npointsOut = m_meshDistorted
156 ? GetNcoeffs()
157 : npointsIn; // If mesh is distorted then outarray
158 // is in coefficient space
159 size_t nTracePts = GetTraceTotPoints();
160
161 // this should be preallocated
162 Array<OneD, Array<OneD, NekDouble>> outarrayDiff(nvariables);
163 for (size_t i = 0; i < nvariables; ++i)
164 {
165 outarrayDiff[i] = Array<OneD, NekDouble>(npointsOut, 0.0);
166 }
167
168 // Set artificial viscosity based on NS viscous tensor
169 if (m_is_shockCaptPhys)
170 {
171 if (m_varConv->GetFlagCalcDivCurl())
172 {
173 Array<OneD, NekDouble> div(npointsIn), curlSquare(npointsIn);
174 GetDivCurlSquared(m_fields, inarray, div, curlSquare, pFwd, pBwd);
175
176 // Set volume and trace artificial viscosity
177 m_varConv->SetAv(m_fields, inarray, div, curlSquare);
178 }
179 else
180 {
181 m_varConv->SetAv(m_fields, inarray);
182 }
183 }
184
185 if (m_is_diffIP)
186 {
187 if (m_bndEvaluateTime < 0.0)
188 {
189 NEKERROR(ErrorUtil::efatal, "m_bndEvaluateTime not setup");
190 }
191
192 // Diffusion term in physical rhs form
193 if (m_meshDistorted)
194 {
195 m_diffusion->DiffuseCoeffs(nvariables, m_fields, inarray,
196 outarrayDiff, m_bndEvaluateTime, pFwd,
197 pBwd);
198 }
199 else
200 {
201 m_diffusion->Diffuse(nvariables, m_fields, inarray, outarrayDiff,
202 m_bndEvaluateTime, pFwd, pBwd);
203 }
204 for (size_t i = 0; i < nvariables; ++i)
205 {
206 Vmath::Vadd(npointsOut, outarrayDiff[i], 1, outarray[i], 1,
207 outarray[i], 1);
208 }
209 }
210 else
211 {
212 // Get primitive variables [u,v,w,T]
213 Array<OneD, Array<OneD, NekDouble>> inarrayDiff(nvariables - 1);
214 Array<OneD, Array<OneD, NekDouble>> inFwd(nvariables - 1);
215 Array<OneD, Array<OneD, NekDouble>> inBwd(nvariables - 1);
216
217 for (size_t i = 0; i < nvariables - 1; ++i)
218 {
219 inarrayDiff[i] = Array<OneD, NekDouble>{npointsIn};
220 inFwd[i] = Array<OneD, NekDouble>{nTracePts};
221 inBwd[i] = Array<OneD, NekDouble>{nTracePts};
222 }
223
224 // Extract temperature
225 m_varConv->GetTemperature(inarray, inarrayDiff[nvariables - 2]);
226
227 // Extract velocities
228 m_varConv->GetVelocityVector(inarray, inarrayDiff);
229
230 // Repeat calculation for trace space
231 if (pFwd == NullNekDoubleArrayOfArray ||
232 pBwd == NullNekDoubleArrayOfArray)
233 {
234 inFwd = NullNekDoubleArrayOfArray;
235 inBwd = NullNekDoubleArrayOfArray;
236 }
237 else
238 {
239 m_varConv->GetTemperature(pFwd, inFwd[nvariables - 2]);
240 m_varConv->GetTemperature(pBwd, inBwd[nvariables - 2]);
241
242 m_varConv->GetVelocityVector(pFwd, inFwd);
243 m_varConv->GetVelocityVector(pBwd, inBwd);
244 }
245
246 // Diffusion term in physical rhs form
247 if (m_meshDistorted)
248 {
249 m_diffusion->DiffuseCoeffs(nvariables, m_fields, inarrayDiff,
250 outarrayDiff, inFwd, inBwd);
251 }
252 else
253 {
254 m_diffusion->Diffuse(nvariables, m_fields, inarrayDiff,
255 outarrayDiff, inFwd, inBwd);
256 }
257
258 for (size_t i = 0; i < nvariables; ++i)
259 {
260 Vmath::Vadd(npointsOut, outarrayDiff[i], 1, outarray[i], 1,
261 outarray[i], 1);
262 }
263 }
264
265 // Add artificial diffusion through Laplacian operator
266 if (m_artificialDiffusion)
267 {
268 m_artificialDiffusion->DoArtificialDiffusion(inarray, outarray);
269 }
270}
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition ErrorUtil.hpp:210
Nektar::CompressibleFlowSystem::m_artificialDiffusion
ArtificialDiffusionSharedPtr m_artificialDiffusion
Definition CompressibleFlowSystem.h:72
Nektar::NavierStokesCFE::GetDivCurlSquared
void GetDivCurlSquared(const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &cnsVar, Array< OneD, NekDouble > &div, Array< OneD, NekDouble > &curlSquare, const Array< OneD, Array< OneD, NekDouble > > &cnsVarFwd, const Array< OneD, Array< OneD, NekDouble > > &cnsVarBwd)
Get divergence and curl squared.
Definition NavierStokesCFE.cpp:717
Nektar::SolverUtils::EquationSystem::GetNpoints
SOLVER_UTILS_EXPORT int GetNpoints()
Definition EquationSystem.h:351
Nektar::SolverUtils::EquationSystem::GetNcoeffs
SOLVER_UTILS_EXPORT int GetNcoeffs()
Definition EquationSystem.h:283
Nektar::SolverUtils::EquationSystem::GetTraceTotPoints
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
Definition EquationSystem.h:316
Nektar::NullNekDoubleArrayOfArray
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray
Definition BasicUtils/SharedArray.hpp:929

References Nektar::ErrorUtil::efatal, GetDivCurlSquared(), Nektar::SolverUtils::EquationSystem::GetNcoeffs(), Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::CompressibleFlowSystem::m_artificialDiffusion, Nektar::CompressibleFlowSystem::m_bndEvaluateTime, Nektar::CompressibleFlowSystem::m_diffusion, Nektar::SolverUtils::EquationSystem::m_fields, m_is_diffIP, m_is_shockCaptPhys, Nektar::SolverUtils::ALEHelper::m_meshDistorted, Nektar::CompressibleFlowSystem::m_varConv, NEKERROR, Nektar::NullNekDoubleArrayOfArray, and Vmath::Vadd().

Referenced by Nektar::NavierStokesCFEAxisym::v_DoDiffusion().

◆ v_ExtraFldOutput()

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

Reimplemented from Nektar::CompressibleFlowSystem.

Definition at line 855 of file NavierStokesCFE.cpp.

858{
859 bool extraFields;
860 m_session->MatchSolverInfo("OutputExtraFields", "True", extraFields, true);
861 if (extraFields)
862 {
863 const int nPhys = m_fields[0]->GetNpoints();
864 const int nCoeffs = m_fields[0]->GetNcoeffs();
865 Array<OneD, Array<OneD, NekDouble>> cnsVar(m_fields.size());
866
867 for (size_t i = 0; i < m_fields.size(); ++i)
868 {
869 cnsVar[i] = m_fields[i]->GetPhys();
870 }
871
872 Array<OneD, Array<OneD, NekDouble>> velocity(m_spacedim);
873 Array<OneD, Array<OneD, NekDouble>> velFwd(m_spacedim);
874 for (int i = 0; i < m_spacedim; ++i)
875 {
876 velocity[i] = Array<OneD, NekDouble>(nPhys);
877 velFwd[i] = Array<OneD, NekDouble>(nCoeffs);
878 }
879
880 Array<OneD, NekDouble> pressure(nPhys), temperature(nPhys);
881 Array<OneD, NekDouble> entropy(nPhys);
882 Array<OneD, NekDouble> soundspeed(nPhys), mach(nPhys);
883 Array<OneD, NekDouble> sensor(nPhys), SensorKappa(nPhys);
884
885 m_varConv->GetVelocityVector(cnsVar, velocity);
886 m_varConv->GetPressure(cnsVar, pressure);
887 m_varConv->GetTemperature(cnsVar, temperature);
888 m_varConv->GetEntropy(cnsVar, entropy);
889 m_varConv->GetSoundSpeed(cnsVar, soundspeed);
890 m_varConv->GetMach(cnsVar, soundspeed, mach);
891
892 int sensorOffset;
893 m_session->LoadParameter("SensorOffset", sensorOffset, 1);
894 m_varConv->GetSensor(m_fields[0], cnsVar, sensor, SensorKappa,
895 sensorOffset);
896
897 Array<OneD, NekDouble> pFwd(nCoeffs), TFwd(nCoeffs);
898 Array<OneD, NekDouble> sFwd(nCoeffs);
899 Array<OneD, NekDouble> aFwd(nCoeffs), mFwd(nCoeffs);
900 Array<OneD, NekDouble> sensFwd(nCoeffs);
901
902 std::string velNames[3] = {"u", "v", "w"};
903 for (int i = 0; i < m_spacedim; ++i)
904 {
905 m_fields[0]->FwdTransLocalElmt(velocity[i], velFwd[i]);
906 variables.push_back(velNames[i]);
907 fieldcoeffs.push_back(velFwd[i]);
908 }
909
910 m_fields[0]->FwdTransLocalElmt(pressure, pFwd);
911 m_fields[0]->FwdTransLocalElmt(temperature, TFwd);
912 m_fields[0]->FwdTransLocalElmt(entropy, sFwd);
913 m_fields[0]->FwdTransLocalElmt(soundspeed, aFwd);
914 m_fields[0]->FwdTransLocalElmt(mach, mFwd);
915 m_fields[0]->FwdTransLocalElmt(sensor, sensFwd);
916
917 variables.push_back("p");
918 variables.push_back("T");
919 variables.push_back("s");
920 variables.push_back("a");
921 variables.push_back("Mach");
922 variables.push_back("Sensor");
923 fieldcoeffs.push_back(pFwd);
924 fieldcoeffs.push_back(TFwd);
925 fieldcoeffs.push_back(sFwd);
926 fieldcoeffs.push_back(aFwd);
927 fieldcoeffs.push_back(mFwd);
928 fieldcoeffs.push_back(sensFwd);
929
930 if (m_artificialDiffusion)
931 {
932 // reuse pressure
933 Array<OneD, NekDouble> sensorFwd(nCoeffs);
934 m_artificialDiffusion->GetArtificialViscosity(cnsVar, pressure);
935 m_fields[0]->FwdTransLocalElmt(pressure, sensorFwd);
936
937 variables.push_back("ArtificialVisc");
938 fieldcoeffs.push_back(sensorFwd);
939 }
940
941 if (m_is_shockCaptPhys)
942 {
943
944 Array<OneD, Array<OneD, NekDouble>> cnsVarFwd(m_fields.size()),
945 cnsVarBwd(m_fields.size());
946
947 for (size_t i = 0; i < m_fields.size(); ++i)
948 {
949 cnsVarFwd[i] = Array<OneD, NekDouble>(GetTraceTotPoints());
950 cnsVarBwd[i] = Array<OneD, NekDouble>(GetTraceTotPoints());
951 m_fields[i]->GetFwdBwdTracePhys(cnsVar[i], cnsVarFwd[i],
952 cnsVarBwd[i]);
953 }
954
955 Array<OneD, NekDouble> div(nPhys), curlSquare(nPhys);
956 GetDivCurlSquared(m_fields, cnsVar, div, curlSquare, cnsVarFwd,
957 cnsVarBwd);
958
959 Array<OneD, NekDouble> divFwd(nCoeffs, 0.0);
960 m_fields[0]->FwdTransLocalElmt(div, divFwd);
961 variables.push_back("div");
962 fieldcoeffs.push_back(divFwd);
963
964 Array<OneD, NekDouble> curlFwd(nCoeffs, 0.0);
965 m_fields[0]->FwdTransLocalElmt(curlSquare, curlFwd);
966 variables.push_back("curl^2");
967 fieldcoeffs.push_back(curlFwd);
968
969 m_varConv->SetAv(m_fields, cnsVar, div, curlSquare);
970
971 Array<OneD, NekDouble> muavFwd(nCoeffs);
972 m_fields[0]->FwdTransLocalElmt(m_varConv->GetAv(), muavFwd);
973 variables.push_back("ArtificialVisc");
974 fieldcoeffs.push_back(muavFwd);
975 }
976
977 if (m_ALESolver)
978 {
979 ExtraFldOutputGrid(fieldcoeffs, variables);
980 ExtraFldOutputGridVelocity(fieldcoeffs, variables);
981 }
982 }
983}
Nektar::SolverUtils::ALEHelper::ExtraFldOutputGrid
SOLVER_UTILS_EXPORT void ExtraFldOutputGrid(std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
Definition ALEHelper.cpp:497
Nektar::SolverUtils::ALEHelper::ExtraFldOutputGridVelocity
SOLVER_UTILS_EXPORT void ExtraFldOutputGridVelocity(std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
Definition ALEHelper.cpp:480
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition EquationSystem.h:504
CG_Iterations.pressure
pressure
Definition CG_Iterations.py:229

References Nektar::SolverUtils::ALEHelper::ExtraFldOutputGrid(), Nektar::SolverUtils::ALEHelper::ExtraFldOutputGridVelocity(), GetDivCurlSquared(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::ALEHelper::m_ALESolver, Nektar::CompressibleFlowSystem::m_artificialDiffusion, Nektar::SolverUtils::EquationSystem::m_fields, m_is_shockCaptPhys, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, and Nektar::CompressibleFlowSystem::m_varConv.

◆ v_GetFluxPenalty()

void Nektar::NavierStokesCFE::v_GetFluxPenalty ( const Array< OneD, const Array< OneD, NekDouble > > &  uFwd,
const Array< OneD, const Array< OneD, NekDouble > > &  uBwd,
Array< OneD, Array< OneD, NekDouble > > &  penaltyCoeff 
)
protectedvirtual

Return the penalty vector for the LDGNS diffusion problem.

Definition at line 630 of file NavierStokesCFE.cpp.

634{
635 size_t nTracePts = uFwd[0].size();
636
637 // Compute average temperature
638 size_t nVariables = uFwd.size();
639 Array<OneD, NekDouble> tAve{nTracePts, 0.0};
640 Vmath::Svtsvtp(nTracePts, 0.5, uFwd[nVariables - 1], 1, 0.5,
641 uBwd[nVariables - 1], 1, tAve, 1);
642
643 // Get average viscosity and thermal conductivity
644 Array<OneD, NekDouble> muAve{nTracePts, 0.0};
645 Array<OneD, NekDouble> tcAve{nTracePts, 0.0};
646
647 GetViscosityAndThermalCondFromTemp(tAve, muAve, tcAve);
648
649 // Compute penalty term
650 for (size_t i = 0; i < nVariables; ++i)
651 {
652 // Get jump of u variables
653 Vmath::Vsub(nTracePts, uFwd[i], 1, uBwd[i], 1, penaltyCoeff[i], 1);
654 // Multiply by variable coefficient = {coeff} ( u^+ - u^- )
655 if (i < nVariables - 1)
656 {
657 Vmath::Vmul(nTracePts, muAve, 1, penaltyCoeff[i], 1,
658 penaltyCoeff[i], 1);
659 }
660 else
661 {
662 Vmath::Vmul(nTracePts, tcAve, 1, penaltyCoeff[i], 1,
663 penaltyCoeff[i], 1);
664 }
665 }
666}
Vmath::Svtsvtp
void Svtsvtp(int n, const T alpha, const T *x, int incx, const T beta, const T *y, int incy, T *z, int incz)
Svtsvtp (scalar times vector plus scalar times vector):
Definition Vmath.hpp:473
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition Vmath.hpp:72
Vmath::Vsub
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition Vmath.hpp:220

References GetViscosityAndThermalCondFromTemp(), Vmath::Svtsvtp(), Vmath::Vmul(), and Vmath::Vsub().

Referenced by InitObject_Explicit().

◆ v_GetViscousFluxVector()

void Nektar::NavierStokesCFE::v_GetViscousFluxVector ( const Array< OneD, const Array< OneD, NekDouble > > &  physfield,
TensorOfArray3D< NekDouble > &  derivativesO1,
TensorOfArray3D< NekDouble > &  viscousTensor 
)
protectedvirtual

Return the flux vector for the LDG diffusion problem.

Todo:
Complete the viscous flux vector

Reimplemented in Nektar::NavierStokesCFEAxisym.

Definition at line 276 of file NavierStokesCFE.cpp.

280{
281 // Auxiliary variables
282 size_t nScalar = physfield.size();
283 size_t nPts = physfield[0].size();
284 Array<OneD, NekDouble> divVel(nPts, 0.0);
285
286 // Stokes hypothesis
287 const NekDouble lambda = -2.0 / 3.0;
288
289 // Update viscosity and thermal conductivity
290 Array<OneD, NekDouble> mu(nPts, 0.0);
291 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
292 GetViscosityAndThermalCondFromTemp(physfield[nScalar - 1], mu,
293 thermalConductivity);
294
295 // Velocity divergence
296 for (int j = 0; j < m_spacedim; ++j)
297 {
298 Vmath::Vadd(nPts, divVel, 1, derivativesO1[j][j], 1, divVel, 1);
299 }
300
301 // Velocity divergence scaled by lambda * mu
302 Vmath::Smul(nPts, lambda, divVel, 1, divVel, 1);
303 Vmath::Vmul(nPts, mu, 1, divVel, 1, divVel, 1);
304
305 // Viscous flux vector for the rho equation = 0
306 for (int i = 0; i < m_spacedim; ++i)
307 {
308 Vmath::Zero(nPts, viscousTensor[i][0], 1);
309 }
310
311 // Viscous stress tensor (for the momentum equations)
312 for (int i = 0; i < m_spacedim; ++i)
313 {
314 for (int j = i; j < m_spacedim; ++j)
315 {
316 Vmath::Vadd(nPts, derivativesO1[i][j], 1, derivativesO1[j][i], 1,
317 viscousTensor[i][j + 1], 1);
318
319 Vmath::Vmul(nPts, mu, 1, viscousTensor[i][j + 1], 1,
320 viscousTensor[i][j + 1], 1);
321
322 if (i == j)
323 {
324 // Add divergence term to diagonal
325 Vmath::Vadd(nPts, viscousTensor[i][j + 1], 1, divVel, 1,
326 viscousTensor[i][j + 1], 1);
327 }
328 else
329 {
330 // Copy to make symmetric
331 Vmath::Vcopy(nPts, viscousTensor[i][j + 1], 1,
332 viscousTensor[j][i + 1], 1);
333 }
334 }
335 }
336
337 // Terms for the energy equation
338 for (int i = 0; i < m_spacedim; ++i)
339 {
340 Vmath::Zero(nPts, viscousTensor[i][m_spacedim + 1], 1);
341 // u_j * tau_ij
342 for (int j = 0; j < m_spacedim; ++j)
343 {
344 Vmath::Vvtvp(nPts, physfield[j], 1, viscousTensor[i][j + 1], 1,
345 viscousTensor[i][m_spacedim + 1], 1,
346 viscousTensor[i][m_spacedim + 1], 1);
347 }
348 // Add k*T_i
349 Vmath::Vvtvp(nPts, thermalConductivity, 1, derivativesO1[i][m_spacedim],
350 1, viscousTensor[i][m_spacedim + 1], 1,
351 viscousTensor[i][m_spacedim + 1], 1);
352 }
353}

References GetViscosityAndThermalCondFromTemp(), Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by InitObject_Explicit().

◆ v_GetViscousFluxVectorDeAlias()

void Nektar::NavierStokesCFE::v_GetViscousFluxVectorDeAlias ( const Array< OneD, const Array< OneD, NekDouble > > &  physfield,
TensorOfArray3D< NekDouble > &  derivativesO1,
TensorOfArray3D< NekDouble > &  viscousTensor 
)
protectedvirtual

Return the flux vector for the LDG diffusion problem.

Todo:
Complete the viscous flux vector

Reimplemented in Nektar::NavierStokesCFEAxisym.

Definition at line 359 of file NavierStokesCFE.cpp.

363{
364 // Factor to rescale 1d points in dealiasing.
365 NekDouble OneDptscale = 2;
366 // Get number of points to dealias a cubic non-linearity
367 size_t nScalar = physfield.size();
368 size_t nPts = m_fields[0]->Get1DScaledTotPoints(OneDptscale);
369 size_t nPts_orig = physfield[0].size();
370
371 // Auxiliary variables
372 Array<OneD, NekDouble> divVel(nPts, 0.0);
373
374 // Stokes hypothesis
375 const NekDouble lambda = -2.0 / 3.0;
376
377 // Update viscosity and thermal conductivity
378 Array<OneD, NekDouble> mu(nPts, 0.0);
379 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
380 GetViscosityAndThermalCondFromTemp(physfield[nScalar - 1], mu,
381 thermalConductivity);
382
383 // Interpolate inputs and initialise interpolated output
384 Array<OneD, Array<OneD, NekDouble>> vel_interp(m_spacedim);
385 TensorOfArray3D<NekDouble> deriv_interp(m_spacedim);
386 TensorOfArray3D<NekDouble> out_interp(m_spacedim);
387 for (int i = 0; i < m_spacedim; ++i)
388 {
389 // Interpolate velocity
390 vel_interp[i] = Array<OneD, NekDouble>(nPts);
391 m_fields[0]->PhysInterp1DScaled(OneDptscale, physfield[i],
392 vel_interp[i]);
393
394 // Interpolate derivatives
395 deriv_interp[i] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim + 1);
396 for (int j = 0; j < m_spacedim + 1; ++j)
397 {
398 deriv_interp[i][j] = Array<OneD, NekDouble>(nPts);
399 m_fields[0]->PhysInterp1DScaled(OneDptscale, derivativesO1[i][j],
400 deriv_interp[i][j]);
401 }
402
403 // Output (start from j=1 since flux is zero for rho)
404 out_interp[i] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim + 2);
405 for (int j = 1; j < m_spacedim + 2; ++j)
406 {
407 out_interp[i][j] = Array<OneD, NekDouble>(nPts);
408 }
409 }
410
411 // Velocity divergence
412 for (int j = 0; j < m_spacedim; ++j)
413 {
414 Vmath::Vadd(nPts, divVel, 1, deriv_interp[j][j], 1, divVel, 1);
415 }
416
417 // Velocity divergence scaled by lambda * mu
418 Vmath::Smul(nPts, lambda, divVel, 1, divVel, 1);
419 Vmath::Vmul(nPts, mu, 1, divVel, 1, divVel, 1);
420
421 // Viscous flux vector for the rho equation = 0 (no need to dealias)
422 for (int i = 0; i < m_spacedim; ++i)
423 {
424 Vmath::Zero(nPts_orig, viscousTensor[i][0], 1);
425 }
426
427 // Viscous stress tensor (for the momentum equations)
428 for (int i = 0; i < m_spacedim; ++i)
429 {
430 for (int j = i; j < m_spacedim; ++j)
431 {
432 Vmath::Vadd(nPts, deriv_interp[i][j], 1, deriv_interp[j][i], 1,
433 out_interp[i][j + 1], 1);
434
435 Vmath::Vmul(nPts, mu, 1, out_interp[i][j + 1], 1,
436 out_interp[i][j + 1], 1);
437
438 if (i == j)
439 {
440 // Add divergence term to diagonal
441 Vmath::Vadd(nPts, out_interp[i][j + 1], 1, divVel, 1,
442 out_interp[i][j + 1], 1);
443 }
444 else
445 {
446 // Make symmetric
447 out_interp[j][i + 1] = out_interp[i][j + 1];
448 }
449 }
450 }
451
452 // Terms for the energy equation
453 for (int i = 0; i < m_spacedim; ++i)
454 {
455 Vmath::Zero(nPts, out_interp[i][m_spacedim + 1], 1);
456 // u_j * tau_ij
457 for (int j = 0; j < m_spacedim; ++j)
458 {
459 Vmath::Vvtvp(nPts, vel_interp[j], 1, out_interp[i][j + 1], 1,
460 out_interp[i][m_spacedim + 1], 1,
461 out_interp[i][m_spacedim + 1], 1);
462 }
463 // Add k*T_i
464 Vmath::Vvtvp(nPts, thermalConductivity, 1, deriv_interp[i][m_spacedim],
465 1, out_interp[i][m_spacedim + 1], 1,
466 out_interp[i][m_spacedim + 1], 1);
467 }
468
469 // Project to original space
470 for (int i = 0; i < m_spacedim; ++i)
471 {
472 for (int j = 1; j < m_spacedim + 2; ++j)
473 {
474 m_fields[0]->PhysGalerkinProjection1DScaled(
475 OneDptscale, out_interp[i][j], viscousTensor[i][j]);
476 }
477 }
478}

References GetViscosityAndThermalCondFromTemp(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, Vmath::Smul(), Vmath::Vadd(), Vmath::Vmul(), Vmath::Vvtvp(), and Vmath::Zero().

Referenced by InitObject_Explicit().

◆ v_InitObject()

void Nektar::NavierStokesCFE::v_InitObject ( bool  DeclareField = true)
overrideprotectedvirtual

Initialization object for CompressibleFlowSystem class.

Reimplemented from Nektar::CompressibleFlowSystem.

Reimplemented in Nektar::NavierStokesCFEAxisym, and Nektar::NavierStokesImplicitCFE.

Definition at line 55 of file NavierStokesCFE.cpp.

56{
57 CompressibleFlowSystem::v_InitObject(DeclareFields);
58
59 // rest of initialisation is in this routine so it can also be called
60 // in NavierStokesImplicitCFE initialisation
61 InitObject_Explicit();
62}
Nektar::CompressibleFlowSystem::v_InitObject
void v_InitObject(bool DeclareFields=true) override
Initialization object for CompressibleFlowSystem class.
Definition CompressibleFlowSystem.cpp:53

References InitObject_Explicit(), and Nektar::CompressibleFlowSystem::v_InitObject().

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

◆ v_SupportsShockCaptType()

bool Nektar::NavierStokesCFE::v_SupportsShockCaptType ( const std::string  type) const
overrideprotectedvirtual

Implements Nektar::CompressibleFlowSystem.

Reimplemented in Nektar::NavierStokesImplicitCFE.

Definition at line 985 of file NavierStokesCFE.cpp.

986{
987 if (type == "NonSmooth" || type == "Physical" || type == "Off")
988 {
989 return true;
990 }
991 else
992 {
993 return false;
994 }
995}

Friends And Related Symbol Documentation

◆ MemoryManager< NavierStokesCFE >

friend class MemoryManager< NavierStokesCFE >
friend

Definition at line 1 of file NavierStokesCFE.h.

Member Data Documentation

◆ className

std::string Nektar::NavierStokesCFE::className
static
Initial value:
=
SolverUtils::GetEquationSystemFactory().RegisterCreatorFunction(
"NavierStokesCFE", NavierStokesCFE::create,
"NavierStokes equations in conservative variables.")
Nektar::LibUtilities::NekFactory::RegisterCreatorFunction
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition BasicUtils/NekFactory.hpp:196
Nektar::NavierStokesCFE::create
static SolverUtils::EquationSystemSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Definition NavierStokesCFE.h:56
Nektar::SolverUtils::GetEquationSystemFactory
EquationSystemFactory & GetEquationSystemFactory()
Definition EquationSystem.cpp:99

Definition at line 66 of file NavierStokesCFE.h.

◆ m_C0ProjectExp

MultiRegions::ContFieldSharedPtr Nektar::NavierStokesCFE::m_C0ProjectExp
protected

Definition at line 86 of file NavierStokesCFE.h.

◆ m_Cp

NekDouble Nektar::NavierStokesCFE::m_Cp
protected

Definition at line 80 of file NavierStokesCFE.h.

Referenced by GetViscosityAndThermalCondFromTemp(), GetViscosityAndThermalCondFromTempKernel(), and InitObject_Explicit().

◆ m_Cv

NekDouble Nektar::NavierStokesCFE::m_Cv
protected

Definition at line 81 of file NavierStokesCFE.h.

Referenced by Nektar::NavierStokesImplicitCFE::GetdFlux_dU_2D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dU_3D(), and InitObject_Explicit().

◆ m_eos

EquationOfStateSharedPtr Nektar::NavierStokesCFE::m_eos
protected

Equation of system for computing temperature.

Definition at line 89 of file NavierStokesCFE.h.

◆ m_is_diffIP

bool Nektar::NavierStokesCFE::m_is_diffIP {false}
protected

flag to switch between IP and LDG an enum could be added for more options

Definition at line 75 of file NavierStokesCFE.h.

75{false};

Referenced by InitObject_Explicit(), Nektar::NavierStokesImplicitCFE::v_CalcPhysDeriv(), v_DoDiffusion(), and Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff().

◆ m_is_mu_variable

bool Nektar::NavierStokesCFE::m_is_mu_variable {false}
protected

flag to switch between constant viscosity and Sutherland an enum could be added for more options

Definition at line 72 of file NavierStokesCFE.h.

72{false};

Referenced by GetViscosityFromTempKernel(), and InitObject_Explicit().

◆ m_is_shockCaptPhys

bool Nektar::NavierStokesCFE::m_is_shockCaptPhys {false}
protected

flag for shock capturing switch on/off an enum could be added for more options

Definition at line 78 of file NavierStokesCFE.h.

78{false};

Referenced by GetViscosityAndThermalCondFromTemp(), InitObject_Explicit(), v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), and v_ExtraFldOutput().

◆ m_muRef

NekDouble Nektar::NavierStokesCFE::m_muRef
protected

Definition at line 92 of file NavierStokesCFE.h.

Referenced by GetViscosityFromTempKernel(), and InitObject_Explicit().

◆ m_physicalSensorType

std::string Nektar::NavierStokesCFE::m_physicalSensorType
protected

Definition at line 84 of file NavierStokesCFE.h.

◆ m_Prandtl

NekDouble Nektar::NavierStokesCFE::m_Prandtl
protected

Definition at line 82 of file NavierStokesCFE.h.

Referenced by Nektar::NavierStokesImplicitCFE::GetdFlux_dQx_2D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dQx_3D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dQy_2D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dQy_3D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dQz_3D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dU_2D(), Nektar::NavierStokesImplicitCFE::GetdFlux_dU_3D(), GetViscosityAndThermalCondFromTemp(), GetViscosityAndThermalCondFromTempKernel(), GetViscousFluxBilinearFormKernel(), and InitObject_Explicit().

◆ m_smoothing

std::string Nektar::NavierStokesCFE::m_smoothing
protected

Definition at line 85 of file NavierStokesCFE.h.

◆ m_thermalConductivityRef

NekDouble Nektar::NavierStokesCFE::m_thermalConductivityRef
protected

Definition at line 93 of file NavierStokesCFE.h.

Referenced by InitObject_Explicit().

◆ m_Twall

NekDouble Nektar::NavierStokesCFE::m_Twall
protected

Definition at line 91 of file NavierStokesCFE.h.

Referenced by InitObject_Explicit(), and SpecialBndTreat().

◆ m_ViscosityType

std::string Nektar::NavierStokesCFE::m_ViscosityType
protected

Definition at line 69 of file NavierStokesCFE.h.

Referenced by InitObject_Explicit(), and Nektar::NavierStokesImplicitCFE::v_CalcMuDmuDT().

Generated on Sun Nov 9 2025 20:17:03 for Nektar++ by doxygen 1.9.8