Nektar++
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
void GetViscosityAndThermalCondFromTemp (const Array< OneD, NekDouble > &temperature, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &thermalCond)
 Update viscosity todo: add artificial viscosity here. More...
 
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. More...
 
void GetDivCurlFromDvelT (const TensorOfArray3D< NekDouble > &pVarDer, Array< OneD, NekDouble > &div, Array< OneD, NekDouble > &curlSquare)
 Get divergence and curl from velocity derivative tensor. More...
 
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. More...
 
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. More...
 
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_InitObject (bool DeclareFields=true) override
 Initialization object for CompressibleFlowSystem class. More...
 
void v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure) override
 
void v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density) override
 
bool v_HasConstantDensity () override
 
void v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity) override
 
void v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields) override
 
void InitialiseParameters ()
 Load CFS parameters from the session file. More...
 
void InitAdvection ()
 Create advection and diffusion objects for CFS. More...
 
void DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Compute the right-hand side. More...
 
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. More...
 
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. More...
 
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. More...
 
void GetFluxVector (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &flux)
 Return the flux vector for the compressible Euler equations. More...
 
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. More...
 
void SetBoundaryConditions (Array< OneD, Array< OneD, NekDouble > > &physarray, NekDouble time)
 
void SetBoundaryConditionsBwdWeight ()
 Set up a weight on physical boundaries for boundary condition applications. More...
 
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. More...
 
NekDouble v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray) override
 Calculate the maximum timestep subject to CFL restrictions. More...
 
void v_GenerateSummary (SolverUtils::SummaryList &s) override
 Print a summary of time stepping parameters. More...
 
void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) override
 Set up logic for residual calculation. More...
 
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
 
void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables) override
 
virtual 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)=0
 
Array< OneD, NekDouble > v_GetMaxStdVelocity (const NekDouble SpeedSoundFactor) override
 Compute the advection velocity in the standard space for each element of the expansion. More...
 
void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2) override
 
virtual bool v_SupportsShockCaptType (const std::string type) const =0
 
- Protected Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Initialisation object for EquationSystem. More...
 
SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step) override
 
virtual SOLVER_UTILS_EXPORT Array< OneD, NekDouble > v_GetMaxStdVelocity (const NekDouble SpeedSoundFactor=1.0)
 
- Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises UnsteadySystem class members. More...
 
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Init object for UnsteadySystem class. More...
 
SOLVER_UTILS_EXPORT void v_DoSolve () override
 Solves an unsteady problem. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintStatusInformation (const int step, const NekDouble cpuTime)
 Print Status Information. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintSummaryStatistics (const NekDouble intTime)
 Print Summary Statistics. More...
 
SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true) override
 Sets up initial conditions. More...
 
SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &s) override
 Print a summary of time stepping parameters. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Return the timestep to be used for the next step in the time-marching loop. More...
 
virtual SOLVER_UTILS_EXPORT bool v_PreIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_RequireFwdTrans ()
 
virtual SOLVER_UTILS_EXPORT void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
virtual SOLVER_UTILS_EXPORT bool v_UpdateTimeStepCheck ()
 
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control. More...
 
SOLVER_UTILS_EXPORT void CheckForRestartTime (NekDouble &time, int &nchk)
 
SOLVER_UTILS_EXPORT void SVVVarDiffCoeff (const Array< OneD, Array< OneD, NekDouble > > vel, StdRegions::VarCoeffMap &varCoeffMap)
 Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h time velocity. More...
 
SOLVER_UTILS_EXPORT void DoDummyProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Perform dummy projection. More...
 
- Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises EquationSystem class members. More...
 
virtual SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareFeld=true)
 Initialisation object for EquationSystem. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true)
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Virtual function for solve implementation. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Virtual function for the L_inf error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the L_2 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the H_1 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys ()
 Virtual function for transformation to physical space. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space. More...
 
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &l)
 Virtual function for generating summary information. More...
 
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure (void)
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp (void)
 Virtual function to identify if operator is negated in DoSolve. More...
 
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
- Protected Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual SOLVER_UTILS_EXPORT void v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)=0
 
