Nektar++
Public Member Functions | 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]

Public Member Functions

virtual ~NavierStokesCFE ()
 
- Public Member Functions inherited from Nektar::CompressibleFlowSystem
virtual ~CompressibleFlowSystem ()
 Destructor for CompressibleFlowSystem class. More...
 
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...
 
virtual void GetPressure (const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, NekDouble > &pressure)
 Extract array with pressure from physfield. More...
 
virtual void GetDensity (const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, NekDouble > &density)
 Extract array with density from physfield. More...
 
virtual bool HasConstantDensity ()
 
virtual void GetVelocity (const Array< OneD, const Array< OneD, NekDouble >> &physfield, Array< OneD, Array< OneD, NekDouble >> &velocity)
 Extract array with velocity from physfield. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT AdvectionSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
virtual SOLVER_UTILS_EXPORT ~AdvectionSystem ()
 
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
virtual SOLVER_UTILS_EXPORT ~UnsteadySystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep (const Array< OneD, const Array< OneD, NekDouble >> &inarray)
 Calculate the larger time-step mantaining the problem stable. More...
 
SOLVER_UTILS_EXPORT void SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void SetUpTraceNormals (void)
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise ()
 Perform any initialisation necessary before solving the problem. More...
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem. More...
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space. More...
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space. More...
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve. More...
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
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 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 GetFinalTime ()
 Return final time. More...
 
SOLVER_UTILS_EXPORT int GetNcoeffs ()
 
SOLVER_UTILS_EXPORT int GetNcoeffs (const int eid)
 
SOLVER_UTILS_EXPORT int GetNumExpModes ()
 
SOLVER_UTILS_EXPORT const Array< OneD, int > GetNumExpModesPerExp ()
 
SOLVER_UTILS_EXPORT int GetNvariables ()
 
SOLVER_UTILS_EXPORT const std::string GetVariable (unsigned int i)
 
SOLVER_UTILS_EXPORT int GetTraceTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTraceNpoints ()
 
SOLVER_UTILS_EXPORT int GetExpSize ()
 
SOLVER_UTILS_EXPORT int GetPhys_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetCoeff_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTotPoints (int n)
 
SOLVER_UTILS_EXPORT int GetNpoints ()
 
SOLVER_UTILS_EXPORT int GetSteps ()
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void CopyToPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void SetSteps (const int steps)
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void 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 Array< OneD, const Array< OneD, NekDouble > > GetTraceNormals ()
 
SOLVER_UTILS_EXPORT void SetTime (const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetInitialStep (const int step)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp ()
 Virtual function to identify if operator is negated in DoSolve. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual ~FluidInterface ()=default
 
virtual SOLVER_UTILS_EXPORT void SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels)
 
virtual SOLVER_UTILS_EXPORT void GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels)
 
virtual SOLVER_UTILS_EXPORT void SetMovingFrameProjectionMat (const boost::numeric::ublas::matrix< NekDouble > &vProjMat)
 
virtual SOLVER_UTILS_EXPORT void GetMovingFrameProjectionMat (boost::numeric::ublas::matrix< NekDouble > &vProjMat)
 
virtual SOLVER_UTILS_EXPORT void SetMovingFrameAngles (const Array< OneD, NekDouble > &vFrameTheta)
 
virtual SOLVER_UTILS_EXPORT void GetMovingFrameAngles (Array< OneD, NekDouble > &vFrameTheta)
 

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)
 
void GetViscousFluxVectorConservVar (const int 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 int 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 ()
 
virtual void v_InitObject (bool DeclareField=true) override
 Initialization object for CompressibleFlowSystem class. More...
 
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) override
 Apply artificial diffusion (Laplacian operator) More...
 
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...
 
virtual 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<T>::value || tinysimd::is_vector_floating_point<T>::value>::type>
void GetViscosityAndThermalCondFromTempKernel (const T &temperature, T &mu, T &thermalCond)
 
template<class T , typename = typename std::enable_if< std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value>::type>
void GetViscosityFromTempKernel (const T &temperature, T &mu)
 
template<class T , typename = typename std::enable_if< std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value>::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 int 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...
 
- Protected Member Functions inherited from Nektar::CompressibleFlowSystem
 CompressibleFlowSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
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...
 
virtual NekDouble v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble >> &inarray)
 Calculate the maximum timestep subject to CFL restrictions. More...
 
virtual void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Set up logic for residual calculation. More...
 
NekDouble GetGamma ()
 
const Array< OneD, const Array< OneD, NekDouble > > & GetVecLocs ()
 
const Array< OneD, const Array< OneD, NekDouble > > & GetNormals ()
 
virtual Array< OneD, NekDouble > v_GetMaxStdVelocity (const NekDouble SpeedSoundFactor)
 Compute the advection velocity in the standard space for each element of the expansion. More...
 
virtual void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
- Protected Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
virtual SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step)
 
- 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 NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Solves an unsteady problem. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoInitialise ()
 Sets up initial conditions. More...
 
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &s)
 Print a summary of time stepping parameters. More...
 
virtual SOLVER_UTILS_EXPORT void v_AppendOutput1D (Array< OneD, Array< OneD, NekDouble >> &solution1D)
 Print the solution at each solution point in a txt file. More...
 
virtual SOLVER_UTILS_EXPORT bool v_PreIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_RequireFwdTrans ()
 
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...
 
virtual SOLVER_UTILS_EXPORT bool UpdateTimeStepCheck ()
 
- 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 NekDouble v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Virtual function for the L_inf error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the L_2 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT void v_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_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)
 

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
int m_infosteps
 Number of time steps between outputting status information. More...
 
int m_abortSteps
 Number of steps between checks for abort conditions. More...
 