virtual SOLVER_UTILS_EXPORT bool v_HasConstantDensity ()=0
 
virtual SOLVER_UTILS_EXPORT void v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density)=0
 
virtual SOLVER_UTILS_EXPORT void v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)=0
 
virtual SOLVER_UTILS_EXPORT void v_SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step)
 
virtual SOLVER_UTILS_EXPORT bool v_GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step)
 
virtual SOLVER_UTILS_EXPORT void v_SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step)
 
virtual SOLVER_UTILS_EXPORT void v_SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot)
 
virtual SOLVER_UTILS_EXPORT bool v_GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step)
 
virtual SOLVER_UTILS_EXPORT void v_SetAeroForce (Array< OneD, NekDouble > forces)
 
virtual SOLVER_UTILS_EXPORT void v_GetAeroForce (Array< OneD, NekDouble > forces)
 

Protected Attributes

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 More...
 
bool m_is_diffIP {false}
 flag to switch between IP and LDG an enum could be added for more options More...
 
bool m_is_shockCaptPhys {false}
 flag for shock capturing switch on/off an enum could be added for more options More...
 
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. More...
 
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. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
LibUtilities::TimeIntegrationSchemeSharedPtr m_intScheme
 Wrapper to the time integration scheme. More...
 
LibUtilities::TimeIntegrationSchemeOperators m_ode
 The time integration scheme operators to use. More...
 
Array< OneD, Array< OneD, NekDouble > > m_previousSolution
 Storage for previous solution for steady-state check. More...
 
std::vector< int > m_intVariables
 
NekDouble m_cflSafetyFactor
 CFL safety factor (comprise between 0 to 1). More...
 
NekDouble m_CFLGrowth
 CFL growth rate. More...
 
NekDouble m_CFLEnd
 Maximun cfl in cfl growth. More...
 
int m_abortSteps
 Number of steps between checks for abort conditions. More...
 
bool m_explicitDiffusion
 Indicates if explicit or implicit treatment of diffusion is used. More...
 
bool m_explicitAdvection
 Indicates if explicit or implicit treatment of advection is used. More...
 
bool m_explicitReaction
 Indicates if explicit or implicit treatment of reaction is used. More...
 
int m_steadyStateSteps
 Check for steady state at step interval. More...
 
NekDouble m_steadyStateTol
 Tolerance to which steady state should be evaluated at. More...
 
int m_filtersInfosteps
 Number of time steps between outputting filters information. More...
 
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
 
bool m_homoInitialFwd
 Flag to determine if simulation should start in homogeneous forward transformed state. More...
 
std::ofstream m_errFile
 
NekDouble m_epsilon
 Diffusion coefficient. More...
 
- Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
bool m_verbose
 
LibUtilities::SessionReaderSharedPtr m_session
 The session reader. More...
 
std::map< std::string, SolverUtils::SessionFunctionSharedPtr > m_sessionFunctions
 Map of known SessionFunctions. More...
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output. More...
 
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
 Array holding all dependent variables. More...
 
SpatialDomains::BoundaryConditionsSharedPtr m_boundaryConditions
 Pointer to boundary conditions object. More...
 
SpatialDomains::MeshGraphSharedPtr m_graph
 Pointer to graph defining mesh. More...
 
std::string m_sessionName
 Name of the session. More...
 
NekDouble m_time
 Current time of simulation. More...
 
int m_initialStep
 Number of the step where the simulation should begin. More...
 
NekDouble m_fintime
 Finish time of the simulation. More...
 
NekDouble m_timestep
 Time step size. More...
 
NekDouble m_lambda
 Lambda constant in real system if one required. More...
 
NekDouble m_checktime
 Time between checkpoints. More...
 
NekDouble m_lastCheckTime
 
NekDouble m_TimeIncrementFactor
 
int m_nchk
 Number of checkpoints written so far. More...
 
int m_steps
 Number of steps to take. More...
 
int m_checksteps
 Number of steps between checkpoints. More...
 
int m_infosteps
 Number of time steps between outputting status information. More...
 
int m_iterPIT = 0
 Number of parallel-in-time time iteration. More...
 
int m_windowPIT = 0
 Index of windows for parallel-in-time time iteration. More...
 
int m_spacedim
 Spatial dimension (>= expansion dim). More...
 
int m_expdim
 Expansion dimension. More...
 
bool m_singleMode
 Flag to determine if single homogeneous mode is used. More...
 
bool m_halfMode
 Flag to determine if half homogeneous mode is used. More...
 
bool m_multipleModes
 Flag to determine if use multiple homogenenous modes are used. More...
 
bool m_useFFT
 Flag to determine if FFT is used for homogeneous transform. More...
 
bool m_homogen_dealiasing
 Flag to determine if dealiasing is used for homogeneous simulations. More...
 
bool m_specHP_dealiasing
 Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More...
 
enum MultiRegions::ProjectionType m_projectionType
 Type of projection; e.g continuous or discontinuous. More...
 
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
 Array holding trace normals for DG simulations in the forwards direction. More...
 
Array< OneD, bool > m_checkIfSystemSingular
 Flag to indicate if the fields should be checked for singularity. More...
 
LibUtilities::FieldMetaDataMap m_fieldMetaDataMap
 Map to identify relevant solver info to dump in output fields. More...
 
Array< OneD, 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. More...
 
std::vector< std::string > m_strFrameData
 variable name in m_movingFrameData More...
 
int m_NumQuadPointsError
 Number of Quadrature points used to work out the error. More...
 
enum HomogeneousType m_HomogeneousType
 
NekDouble m_LhomX
 physical length in X direction (if homogeneous) More...
 
NekDouble m_LhomY
 physical length in Y direction (if homogeneous) More...
 
NekDouble m_LhomZ
 physical length in Z direction (if homogeneous) More...
 
int m_npointsX
 number of points in X direction (if homogeneous) More...
 
int m_npointsY
 number of points in Y direction (if homogeneous) More...
 
int m_npointsZ
 number of points in Z direction (if homogeneous) More...
 
int m_HomoDirec
 number of homogenous directions More...
 
- Protected Attributes inherited from Nektar::SolverUtils::ALEHelper
Array< OneD, MultiRegions::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_ImplicitALESolver = 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. More...
 
Array< OneD, NekDouble > GetStabilityLimitVector (const Array< OneD, int > &ExpOrder)
 Function to calculate the stability limit for DG/CG (a vector of them). More...
 
- Public Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT AdvectionSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
SOLVER_UTILS_EXPORT ~AdvectionSystem () override=default
 
SOLVER_UTILS_EXPORT AdvectionSharedPtr GetAdvObject ()
 Returns the advection object held by this instance. More...
 
SOLVER_UTILS_EXPORT Array< OneD, 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. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Calculate the larger time-step mantaining the problem stable. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void SetTimeStep (const NekDouble timestep)
 
SOLVER_UTILS_EXPORT void SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeSharedPtr & GetTimeIntegrationScheme ()
 Returns the time integration scheme. More...
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeOperators & GetTimeIntegrationSchemeOperators ()
 Returns the time integration scheme operators. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise (bool dumpInitialConditions=true)
 Perform any initialisation necessary before solving the problem. More...
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem. More...
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space. More...
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space. More...
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve. More...
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
std::shared_ptr< T > as ()
 
SOLVER_UTILS_EXPORT void ResetSessionName (std::string newname)
 Reset Session name. More...
 
SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr GetSession ()
 Get Session name. More...
 
SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr GetPressure ()
 Get pressure field if available. More...
 