int m_filtersInfosteps
 Number of time steps between outputting filters information. More...
 
int m_nanSteps
 
LibUtilities::TimeIntegrationSchemeSharedPtr m_intScheme
 Wrapper to the time integration scheme. More...
 
LibUtilities::TimeIntegrationSchemeOperators m_ode
 The time integration scheme operators to use. More...
 
NekDouble m_epsilon
 
bool m_explicitDiffusion
 Indicates if explicit or implicit treatment of diffusion is used. More...
 
bool m_explicitAdvection
 Indicates if explicit or implicit treatment of advection is used. More...
 
bool m_explicitReaction
 Indicates if explicit or implicit treatment of reaction is used. More...
 
bool m_homoInitialFwd
 Flag to determine if simulation should start in homogeneous forward transformed state. More...
 
NekDouble m_steadyStateTol
 Tolerance to which steady state should be evaluated at. More...
 
int m_steadyStateSteps
 Check for steady state at step interval. More...
 
NekDouble m_steadyStateRes = 1.0
 
NekDouble m_steadyStateRes0 = 1.0
 
Array< OneD, Array< OneD, NekDouble > > m_previousSolution
 Storage for previous solution for steady-state check. More...
 
std::ofstream m_errFile
 
std::vector< int > m_intVariables
 
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
 
NekDouble m_filterTimeWarning
 Number of time steps between outputting status information. More...
 
NekDouble m_TimeIntegLambda = 0.0
 coefff of spacial derivatives(rhs or m_F in GLM) in calculating the residual of the whole equation(used in unsteady time integrations) More...
 
bool m_flagImplicitItsStatistics
 
bool m_flagImplicitSolver = false
 
Array< OneD, NekDouble > m_magnitdEstimat
 estimate the magnitude of each conserved varibles More...
 
Array< OneD, NekDouble > m_locTimeStep
 local time step(notice only for jfnk other see m_cflSafetyFactor) More...
 
NekDouble m_inArrayNorm = -1.0
 
int m_TotLinItePerStep = 0
 
int m_StagesPerStep = 1
 
bool m_flagUpdatePreconMat
 
int m_maxLinItePerNewton
 
int m_TotNewtonIts = 0
 
int m_TotLinIts = 0
 
int m_TotImpStages = 0
 
bool m_CalcPhysicalAV = true
 flag to update artificial viscosity More...
 
- Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
bool m_verbose
 
bool m_root
 
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_timestepMax = -1.0
 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_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_movingFrameVelsxyz
 Moving frame of reference velocities. More...
 
Array< OneD, NekDouble > m_movingFrameTheta
 Moving frame of reference angles with respect to the. More...
 
boost::numeric::ublas::matrix< NekDouble > m_movingFrameProjMat
 Projection matrix for transformation between inertial and moving. 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...
 

Friends

class MemoryManager< NavierStokesCFE >
 

Additional Inherited Members

- Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
NekDouble m_cflSafetyFactor
 CFL safety factor (comprise between 0 to 1). More...
 
NekDouble m_cflNonAcoustic
 
NekDouble m_CFLGrowth
 CFL growth rate. More...
 
NekDouble m_CFLEnd
 maximun cfl in cfl growth 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 []
 

Detailed Description

Definition at line 49 of file NavierStokesCFE.h.

Constructor & Destructor Documentation

◆ ~NavierStokesCFE()

Nektar::NavierStokesCFE::~NavierStokesCFE ( )
virtual

Definition at line 53 of file NavierStokesCFE.cpp.

54 {
55 }

◆ NavierStokesCFE()

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

Definition at line 46 of file NavierStokesCFE.cpp.

49  : UnsteadySystem(pSession, pGraph), CompressibleFlowSystem(pSession, pGraph)
50 {
51 }
Nektar::CompressibleFlowSystem::CompressibleFlowSystem
CompressibleFlowSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Definition: CompressibleFlowSystem.cpp:45
Nektar::SolverUtils::UnsteadySystem::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
Definition: UnsteadySystem.cpp:68

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 55 of file NavierStokesCFE.h.

58  {
59  SolverUtils::EquationSystemSharedPtr p =
60  MemoryManager<NavierStokesCFE>::AllocateSharedPtr(pSession, pGraph);
61  p->InitObject();
62  return p;
63  }
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:168
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:63

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

762 {
763  auto nDim = pVarDer.size();
764  auto nPts = div.size();
765 
766  // div velocity
767  for (size_t p = 0; p < nPts; ++p)
768  {
769  NekDouble divTmp = 0;
770  for (unsigned short j = 0; j < nDim; ++j)
771  {
772  divTmp += pVarDer[j][j][p];
773  }
774  div[p] = divTmp;
775  }
776 
777  // |curl velocity| ** 2
778  if (nDim > 2)
779  {
780  for (size_t p = 0; p < nPts; ++p)
781  {
782  // curl[0] 3/2 - 2/3
783  NekDouble curl032 = pVarDer[2][1][p]; // load 1x
784  NekDouble curl023 = pVarDer[1][2][p]; // load 1x
785  NekDouble curl0 = curl032 - curl023;
786  // square curl[0]
787  NekDouble curl0sqr = curl0 * curl0;
788 
789  // curl[1] 3/1 - 1/3
790  NekDouble curl131 = pVarDer[2][0][p]; // load 1x
791  NekDouble curl113 = pVarDer[0][2][p]; // load 1x
792  NekDouble curl1 = curl131 - curl113;
793  // square curl[1]
794  NekDouble curl1sqr = curl1 * curl1;
795 
796  // curl[2] 1/2 - 2/1
797  NekDouble curl212 = pVarDer[0][1][p]; // load 1x
798  NekDouble curl221 = pVarDer[1][0][p]; // load 1x
799  NekDouble curl2 = curl212 - curl221;
800  // square curl[2]
801  NekDouble curl2sqr = curl2 * curl2;
802 
803  // reduce
804  curl0sqr += curl1sqr + curl2sqr;
805  // store
806  curlSquare[p] = curl0sqr; // store 1x
807  }
808  }
809  else if (nDim > 1)
810  {
811  for (size_t p = 0; p < nPts; ++p)
812  {
813  // curl[2] 1/2
814  NekDouble c212 = pVarDer[0][1][p]; // load 1x
815  // curl[2] 2/1
816  NekDouble c221 = pVarDer[1][0][p]; // load 1x
817  // curl[2] 1/2 - 2/1
818  NekDouble curl = c212 - c221;
819  // square curl[2]
820  curlSquare[p] = curl * curl; // store 1x
821  }
822  }
823  else
824  {
825  Vmath::Fill(nPts, 0.0, curlSquare, 1);
826  }
827 }
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.cpp:45

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