SOLVER_UTILS_EXPORT void ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
SOLVER_UTILS_EXPORT void PrintSummary (std::ostream &out)
 Print a summary of parameters and solver characteristics. More...
 
SOLVER_UTILS_EXPORT void SetLambda (NekDouble lambda)
 Set parameter m_lambda. More...
 
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
 Get a SessionFunction by name. More...
 
SOLVER_UTILS_EXPORT void SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Initialise the data in the dependent fields. More...
 
SOLVER_UTILS_EXPORT void EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 Evaluates an exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the L2 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, bool Normalised=false)
 Compute the L2 error of the fields. More...
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT NekDouble H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the H1 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > ErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n)
 Write checkpoint file of m_fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 Write checkpoint file of custom data fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_BaseFlow (const int n)
 Write base flow file of m_fields. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname)
 Write field data to the given filename. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 Write input fields to the given filename. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
 Input field data from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFldToMultiDomains (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int ndomains)
 Input field data from the given file to multiple domains. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, std::vector< std::string > &fieldStr, Array< OneD, Array< OneD, NekDouble > > &coeffs)
 Output a field. Input field data into array from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, MultiRegions::ExpListSharedPtr &pField, std::string &pFieldName)
 Output a field. Input field data into ExpList from the given file. More...
 
SOLVER_UTILS_EXPORT void SessionSummary (SummaryList &vSummary)
 Write out a session summary. More...
 
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > & UpdateFields ()
 
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMap & UpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTime ()
 Return final time. More...
 
SOLVER_UTILS_EXPORT int GetNcoeffs ()
 
SOLVER_UTILS_EXPORT int GetNcoeffs (const int eid)
 
SOLVER_UTILS_EXPORT int GetNumExpModes ()
 
SOLVER_UTILS_EXPORT const Array< OneD, int > GetNumExpModesPerExp ()
 
SOLVER_UTILS_EXPORT int GetNvariables ()
 
SOLVER_UTILS_EXPORT const std::string GetVariable (unsigned int i)
 
SOLVER_UTILS_EXPORT int GetTraceTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTraceNpoints ()
 
SOLVER_UTILS_EXPORT int GetExpSize ()
 
SOLVER_UTILS_EXPORT int GetPhys_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetCoeff_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTotPoints (int n)
 
SOLVER_UTILS_EXPORT int GetNpoints ()
 
SOLVER_UTILS_EXPORT int GetSteps ()
 
SOLVER_UTILS_EXPORT void SetSteps (const int steps)
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void CopyToPhysField (const int i, const Array< OneD, const NekDouble > &input)
 
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > & UpdatePhysField (const int i)
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void SetModifiedBasis (const bool modbasis)
 
SOLVER_UTILS_EXPORT int GetCheckpointNumber ()
 
SOLVER_UTILS_EXPORT void SetCheckpointNumber (int num)
 
SOLVER_UTILS_EXPORT int GetCheckpointSteps ()
 
SOLVER_UTILS_EXPORT void SetCheckpointSteps (int num)
 
SOLVER_UTILS_EXPORT int GetInfoSteps ()
 
SOLVER_UTILS_EXPORT void SetInfoSteps (int num)
 
SOLVER_UTILS_EXPORT void SetIterationNumberPIT (int num)
 
SOLVER_UTILS_EXPORT void SetWindowNumberPIT (int num)
 
SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > > GetTraceNormals ()
 
SOLVER_UTILS_EXPORT void SetTime (const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetTimeStep (const NekDouble timestep)
 
SOLVER_UTILS_EXPORT void SetInitialStep (const int step)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
SOLVER_UTILS_EXPORT bool NegatedOp ()
 Identify if operator is negated in DoSolve. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::ALEHelper
virtual ~ALEHelper ()=default
 
virtual SOLVER_UTILS_EXPORT void v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
 
SOLVER_UTILS_EXPORT void InitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
 
virtual SOLVER_UTILS_EXPORT void v_UpdateGridVelocity (const NekDouble &time)
 
virtual SOLVER_UTILS_EXPORT void v_ALEPreMultiplyMass (Array< OneD, Array< OneD, NekDouble > > &fields)
 
SOLVER_UTILS_EXPORT void ALEDoElmtInvMass (Array< OneD, Array< OneD, NekDouble > > &traceNormals, Array< OneD, Array< OneD, NekDouble > > &fields, NekDouble time)
 Update m_fields with u^n by multiplying by inverse mass matrix. That's then used in e.g. checkpoint output and L^2 error calculation. More...
 
SOLVER_UTILS_EXPORT void ALEDoElmtInvMassBwdTrans (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
SOLVER_UTILS_EXPORT void MoveMesh (const NekDouble &time, Array< OneD, Array< OneD, NekDouble > > &traceNormals)
 
const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocity ()
 
SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocityTrace ()
 
SOLVER_UTILS_EXPORT void ExtraFldOutputGridVelocity (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
- Public Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual ~FluidInterface ()=default
 
SOLVER_UTILS_EXPORT void GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)
 Extract array with velocity from physfield. More...
 
SOLVER_UTILS_EXPORT bool HasConstantDensity ()
 
SOLVER_UTILS_EXPORT void GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density)
 Extract array with density from physfield. More...
 
SOLVER_UTILS_EXPORT void GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)
 Extract array with pressure from physfield. More...
 
SOLVER_UTILS_EXPORT void SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step)
 
SOLVER_UTILS_EXPORT bool GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step)
 
SOLVER_UTILS_EXPORT void SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step)
 
SOLVER_UTILS_EXPORT void SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot)
 
SOLVER_UTILS_EXPORT bool GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step)
 
SOLVER_UTILS_EXPORT void SetAeroForce (Array< OneD, NekDouble > forces)
 Set aerodynamic force and moment. More...
 
SOLVER_UTILS_EXPORT void GetAeroForce (Array< OneD, NekDouble > forces)
 Get aerodynamic force and moment. More...
 
- 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::CompressibleFlowSystem::CompressibleFlowSystem
CompressibleFlowSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Definition: CompressibleFlowSystem.cpp:43
Nektar::SolverUtils::UnsteadySystem::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
Definition: UnsteadySystem.cpp:74

◆ ~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
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350
Nektar::SolverUtils::EquationSystemSharedPtr
std::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.
Definition: EquationSystem.h:65

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

◆ 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 784 of file NavierStokesCFE.cpp.

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

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 716 of file NavierStokesCFE.cpp.

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

References Nektar::UnitTests::d(), GetDivCurlFromDvelT(), Nektar::CompressibleFlowSystem::m_diffusion, and CellMLToNektar.cellml_metadata::p.

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 671 of file NavierStokesCFE.cpp.

674{
675 size_t nPts = temperature.size();
676
677 for (size_t p = 0; p < nPts; ++p)
678 {
679 GetViscosityAndThermalCondFromTempKernel(temperature[p], mu[p],
680 thermalCond[p]);
681 }
682
683 // Add artificial viscosity if wanted
684 // move this above and add in kernel
685 if (m_is_shockCaptPhys)
686 {
687 size_t nTracePts = m_fields[0]->GetTrace()->GetTotPoints();
688 if (nPts != nTracePts)
689 {
690 Vmath::Vadd(nPts, mu, 1, m_varConv->GetAv(), 1, mu, 1);
691 }
692 else
693 {
694 Vmath::Vadd(nPts, mu, 1, m_varConv->GetAvTrace(), 1, mu, 1);
695 }
696
697 // Update thermal conductivity
698 NekDouble tRa = m_Cp / m_Prandtl;
699 Vmath::Smul(nPts, tRa, mu, 1, thermalCond, 1);
700 }
701}
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, CellMLToNektar.cellml_metadata::p, Vmath::Smul(), and Vmath::Vadd().