697 {
698  auto nDim = fields[0]->GetCoordim(0);
699  auto nVar = cnsVar.size();
700  auto nPts = cnsVar[0].size();
701  auto nPtsTrc = cnsVarFwd[0].size();
702 
703  // These should be allocated once
704  Array<OneD, Array<OneD, NekDouble>> primVar(nVar - 1), primVarFwd(nVar - 1),
705  primVarBwd(nVar - 1);
706 
707  for (unsigned short d = 0; d < nVar - 2; ++d)
708  {
709  primVar[d] = Array<OneD, NekDouble>(nPts, 0.0);
710  primVarFwd[d] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
711  primVarBwd[d] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
712  }
713  auto ergLoc = nVar - 2;
714  primVar[ergLoc] = Array<OneD, NekDouble>(nPts, 0.0);
715  primVarFwd[ergLoc] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
716  primVarBwd[ergLoc] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
717 
718  // Get primitive variables [u,v,w,T=0]
719  // Possibly should be changed to [rho,u,v,w,T] to make IP and LDGNS more
720  // consistent with each other
721  for (unsigned short d = 0; d < nVar - 2; ++d)
722  {
723  // Volume
724  for (size_t p = 0; p < nPts; ++p)
725  {
726  primVar[d][p] = cnsVar[d + 1][p] / cnsVar[0][p];
727  }
728  // Trace
729  for (size_t p = 0; p < nPtsTrc; ++p)
730  {
731  primVarFwd[d][p] = cnsVarFwd[d + 1][p] / cnsVarFwd[0][p];
732  primVarBwd[d][p] = cnsVarBwd[d + 1][p] / cnsVarBwd[0][p];
733  }
734  }
735 
736  // this should be allocated once
737  Array<OneD, Array<OneD, Array<OneD, NekDouble>>> primVarDer(nDim);
738  for (unsigned short j = 0; j < nDim; ++j)
739  {
740  primVarDer[j] = Array<OneD, Array<OneD, NekDouble>>(nVar - 1);
741  for (unsigned short i = 0; i < nVar - 1; ++i)
742  {
743  primVarDer[j][i] = Array<OneD, NekDouble>(nPts, 0.0);
744  }
745  }
746 
747  // Get derivative tensor
748  m_diffusion->DiffuseCalcDerivative(fields, primVar, primVarDer, primVarFwd,
749  primVarBwd);
750 
751  // Get div curl squared
752  GetDivCurlFromDvelT(primVarDer, div, curlSquare);
753 }
Nektar::CompressibleFlowSystem::m_diffusion
SolverUtils::DiffusionSharedPtr m_diffusion
Definition: CompressibleFlowSystem.h:94
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:759

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

Referenced by v_DoDiffusion(), 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 646 of file NavierStokesCFE.cpp.

649 {
650  auto nPts = temperature.size();
651 
652  for (size_t p = 0; p < nPts; ++p)
653  {
654  GetViscosityAndThermalCondFromTempKernel(temperature[p], mu[p],
655  thermalCond[p]);
656  }
657 
658  // Add artificial viscosity if wanted
659  // move this above and add in kernel
660  if (m_is_shockCaptPhys)
661  {
662  auto nTracePts = m_fields[0]->GetTrace()->GetTotPoints();
663  if (nPts != nTracePts)
664  {
665  Vmath::Vadd(nPts, mu, 1, m_varConv->GetAv(), 1, mu, 1);
666  }
667  else
668  {
669  Vmath::Vadd(nPts, mu, 1, m_varConv->GetAvTrace(), 1, mu, 1);
670  }
671 
672  // Update thermal conductivity
673  NekDouble tRa = m_Cp / m_Prandtl;
674  Vmath::Smul(nPts, tRa, mu, 1, thermalCond, 1);
675  }
676 }
Nektar::CompressibleFlowSystem::m_varConv
VariableConverterSharedPtr m_varConv
Definition: CompressibleFlowSystem.h:116
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:79
Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTempKernel
void GetViscosityAndThermalCondFromTempKernel(const T &temperature, T &mu, T &thermalCond)
Definition: NavierStokesCFE.h:175
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:335
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:359
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.cpp:248

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<T>::value || tinysimd::is_vector_floating_point<T>::value>::type>
void Nektar::NavierStokesCFE::GetViscosityAndThermalCondFromTempKernel ( const T &  temperature,
T &  mu,
T &  thermalCond 
)
inlineprotected

Definition at line 175 of file NavierStokesCFE.h.

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

References GetViscosityFromTempKernel(), m_Cp, and m_Prandtl.

Referenced by GetViscosityAndThermalCondFromTemp().

◆ GetViscosityFromTempKernel()

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

Definition at line 186 of file NavierStokesCFE.h.