Referenced by GetViscousFluxVectorConservVar(), GetViscousSymmtrFluxConservVar(), Nektar::NavierStokesImplicitCFE::v_CalcMuDmuDT(), 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::UnitTests::d(), 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:671
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 Nektar::UnitTests::d(), GetViscosityAndThermalCondFromTemp(), GetViscousFluxBilinearFormKernel(), tinysimd::is_not_aligned, Nektar::CompressibleFlowSystem::m_varConv, and CellMLToNektar.cellml_metadata::p.

◆ 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 577 of file NavierStokesCFE.cpp.

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

References Nektar::UnitTests::d(), GetViscosityAndThermalCondFromTemp(), GetViscousFluxBilinearFormKernel(), Nektar::CompressibleFlowSystem::m_varConv, and CellMLToNektar.cellml_metadata::p.

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:208
Nektar::CompressibleFlowSystem::SetBoundaryConditionsBwdWeight
void SetBoundaryConditionsBwdWeight()
Set up a weight on physical boundaries for boundary condition applications.
Definition: CompressibleFlowSystem.cpp:427
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: BasicUtils/NekFactory.hpp:143
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:488
Nektar::NavierStokesCFE::m_thermalConductivityRef
NekDouble m_thermalConductivityRef
Definition: NavierStokesCFE.h:93
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:577
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:275
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:629
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:358
Nektar::SolverUtils::ALEHelper::m_gridVelocityTrace
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
Definition: ALEHelper.h:90
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 488 of file NavierStokesCFE.cpp.