187  {
188  // Variable viscosity through the Sutherland's law
189  if (m_is_mu_variable)
190  {
191  mu = m_varConv->GetDynamicViscosity(temperature);
192  }
193  else
194  {
195  mu = m_muRef;
196  }
197  }
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:73

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<T>::value || tinysimd::is_vector_floating_point<T>::value>::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 210 of file NavierStokesCFE.h.

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

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

Referenced by GetViscousFluxVectorConservVar(), and GetViscousSymmtrFluxConservVar().

◆ GetViscousFluxVectorConservVar() [1/2]

template<bool IS_TRACE>
void Nektar::NavierStokesCFE::GetViscousFluxVectorConservVar ( const int  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 346 of file NavierStokesCFE.h.

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

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

◆ GetViscousFluxVectorConservVar() [2/2]

void Nektar::NavierStokesCFE::GetViscousFluxVectorConservVar ( const int  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 int  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 552 of file NavierStokesCFE.cpp.

557 {
558  size_t nConvectiveFields = inarray.size();
559  size_t nPts = inaverg[nConvectiveFields - 1].size();
560  nonZeroIndex = Array<OneD, int>{nConvectiveFields - 1, 0};
561  for (int i = 0; i < nConvectiveFields - 1; ++i)
562  {
563  nonZeroIndex[i] = i + 1;
564  }
565 
566  Array<OneD, NekDouble> mu(nPts, 0.0);
567  Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
568  Array<OneD, NekDouble> temperature(nPts, 0.0);
569  m_varConv->GetTemperature(inaverg, temperature);
570  GetViscosityAndThermalCondFromTemp(temperature, mu, thermalConductivity);
571 
572  std::vector<NekDouble> inAvgTmp(nConvectiveFields);
573  std::vector<NekDouble> inTmp(nConvectiveFields);
574  std::vector<NekDouble> outTmp(nConvectiveFields);
575  for (int d = 0; d < nDim; ++d)
576  {
577  for (int nderiv = 0; nderiv < nDim; ++nderiv)
578  {
579  for (size_t p = 0; p < nPts; ++p)
580  {
581  // rearrenge data
582  for (int f = 0; f < nConvectiveFields; ++f)
583  {
584  inAvgTmp[f] = inaverg[f][p];
585  inTmp[f] = inarray[f][p];
586  }
587 
588  GetViscousFluxBilinearFormKernel(nDim, d, nderiv,
589  inAvgTmp.data(), inTmp.data(),
590  mu[p], outTmp.data());
591 
592  for (int f = 0; f < nConvectiveFields; ++f)
593  {
594  outarray[d][f][p] += normal[nderiv][p] * outTmp[f];
595  }
596  }
597  }
598  }
599 }

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

70 {
71  // Get gas constant from session file and compute Cp
72  NekDouble gasConstant;
73  m_session->LoadParameter("GasConstant", gasConstant, 287.058);
74  m_Cp = m_gamma / (m_gamma - 1.0) * gasConstant;
75  m_Cv = m_Cp / m_gamma;
76 
77  m_session->LoadParameter("Twall", m_Twall, 300.15);
78 
79  // Viscosity
80  m_session->LoadSolverInfo("ViscosityType", m_ViscosityType, "Constant");
81  m_session->LoadParameter("mu", m_muRef, 1.78e-05);
82  if (m_ViscosityType == "Variable")
83  {
84  m_is_mu_variable = true;
85  }
86 
87  // Thermal conductivity or Prandtl
88  if (m_session->DefinesParameter("thermalConductivity"))
89  {
90  ASSERTL0(!m_session->DefinesParameter("Pr"),
91  "Cannot define both Pr and thermalConductivity.");
92 
93  m_session->LoadParameter("thermalConductivity",
94  m_thermalConductivityRef);
95  m_Prandtl = m_Cp * m_muRef / m_thermalConductivityRef;
96  }
97  else
98  {
99  m_session->LoadParameter("Pr", m_Prandtl, 0.72);
100  m_thermalConductivityRef = m_Cp * m_muRef / m_Prandtl;
101  }
102 
103  if (m_shockCaptureType == "Physical")
104  {
105  m_is_shockCaptPhys = true;
106  }
107 
108  string diffName;
109  m_session->LoadSolverInfo("DiffusionType", diffName, "LDGNS");
110 
111  m_diffusion =
112  SolverUtils::GetDiffusionFactory().CreateInstance(diffName, diffName);
113  if ("InteriorPenalty" == diffName)
114  {
115  m_is_diffIP = true;
116  SetBoundaryConditionsBwdWeight();
117  }
118 
119  if ("LDGNS" == diffName || "LDGNS3DHomogeneous1D" == diffName)
120  {
121  m_diffusion->SetFluxPenaltyNS(&NavierStokesCFE::v_GetFluxPenalty, this);
122  }
123 
124  if (m_specHP_dealiasing)
125  {
126  m_diffusion->SetFluxVectorNS(
127  &NavierStokesCFE::v_GetViscousFluxVectorDeAlias, this);
128  }
129  else
130  {
131  m_diffusion->SetFluxVectorNS(&NavierStokesCFE::v_GetViscousFluxVector,
132  this);
133  }
134 
135  m_diffusion->SetDiffusionFluxCons(
136  &NavierStokesCFE::GetViscousFluxVectorConservVar<false>, this);
137 
138  m_diffusion->SetDiffusionFluxConsTrace(
139  &NavierStokesCFE::GetViscousFluxVectorConservVar<true>, this);
140 
141  m_diffusion->SetSpecialBndTreat(&NavierStokesCFE::SpecialBndTreat, this);
142 
143  m_diffusion->SetDiffusionSymmFluxCons(
144  &NavierStokesCFE::GetViscousSymmtrFluxConservVar, this);
145 
146  // Concluding initialisation of diffusion operator
147  m_diffusion->InitObject(m_session, m_fields);
148 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
Nektar::CompressibleFlowSystem::SetBoundaryConditionsBwdWeight
void SetBoundaryConditionsBwdWeight()
Set up a weight on physical boundaries for boundary condition applications.
Definition: CompressibleFlowSystem.cpp:387
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:144
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:250
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:463
Nektar::NavierStokesCFE::m_thermalConductivityRef
NekDouble m_thermalConductivityRef
Definition: NavierStokesCFE.h:94
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:333
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:76
Nektar::NavierStokesCFE::GetViscousSymmtrFluxConservVar
void GetViscousSymmtrFluxConservVar(const int 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:552
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:604
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:388
Nektar::SolverUtils::EquationSystem::m_session
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Definition: EquationSystem.h:328
Nektar::SolverUtils::GetDiffusionFactory
DiffusionFactory & GetDiffusionFactory()
Definition: Diffusion.cpp:41

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

465 {
466  size_t nConvectiveFields = consvar.size();
467  int ndens = 0;
468  int nengy = nConvectiveFields - 1;
469 
470  Array<OneD, Array<OneD, NekDouble>> bndCons{nConvectiveFields};
471  Array<OneD, NekDouble> bndTotEngy;
472  Array<OneD, NekDouble> bndPressure;
473  Array<OneD, NekDouble> bndRho;
474  Array<OneD, NekDouble> bndIntEndy;
475  int nLengthArray = 0;
476 
477  int cnt = 0;
478  int nBndRegions = m_fields[nengy]->GetBndCondExpansions().size();
479  for (int j = 0; j < nBndRegions; ++j)
480  {
481  if (m_fields[nengy]
482  ->GetBndConditions()[j]
483  ->GetBoundaryConditionType() == SpatialDomains::ePeriodic)
484  {
485  continue;
486  }
487 
488  size_t nBndEdges =
489  m_fields[nengy]->GetBndCondExpansions()[j]->GetExpSize();
490  for (int e = 0; e < nBndEdges; ++e)
491  {
492  size_t nBndEdgePts = m_fields[nengy]
493  ->GetBndCondExpansions()[j]
494  ->GetExp(e)
495  ->GetTotPoints();
496 
497  int id2 = m_fields[0]->GetTrace()->GetPhys_Offset(
498  m_fields[0]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt++));
499 
500  // Imposing Temperature Twall at the wall
501  if (boost::iequals(
502  m_fields[nengy]->GetBndConditions()[j]->GetUserDefined(),
503  "WallViscous"))
504  {
505  if (nBndEdgePts != nLengthArray)
506  {
507  for (int i = 0; i < nConvectiveFields; ++i)
508  {
509  bndCons[i] = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
510  }
511  bndTotEngy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
512  bndPressure = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
513  bndRho = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
514  bndIntEndy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
515  nLengthArray = nBndEdgePts;
516  }
517  else
518  {
519  Vmath::Zero(nLengthArray, bndPressure, 1);
520  Vmath::Zero(nLengthArray, bndRho, 1);
521  Vmath::Zero(nLengthArray, bndIntEndy, 1);
522  }
523 
524  Array<OneD, NekDouble> tmp;
525 
526  for (int k = 0; k < nConvectiveFields; ++k)
527  {
528  Vmath::Vcopy(nBndEdgePts, tmp = consvar[k] + id2, 1,
529  bndCons[k], 1);
530  }
531 
532  m_varConv->GetPressure(bndCons, bndPressure);
533  Vmath::Fill(nLengthArray, m_Twall, bndTotEngy, 1);
534  m_varConv->GetRhoFromPT(bndPressure, bndTotEngy, bndRho);
535  m_varConv->GetEFromRhoP(bndRho, bndPressure, bndIntEndy);
536  m_varConv->GetDynamicEnergy(bndCons, bndTotEngy);
537 
538  Vmath::Vvtvp(nBndEdgePts, bndIntEndy, 1, bndCons[ndens], 1,
539  bndTotEngy, 1, bndTotEngy, 1);
540 
541  Vmath::Vcopy(nBndEdgePts, bndTotEngy, 1,
542  tmp = consvar[nengy] + id2, 1);
543  }
544  }
545  }
546 }
Vmath::Vvtvp
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:574
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:492
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1255

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

Apply artificial diffusion (Laplacian operator)

Reimplemented from Nektar::CompressibleFlowSystem.

Reimplemented in Nektar::NavierStokesCFEAxisym.

Definition at line 150 of file NavierStokesCFE.cpp.

155 {
156  size_t nvariables = inarray.size();
157  size_t npoints = GetNpoints();
158  size_t nTracePts = GetTraceTotPoints();
159 
160  // this should be preallocated
161  Array<OneD, Array<OneD, NekDouble>> outarrayDiff(nvariables);
162  for (int i = 0; i < nvariables; ++i)
163  {
164  outarrayDiff[i] = Array<OneD, NekDouble>(npoints, 0.0);
165  }
166 
167  // Set artificial viscosity based on NS viscous tensor
168  if (m_is_shockCaptPhys)
169  {
170  Array<OneD, NekDouble> div(npoints), curlSquare(npoints);
171  GetDivCurlSquared(m_fields, inarray, div, curlSquare, pFwd, pBwd);
172 
173  // Set volume and trace artificial viscosity
174  m_varConv->SetAv(m_fields, inarray, div, curlSquare);
175  }
176 
177  if (m_is_diffIP)
178  {
179  if (m_bndEvaluateTime < 0.0)
180  {
181  NEKERROR(ErrorUtil::efatal, "m_bndEvaluateTime not setup");
182  }
183  m_diffusion->Diffuse(nvariables, m_fields, inarray, outarrayDiff,
184  m_bndEvaluateTime, pFwd, pBwd);
185  for (int i = 0; i < nvariables; ++i)
186  {
187  Vmath::Vadd(npoints, outarrayDiff[i], 1, outarray[i], 1,
188  outarray[i], 1);
189  }
190  }
191  else
192  {
193  // Get primitive variables [u,v,w,T]
194  Array<OneD, Array<OneD, NekDouble>> inarrayDiff(nvariables - 1);
195  Array<OneD, Array<OneD, NekDouble>> inFwd(nvariables - 1);
196  Array<OneD, Array<OneD, NekDouble>> inBwd(nvariables - 1);
197 
198  for (int i = 0; i < nvariables - 1; ++i)
199  {
200  inarrayDiff[i] = Array<OneD, NekDouble>{npoints};
201  inFwd[i] = Array<OneD, NekDouble>{nTracePts};
202  inBwd[i] = Array<OneD, NekDouble>{nTracePts};
203  }
204 
205  // Extract pressure
206  // (use inarrayDiff[0] as a temporary storage for the pressure)
207  m_varConv->GetPressure(inarray, inarrayDiff[0]);
208 
209  // Extract temperature
210  m_varConv->GetTemperature(inarray, inarrayDiff[nvariables - 2]);
211 
212  // Extract velocities
213  m_varConv->GetVelocityVector(inarray, inarrayDiff);
214 
215  // Repeat calculation for trace space
216  if (pFwd == NullNekDoubleArrayOfArray ||
217  pBwd == NullNekDoubleArrayOfArray)
218  {
219  inFwd = NullNekDoubleArrayOfArray;
220  inBwd = NullNekDoubleArrayOfArray;
221  }
222  else
223  {
224  m_varConv->GetPressure(pFwd, inFwd[0]);
225  m_varConv->GetPressure(pBwd, inBwd[0]);
226 
227  m_varConv->GetTemperature(pFwd, inFwd[nvariables - 2]);
228  m_varConv->GetTemperature(pBwd, inBwd[nvariables - 2]);
229 
230  m_varConv->GetVelocityVector(pFwd, inFwd);
231  m_varConv->GetVelocityVector(pBwd, inBwd);
232  }
233 
234  // Diffusion term in physical rhs form
235  m_diffusion->Diffuse(nvariables, m_fields, inarrayDiff, outarrayDiff,
236  inFwd, inBwd);
237 
238  for (int i = 0; i < nvariables; ++i)
239  {
240  Vmath::Vadd(npoints, outarrayDiff[i], 1, outarray[i], 1,
241  outarray[i], 1);
242  }
243  }
244 }
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:209
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:691
Nektar::SolverUtils::EquationSystem::GetTraceTotPoints
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
Definition: EquationSystem.h:695
Nektar::SolverUtils::EquationSystem::GetNpoints
SOLVER_UTILS_EXPORT int GetNpoints()
Definition: EquationSystem.h:730
Nektar::NullNekDoubleArrayOfArray
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray
Definition: SharedArray.hpp:884

References Nektar::ErrorUtil::efatal, GetDivCurlSquared(), Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), 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 829 of file NavierStokesCFE.cpp.

832 {
833  bool extraFields;
834  m_session->MatchSolverInfo("OutputExtraFields", "True", extraFields, true);
835  if (extraFields)
836  {
837  const int nPhys = m_fields[0]->GetNpoints();
838  const int nCoeffs = m_fields[0]->GetNcoeffs();
839  Array<OneD, Array<OneD, NekDouble>> cnsVar(m_fields.size());
840 
841  for (int i = 0; i < m_fields.size(); ++i)
842  {
843  cnsVar[i] = m_fields[i]->GetPhys();
844  }
845 
846  Array<OneD, Array<OneD, NekDouble>> velocity(m_spacedim);
847  Array<OneD, Array<OneD, NekDouble>> velFwd(m_spacedim);
848  for (int i = 0; i < m_spacedim; ++i)
849  {
850  velocity[i] = Array<OneD, NekDouble>(nPhys);
851  velFwd[i] = Array<OneD, NekDouble>(nCoeffs);
852  }
853 
854  Array<OneD, NekDouble> pressure(nPhys), temperature(nPhys);
855  Array<OneD, NekDouble> entropy(nPhys);
856  Array<OneD, NekDouble> soundspeed(nPhys), mach(nPhys);
857  Array<OneD, NekDouble> sensor(nPhys), SensorKappa(nPhys);
858 
859  m_varConv->GetVelocityVector(cnsVar, velocity);
860  m_varConv->GetPressure(cnsVar, pressure);
861  m_varConv->GetTemperature(cnsVar, temperature);
862  m_varConv->GetEntropy(cnsVar, entropy);
863  m_varConv->GetSoundSpeed(cnsVar, soundspeed);
864  m_varConv->GetMach(cnsVar, soundspeed, mach);
865 
866  int sensorOffset;
867  m_session->LoadParameter("SensorOffset", sensorOffset, 1);
868  m_varConv->GetSensor(m_fields[0], cnsVar, sensor, SensorKappa,
869  sensorOffset);
870 
871  Array<OneD, NekDouble> pFwd(nCoeffs), TFwd(nCoeffs);
872  Array<OneD, NekDouble> sFwd(nCoeffs);
873  Array<OneD, NekDouble> aFwd(nCoeffs), mFwd(nCoeffs);
874  Array<OneD, NekDouble> sensFwd(nCoeffs);
875 
876  string velNames[3] = {"u", "v", "w"};
877  for (int i = 0; i < m_spacedim; ++i)
878  {
879  m_fields[0]->FwdTransLocalElmt(velocity[i], velFwd[i]);
880  variables.push_back(velNames[i]);
881  fieldcoeffs.push_back(velFwd[i]);
882  }
883 
884  m_fields[0]->FwdTransLocalElmt(pressure, pFwd);
885  m_fields[0]->FwdTransLocalElmt(temperature, TFwd);
886  m_fields[0]->FwdTransLocalElmt(entropy, sFwd);
887  m_fields[0]->FwdTransLocalElmt(soundspeed, aFwd);
888  m_fields[0]->FwdTransLocalElmt(mach, mFwd);
889  m_fields[0]->FwdTransLocalElmt(sensor, sensFwd);
890 
891  variables.push_back("p");
892  variables.push_back("T");
893  variables.push_back("s");
894  variables.push_back("a");
895  variables.push_back("Mach");
896  variables.push_back("Sensor");
897  fieldcoeffs.push_back(pFwd);
898  fieldcoeffs.push_back(TFwd);
899  fieldcoeffs.push_back(sFwd);
900  fieldcoeffs.push_back(aFwd);
901  fieldcoeffs.push_back(mFwd);
902  fieldcoeffs.push_back(sensFwd);
903 
904  if (m_artificialDiffusion)
905  {
906  // reuse pressure
907  Array<OneD, NekDouble> sensorFwd(nCoeffs);
908  m_artificialDiffusion->GetArtificialViscosity(cnsVar, pressure);
909  m_fields[0]->FwdTransLocalElmt(pressure, sensorFwd);
910 
911  variables.push_back("ArtificialVisc");
912  fieldcoeffs.push_back(sensorFwd);
913  }
914 
915  if (m_is_shockCaptPhys)
916  {
917 
918  Array<OneD, Array<OneD, NekDouble>> cnsVarFwd(m_fields.size()),
919  cnsVarBwd(m_fields.size());
920 
921  for (int i = 0; i < m_fields.size(); ++i)
922  {
923  cnsVarFwd[i] = Array<OneD, NekDouble>(GetTraceTotPoints());
924  cnsVarBwd[i] = Array<OneD, NekDouble>(GetTraceTotPoints());
925  m_fields[i]->GetFwdBwdTracePhys(cnsVar[i], cnsVarFwd[i],
926  cnsVarBwd[i]);
927  }
928 
929  Array<OneD, NekDouble> div(nPhys), curlSquare(nPhys);
930  GetDivCurlSquared(m_fields, cnsVar, div, curlSquare, cnsVarFwd,
931  cnsVarBwd);
932 
933  Array<OneD, NekDouble> divFwd(nCoeffs, 0.0);
934  m_fields[0]->FwdTransLocalElmt(div, divFwd);
935  variables.push_back("div");
936  fieldcoeffs.push_back(divFwd);
937 
938  Array<OneD, NekDouble> curlFwd(nCoeffs, 0.0);
939  m_fields[0]->FwdTransLocalElmt(curlSquare, curlFwd);
940  variables.push_back("curl^2");
941  fieldcoeffs.push_back(curlFwd);
942 
943  m_varConv->SetAv(m_fields, cnsVar, div, curlSquare);
944 
945  Array<OneD, NekDouble> muavFwd(nCoeffs);
946  m_fields[0]->FwdTransLocalElmt(m_varConv->GetAv(), muavFwd);
947  variables.push_back("ArtificialVisc");
948  fieldcoeffs.push_back(muavFwd);
949  }
950  }
951 }
Nektar::CompressibleFlowSystem::m_artificialDiffusion
ArtificialDiffusionSharedPtr m_artificialDiffusion
Definition: CompressibleFlowSystem.h:95
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:368
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 604 of file NavierStokesCFE.cpp.

608 {
609  unsigned int nTracePts = uFwd[0].size();
610 
611  // Compute average temperature
612  unsigned int nVariables = uFwd.size();
613  Array<OneD, NekDouble> tAve{nTracePts, 0.0};
614  Vmath::Svtsvtp(nTracePts, 0.5, uFwd[nVariables - 1], 1, 0.5,
615  uBwd[nVariables - 1], 1, tAve, 1);
616 
617  // Get average viscosity and thermal conductivity
618  Array<OneD, NekDouble> muAve{nTracePts, 0.0};
619  Array<OneD, NekDouble> tcAve{nTracePts, 0.0};
620 
621  GetViscosityAndThermalCondFromTemp(tAve, muAve, tcAve);
622 
623  // Compute penalty term
624  for (int i = 0; i < nVariables; ++i)
625  {
626  // Get jump of u variables
627  Vmath::Vsub(nTracePts, uFwd[i], 1, uBwd[i], 1, penaltyCoeff[i], 1);
628  // Multiply by variable coefficient = {coeff} ( u^+ - u^- )
629  if (i < nVariables - 1)
630  {
631  Vmath::Vmul(nTracePts, muAve, 1, penaltyCoeff[i], 1,
632  penaltyCoeff[i], 1);
633  }
634  else
635  {
636  Vmath::Vmul(nTracePts, tcAve, 1, penaltyCoeff[i], 1,
637  penaltyCoeff[i], 1);
638  }
639  }
640 }
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)
vvtvvtp (scalar times vector plus scalar times vector):
Definition: Vmath.cpp:751
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:209
Vmath::Vsub
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:419

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

254 {
255  // Auxiliary variables
256  size_t nScalar = physfield.size();
257  size_t nPts = physfield[0].size();
258  Array<OneD, NekDouble> divVel(nPts, 0.0);
259 
260  // Stokes hypothesis
261  const NekDouble lambda = -2.0 / 3.0;
262 
263  // Update viscosity and thermal conductivity
264  Array<OneD, NekDouble> mu(nPts, 0.0);
265  Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
266  GetViscosityAndThermalCondFromTemp(physfield[nScalar - 1], mu,
267  thermalConductivity);
268 
269  // Velocity divergence
270  for (int j = 0; j < m_spacedim; ++j)
271  {
272  Vmath::Vadd(nPts, divVel, 1, derivativesO1[j][j], 1, divVel, 1);
273  }
274 
275  // Velocity divergence scaled by lambda * mu
276  Vmath::Smul(nPts, lambda, divVel, 1, divVel, 1);
277  Vmath::Vmul(nPts, mu, 1, divVel, 1, divVel, 1);
278 
279  // Viscous flux vector for the rho equation = 0
280  for (int i = 0; i < m_spacedim; ++i)
281  {
282  Vmath::Zero(nPts, viscousTensor[i][0], 1);
283  }
284 
285  // Viscous stress tensor (for the momentum equations)
286  for (int i = 0; i < m_spacedim; ++i)
287  {
288  for (int j = i; j < m_spacedim; ++j)
289  {
290  Vmath::Vadd(nPts, derivativesO1[i][j], 1, derivativesO1[j][i], 1,
291  viscousTensor[i][j + 1], 1);
292 
293  Vmath::Vmul(nPts, mu, 1, viscousTensor[i][j + 1], 1,
294  viscousTensor[i][j + 1], 1);
295 
296  if (i == j)
297  {
298  // Add divergence term to diagonal
299  Vmath::Vadd(nPts, viscousTensor[i][j + 1], 1, divVel, 1,
300  viscousTensor[i][j + 1], 1);
301  }
302  else
303  {
304  // Copy to make symmetric
305  Vmath::Vcopy(nPts, viscousTensor[i][j + 1], 1,
306  viscousTensor[j][i + 1], 1);
307  }
308  }
309  }
310 
311  // Terms for the energy equation
312  for (int i = 0; i < m_spacedim; ++i)
313  {
314  Vmath::Zero(nPts, viscousTensor[i][m_spacedim + 1], 1);
315  // u_j * tau_ij
316  for (int j = 0; j < m_spacedim; ++j)
317  {
318  Vmath::Vvtvp(nPts, physfield[j], 1, viscousTensor[i][j + 1], 1,
319  viscousTensor[i][m_spacedim + 1], 1,
320  viscousTensor[i][m_spacedim + 1], 1);
321  }
322  // Add k*T_i
323  Vmath::Vvtvp(nPts, thermalConductivity, 1, derivativesO1[i][m_spacedim],
324  1, viscousTensor[i][m_spacedim + 1], 1,
325  viscousTensor[i][m_spacedim + 1], 1);
326  }
327 }

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

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

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::NavierStokesImplicitCFE, and Nektar::NavierStokesCFEAxisym.

Definition at line 60 of file NavierStokesCFE.cpp.

61 {
62  CompressibleFlowSystem::v_InitObject(DeclareFields);
63 
64  // rest of initialisation is in this routine so it can also be called
65  // in NavierStokesImplicitCFE initialisation
66  InitObject_Explicit();
67 }
Nektar::CompressibleFlowSystem::v_InitObject
virtual void v_InitObject(bool DeclareFields=true)
Initialization object for CompressibleFlowSystem class.
Definition: CompressibleFlowSystem.cpp:55

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

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

Friends And Related Function Documentation

◆ MemoryManager< NavierStokesCFE >

friend class MemoryManager< NavierStokesCFE >
friend

Definition at line 1 of file NavierStokesCFE.h.

Member Data Documentation

◆ className

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: NekFactory.hpp:198
Nektar::NavierStokesCFE::create
static SolverUtils::EquationSystemSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Definition: NavierStokesCFE.h:55
Nektar::SolverUtils::GetEquationSystemFactory
EquationSystemFactory & GetEquationSystemFactory()
Definition: EquationSystem.cpp:85

Definition at line 65 of file NavierStokesCFE.h.

◆ m_C0ProjectExp

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

Definition at line 87 of file NavierStokesCFE.h.

◆ m_Cp

NekDouble Nektar::NavierStokesCFE::m_Cp
protected

Definition at line 81 of file NavierStokesCFE.h.

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

◆ m_Cv

NekDouble Nektar::NavierStokesCFE::m_Cv
protected

Definition at line 82 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 90 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 76 of file NavierStokesCFE.h.

Referenced by InitObject_Explicit(), 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 73 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 79 of file NavierStokesCFE.h.

Referenced by GetViscosityAndThermalCondFromTemp(), InitObject_Explicit(), v_DoDiffusion(), and v_ExtraFldOutput().

◆ m_muRef

NekDouble Nektar::NavierStokesCFE::m_muRef
protected

Definition at line 93 of file NavierStokesCFE.h.

Referenced by GetViscosityFromTempKernel(), and InitObject_Explicit().

◆ m_physicalSensorType

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

Definition at line 85 of file NavierStokesCFE.h.

◆ m_Prandtl

NekDouble Nektar::NavierStokesCFE::m_Prandtl
protected

Definition at line 83 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 86 of file NavierStokesCFE.h.

◆ m_thermalConductivityRef

NekDouble Nektar::NavierStokesCFE::m_thermalConductivityRef
protected

Definition at line 94 of file NavierStokesCFE.h.

Referenced by InitObject_Explicit().

◆ m_Twall

NekDouble Nektar::NavierStokesCFE::m_Twall
protected

Definition at line 92 of file NavierStokesCFE.h.

Referenced by InitObject_Explicit(), and SpecialBndTreat().

◆ m_ViscosityType

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

Definition at line 70 of file NavierStokesCFE.h.

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

Generated on Tue Aug 23 2022 07:27:17 for Nektar++ by doxygen 1.9.1