490{
491 size_t nConvectiveFields = consvar.size();
492 size_t ndens = 0;
493 size_t nengy = nConvectiveFields - 1;
494
495 Array<OneD, Array<OneD, NekDouble>> bndCons{nConvectiveFields};
496 Array<OneD, NekDouble> bndTotEngy;
497 Array<OneD, NekDouble> bndPressure;
498 Array<OneD, NekDouble> bndRho;
499 Array<OneD, NekDouble> bndIntEndy;
500 size_t nLengthArray = 0;
501
502 size_t cnt = 0;
503 size_t nBndRegions = m_fields[nengy]->GetBndCondExpansions().size();
504 for (size_t j = 0; j < nBndRegions; ++j)
505 {
506 if (m_fields[nengy]
507 ->GetBndConditions()[j]
508 ->GetBoundaryConditionType() == SpatialDomains::ePeriodic)
509 {
510 continue;
511 }
512
513 size_t nBndEdges =
514 m_fields[nengy]->GetBndCondExpansions()[j]->GetExpSize();
515 for (size_t e = 0; e < nBndEdges; ++e)
516 {
517 size_t nBndEdgePts = m_fields[nengy]
518 ->GetBndCondExpansions()[j]
519 ->GetExp(e)
520 ->GetTotPoints();
521
522 int id2 = m_fields[0]->GetTrace()->GetPhys_Offset(
523 m_fields[0]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt++));
524
525 // Imposing Temperature Twall at the wall
526 if (boost::iequals(
527 m_fields[nengy]->GetBndConditions()[j]->GetUserDefined(),
528 "WallViscous"))
529 {
530 if (nBndEdgePts != nLengthArray)
531 {
532 for (size_t i = 0; i < nConvectiveFields; ++i)
533 {
534 bndCons[i] = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
535 }
536 bndTotEngy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
537 bndPressure = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
538 bndRho = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
539 bndIntEndy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
540 nLengthArray = nBndEdgePts;
541 }
542 else
543 {
544 Vmath::Zero(nLengthArray, bndPressure, 1);
545 Vmath::Zero(nLengthArray, bndRho, 1);
546 Vmath::Zero(nLengthArray, bndIntEndy, 1);
547 }
548
549 Array<OneD, NekDouble> tmp;
550
551 for (size_t k = 0; k < nConvectiveFields; ++k)
552 {
553 Vmath::Vcopy(nBndEdgePts, tmp = consvar[k] + id2, 1,
554 bndCons[k], 1);
555 }
556
557 m_varConv->GetPressure(bndCons, bndPressure);
558 Vmath::Fill(nLengthArray, m_Twall, bndTotEngy, 1);
559 m_varConv->GetRhoFromPT(bndPressure, bndTotEngy, bndRho);
560 m_varConv->GetEFromRhoP(bndRho, bndPressure, bndIntEndy);
561 m_varConv->GetDynamicEnergy(bndCons, bndTotEngy);
562
563 Vmath::Vvtvp(nBndEdgePts, bndIntEndy, 1, bndCons[ndens], 1,
564 bndTotEngy, 1, bndTotEngy, 1);
565
566 Vmath::Vcopy(nBndEdgePts, bndTotEngy, 1,
567 tmp = consvar[nengy] + id2, 1);
568 }
569 }
570 }
571}
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 =
156 m_ALESolver ? GetNcoeffs()
157 : npointsIn; // If ALE then outarray is in coefficient space
158 size_t nTracePts = GetTraceTotPoints();
159
160 // this should be preallocated
161 Array<OneD, Array<OneD, NekDouble>> outarrayDiff(nvariables);
162 for (size_t i = 0; i < nvariables; ++i)
163 {
164 outarrayDiff[i] = Array<OneD, NekDouble>(npointsOut, 0.0);
165 }
166
167 // Set artificial viscosity based on NS viscous tensor
168 if (m_is_shockCaptPhys)
169 {
170 if (m_varConv->GetFlagCalcDivCurl())
171 {
172 Array<OneD, NekDouble> div(npointsIn), curlSquare(npointsIn);
173 GetDivCurlSquared(m_fields, inarray, div, curlSquare, pFwd, pBwd);
174
175 // Set volume and trace artificial viscosity
176 m_varConv->SetAv(m_fields, inarray, div, curlSquare);
177 }
178 else
179 {
180 m_varConv->SetAv(m_fields, inarray);
181 }
182 }
183
184 if (m_is_diffIP)
185 {
186 if (m_bndEvaluateTime < 0.0)
187 {
188 NEKERROR(ErrorUtil::efatal, "m_bndEvaluateTime not setup");
189 }
190
191 // Diffusion term in physical rhs form
192 if (m_ALESolver)
193 {
194 m_diffusion->DiffuseCoeffs(nvariables, m_fields, inarray,
195 outarrayDiff, m_bndEvaluateTime, pFwd,
196 pBwd);
197 }
198 else
199 {
200 m_diffusion->Diffuse(nvariables, m_fields, inarray, outarrayDiff,
201 m_bndEvaluateTime, pFwd, pBwd);
202 }
203 for (size_t i = 0; i < nvariables; ++i)
204 {
205 Vmath::Vadd(npointsOut, outarrayDiff[i], 1, outarray[i], 1,
206 outarray[i], 1);
207 }
208 }
209 else
210 {
211 // Get primitive variables [u,v,w,T]
212 Array<OneD, Array<OneD, NekDouble>> inarrayDiff(nvariables - 1);
213 Array<OneD, Array<OneD, NekDouble>> inFwd(nvariables - 1);
214 Array<OneD, Array<OneD, NekDouble>> inBwd(nvariables - 1);
215
216 for (size_t i = 0; i < nvariables - 1; ++i)
217 {
218 inarrayDiff[i] = Array<OneD, NekDouble>{npointsIn};
219 inFwd[i] = Array<OneD, NekDouble>{nTracePts};
220 inBwd[i] = Array<OneD, NekDouble>{nTracePts};
221 }
222
223 // Extract temperature
224 m_varConv->GetTemperature(inarray, inarrayDiff[nvariables - 2]);
225
226 // Extract velocities
227 m_varConv->GetVelocityVector(inarray, inarrayDiff);
228
229 // Repeat calculation for trace space
230 if (pFwd == NullNekDoubleArrayOfArray ||
231 pBwd == NullNekDoubleArrayOfArray)
232 {
233 inFwd = NullNekDoubleArrayOfArray;
234 inBwd = NullNekDoubleArrayOfArray;
235 }
236 else
237 {
238 m_varConv->GetTemperature(pFwd, inFwd[nvariables - 2]);
239 m_varConv->GetTemperature(pBwd, inBwd[nvariables - 2]);
240
241 m_varConv->GetVelocityVector(pFwd, inFwd);
242 m_varConv->GetVelocityVector(pBwd, inBwd);
243 }
244
245 // Diffusion term in physical rhs form
246 if (m_ALESolver)
247 {
248 m_diffusion->DiffuseCoeffs(nvariables, m_fields, inarrayDiff,
249 outarrayDiff, inFwd, inBwd);
250 }
251 else
252 {
253 m_diffusion->Diffuse(nvariables, m_fields, inarrayDiff,
254 outarrayDiff, inFwd, inBwd);
255 }
256
257 for (size_t i = 0; i < nvariables; ++i)
258 {
259 Vmath::Vadd(npointsOut, outarrayDiff[i], 1, outarray[i], 1,
260 outarray[i], 1);
261 }
262 }
263
264 // Add artificial diffusion through Laplacian operator
265 if (m_artificialDiffusion)
266 {
267 m_artificialDiffusion->DoArtificialDiffusion(inarray, outarray);
268 }
269}
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:202
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:716
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:920

References Nektar::ErrorUtil::efatal, GetDivCurlSquared(), Nektar::SolverUtils::EquationSystem::GetNcoeffs(), Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::ALEHelper::m_ALESolver, Nektar::CompressibleFlowSystem::m_artificialDiffusion, Nektar::CompressibleFlowSystem::m_bndEvaluateTime, Nektar::CompressibleFlowSystem::m_diffusion, Nektar::SolverUtils::EquationSystem::m_fields, m_is_diffIP, m_is_shockCaptPhys, 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 854 of file NavierStokesCFE.cpp.

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

◆ 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 629 of file NavierStokesCFE.cpp.

633{
634 size_t nTracePts = uFwd[0].size();
635
636 // Compute average temperature
637 size_t nVariables = uFwd.size();
638 Array<OneD, NekDouble> tAve{nTracePts, 0.0};
639 Vmath::Svtsvtp(nTracePts, 0.5, uFwd[nVariables - 1], 1, 0.5,
640 uBwd[nVariables - 1], 1, tAve, 1);
641
642 // Get average viscosity and thermal conductivity
643 Array<OneD, NekDouble> muAve{nTracePts, 0.0};
644 Array<OneD, NekDouble> tcAve{nTracePts, 0.0};
645
646 GetViscosityAndThermalCondFromTemp(tAve, muAve, tcAve);
647
648 // Compute penalty term
649 for (size_t i = 0; i < nVariables; ++i)
650 {
651 // Get jump of u variables
652 Vmath::Vsub(nTracePts, uFwd[i], 1, uBwd[i], 1, penaltyCoeff[i], 1);
653 // Multiply by variable coefficient = {coeff} ( u^+ - u^- )
654 if (i < nVariables - 1)
655 {
656 Vmath::Vmul(nTracePts, muAve, 1, penaltyCoeff[i], 1,
657 penaltyCoeff[i], 1);
658 }
659 else
660 {
661 Vmath::Vmul(nTracePts, tcAve, 1, penaltyCoeff[i], 1,
662 penaltyCoeff[i], 1);
663 }
664 }
665}
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 275 of file NavierStokesCFE.cpp.

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

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 358 of file NavierStokesCFE.cpp.

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

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 978 of file NavierStokesCFE.cpp.

979{
980 if (type == "NonSmooth" || type == "Physical" || type == "Off")
981 {
982 return true;
983 }
984 else
985 {
986 return false;
987 }
988}

Friends And Related Function 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:197
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.

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.

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.

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 Jun 15 2025 07:52:37 for Nektar++ by doxygen 1.9.4