#include <NavierStokesCFE.h>
Inheritance diagram for Nektar::NavierStokesCFE:
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 > |
Detailed Description
Definition at line 50 of file NavierStokesCFE.h.
Constructor & Destructor Documentation
◆ NavierStokesCFE()
|
protected |
Definition at line 45 of file NavierStokesCFE.cpp.
49{
50}
CompressibleFlowSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Definition: CompressibleFlowSystem.cpp:43
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
Definition: UnsteadySystem.cpp:74
◆ ~NavierStokesCFE()
|
overrideprotecteddefault |
Member Function Documentation
◆ C0Smooth()
◆ CalcViscosity()
|
protected |
◆ create()
|
inlinestatic |
Definition at line 56 of file NavierStokesCFE.h.
59 {
61 MemoryManager<NavierStokesCFE>::AllocateSharedPtr(pSession, pGraph);
62 p->InitObject();
64 }
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:166
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()
◆ GetArtificialViscosity()
|
protected |
◆ GetDivCurlFromDvelT()
|
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
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 {
806 {
807 // curl[0] 3/2 - 2/3
810 NekDouble curl0 = curl032 - curl023;
811 // square curl[0]
812 NekDouble curl0sqr = curl0 * curl0;
813
814 // curl[1] 3/1 - 1/3
817 NekDouble curl1 = curl131 - curl113;
818 // square curl[1]
819 NekDouble curl1sqr = curl1 * curl1;
820
821 // curl[2] 1/2 - 2/1
824 NekDouble curl2 = curl212 - curl221;
825 // square curl[2]
826 NekDouble curl2sqr = curl2 * curl2;
827
828 // reduce
829 curl0sqr += curl1sqr + curl2sqr;
830 // store
832 }
833 }
834 else if (nDim > 1)
835 {
837 {
838 // curl[2] 1/2
840 // curl[2] 2/1
842 // curl[2] 1/2 - 2/1
843 NekDouble curl = c212 - c221;
844 // square curl[2]
846 }
847 }
848 else
849 {
850 Vmath::Fill(nPts, 0.0, curlSquare, 1);
851 }
852}
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()
|
protected |
Get divergence and curl squared.
- Parameters
-
input fields -> 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
733 {
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
747 {
748 // Volume
750 {
752 }
753 // Trace
755 {
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}
Definition: BasicUtils/SharedArray.hpp:57
SolverUtils::DiffusionSharedPtr m_diffusion
Definition: CompressibleFlowSystem.h:71
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()
|
protected |
◆ GetViscosityAndThermalCondFromTemp()
|
protected |
Update viscosity todo: add artificial viscosity here.
Definition at line 671 of file NavierStokesCFE.cpp.
674{
675 size_t nPts = temperature.size();
676
678 {
680 thermalCond[p]);
681 }
682
683 // Add artificial viscosity if wanted
684 // move this above and add in kernel
686 {
688 if (nPts != nTracePts)
689 {
691 }
692 else
693 {
695 }
696
697 // Update thermal conductivity
699 Vmath::Smul(nPts, tRa, mu, 1, thermalCond, 1);
700 }
701}
VariableConverterSharedPtr m_varConv
Definition: CompressibleFlowSystem.h:93
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:467
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.hpp:180
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.hpp:100
References 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>
|
inlineprotected |
Definition at line 176 of file NavierStokesCFE.h.
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>
|
inlineprotected |
Definition at line 187 of file NavierStokesCFE.h.
188 {
189 // Variable viscosity through the Sutherland's law
191 {
192 mu = m_varConv->GetDynamicViscosity(temperature);
193 }
194 else
195 {
196 mu = m_muRef;
197 }
198 }
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>
|
inlineprotected |
Calculate diffusion flux using the Jacobian form.
- Parameters
-
in out outarray[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
223 NekDouble one_minus_gammaoPr = 1.0 - gammaoPr;
224
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{};
241 {
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;
266 {
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
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{};
300 {
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>
|
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
375 size_t sizeVec = (nPts / vec_t::width) * vec_t::width;
377
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 {
391 // zero output vector
392 if (IS_TRACE)
393 {
394 outArrTmp[f] = 0.0;
395 }
396 else
397 {
399 {
400 outArrTmp[f + nConvectiveFields * d] = 0.0;
401 }
402 }
403 }
404 if (IS_TRACE)
405 {
407 {
409 }
410 }
411
412 // get viscosity
413 vec_t muV{};
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
426 {
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 {
454 }
455 }
456 else
457 {
459 {
460 for (size_t f = 0; f < nConvectiveFields; ++f)
461 {
462 outArrTmp[f + nConvectiveFields * d].store(
464 }
465 }
466 }
467 }
468
469 // scalar loop
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 {
487 {
488 outArrTmp[f + nConvectiveFields * d] = 0.0;
489 }
490 }
491 }
492
493 if (IS_TRACE)
494 {
496 {
498 }
499 }
500
501 // get viscosity
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
513 {
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 {
546 {
547 for (size_t f = 0; f < nConvectiveFields; ++f)
548 {
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 }
Definition: allocator.hpp:44
static constexpr struct tinysimd::is_not_aligned_t is_not_aligned
References Nektar::UnitTests::d(), GetViscosityAndThermalCondFromTemp(), GetViscousFluxBilinearFormKernel(), tinysimd::is_not_aligned, Nektar::CompressibleFlowSystem::m_varConv, and CellMLToNektar.cellml_metadata::p.
◆ GetViscousFluxVectorConservVar() [2/2]
|
protected |
◆ GetViscousSymmtrFluxConservVar()
|
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);
601 {
602 for (size_t nderiv = 0; nderiv < nDim; ++nderiv)
603 {
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
614 inAvgTmp.data(), inTmp.data(),
615 mu[p], outTmp.data());
616
617 for (size_t f = 0; f < nConvectiveFields; ++f)
618 {
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()
|
protected |
Definition at line 64 of file NavierStokesCFE.cpp.
65{
66 // Get gas constant from session file and compute Cp
67 NekDouble gasConstant;
71
73
74 // Viscosity
78 {
80 }
81
82 // Thermal conductivity or Prandtl
84 {
86 "Cannot define both Pr and thermalConductivity.");
87
91 }
92 else
93 {
96 }
97
99 {
101 }
102
103 std::string diffName;
105
106 m_diffusion =
108 if ("InteriorPenalty" == diffName)
109 {
112 }
113
114 if ("LDGNS" == diffName || "LDGNS3DHomogeneous1D" == diffName)
115 {
117 }
118
120 {
121 m_diffusion->SetFluxVectorNS(
123 }
124 else
125 {
127 this);
128 }
129
130 m_diffusion->SetDiffusionFluxCons(
131 &NavierStokesCFE::GetViscousFluxVectorConservVar<false>, this);
132
133 m_diffusion->SetDiffusionFluxConsTrace(
134 &NavierStokesCFE::GetViscousFluxVectorConservVar<true>, this);
135
137
138 m_diffusion->SetDiffusionSymmFluxCons(
140
141 // Concluding initialisation of diffusion operator
143 m_diffusion->SetGridVelocityTrace(
145}
std::string m_shockCaptureType
Definition: CompressibleFlowSystem.h:75
void SetBoundaryConditionsBwdWeight()
Set up a weight on physical boundaries for boundary condition applications.
Definition: CompressibleFlowSystem.cpp:427
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: BasicUtils/NekFactory.hpp:143
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
Definition: ALEHelper.h:90
bool m_specHP_dealiasing
Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
Definition: EquationSystem.h:524
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()
|
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;
504 for (size_t j = 0; j < nBndRegions; ++j)
505 {
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 {
518 ->GetBndCondExpansions()[j]
519 ->GetExp(e)
520 ->GetTotPoints();
521
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);
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}
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
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()
|
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();
155 size_t npointsOut =
157 : npointsIn; // If ALE then outarray is in coefficient space
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
169 {
171 {
172 Array<OneD, NekDouble> div(npointsIn), curlSquare(npointsIn);
174
175 // Set volume and trace artificial viscosity
177 }
178 else
179 {
181 }
182 }
183
185 {
187 {
189 }
190
191 // Diffusion term in physical rhs form
193 {
195 outarrayDiff, m_bndEvaluateTime, pFwd,
196 pBwd);
197 }
198 else
199 {
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
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
247 {
249 outarrayDiff, inFwd, inBwd);
250 }
251 else
252 {
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
266 {
267 m_artificialDiffusion->DoArtificialDiffusion(inarray, outarray);
268 }
269}
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:202
NekDouble m_bndEvaluateTime
Definition: CompressibleFlowSystem.h:98
ArtificialDiffusionSharedPtr m_artificialDiffusion
Definition: CompressibleFlowSystem.h:72
SOLVER_UTILS_EXPORT int GetNpoints()
Definition: EquationSystem.h:351
SOLVER_UTILS_EXPORT int GetNcoeffs()
Definition: EquationSystem.h:283
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
Definition: EquationSystem.h:316
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()
|
overrideprotectedvirtual |
Reimplemented from Nektar::CompressibleFlowSystem.
Definition at line 854 of file NavierStokesCFE.cpp.
857{
858 bool extraFields;
860 if (extraFields)
861 {
865
867 {
868 cnsVar[i] = m_fields[i]->GetPhys();
869 }
870
874 {
875 velocity[i] = Array<OneD, NekDouble>(nPhys);
876 velFwd[i] = Array<OneD, NekDouble>(nCoeffs);
877 }
878
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);
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;
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"};
903 {
904 m_fields[0]->FwdTransLocalElmt(velocity[i], velFwd[i]);
905 variables.push_back(velNames[i]);
906 fieldcoeffs.push_back(velFwd[i]);
907 }
908
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
930 {
931 // reuse pressure
932 Array<OneD, NekDouble> sensorFwd(nCoeffs);
935
936 variables.push_back("ArtificialVisc");
937 fieldcoeffs.push_back(sensorFwd);
938 }
939
941 {
942
944 cnsVarBwd(m_fields.size());
945
947 {
950 m_fields[i]->GetFwdBwdTracePhys(cnsVar[i], cnsVarFwd[i],
951 cnsVarBwd[i]);
952 }
953
954 Array<OneD, NekDouble> div(nPhys), curlSquare(nPhys);
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
969
970 Array<OneD, NekDouble> muavFwd(nCoeffs);
972 variables.push_back("ArtificialVisc");
973 fieldcoeffs.push_back(muavFwd);
974 }
975 }
976}
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()
|
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}
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
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.hpp:72
void 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()
|
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
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
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
306 {
307 Vmath::Zero(nPts, viscousTensor[i][0], 1);
308 }
309
310 // Viscous stress tensor (for the momentum equations)
312 {
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
338 {
340 // u_j * tau_ij
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
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()
|
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();
368 size_t nPts_orig = physfield[0].size();
369
370 // Auxiliary variables
371 Array<OneD, NekDouble> divVel(nPts, 0.0);
372
373 // Stokes hypothesis
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
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
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)
405 {
406 out_interp[i][j] = Array<OneD, NekDouble>(nPts);
407 }
408 }
409
410 // Velocity divergence
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)
422 {
423 Vmath::Zero(nPts_orig, viscousTensor[i][0], 1);
424 }
425
426 // Viscous stress tensor (for the momentum equations)
428 {
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
453 {
455 // u_j * tau_ij
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
464 1, out_interp[i][m_spacedim + 1], 1,
465 out_interp[i][m_spacedim + 1], 1);
466 }
467
468 // Project to original space
470 {
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()
|
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}
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()
|
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 |
Definition at line 1 of file NavierStokesCFE.h.
Member Data Documentation
◆ className
|
static |
Initial value:
=
"NavierStokesCFE", NavierStokesCFE::create,
"NavierStokes equations in conservative variables.")
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition: BasicUtils/NekFactory.hpp:197
EquationSystemFactory & GetEquationSystemFactory()
Definition: EquationSystem.cpp:99
Definition at line 66 of file NavierStokesCFE.h.
◆ m_C0ProjectExp
|
protected |
Definition at line 86 of file NavierStokesCFE.h.
◆ m_Cp
|
protected |
Definition at line 80 of file NavierStokesCFE.h.
Referenced by GetViscosityAndThermalCondFromTemp(), GetViscosityAndThermalCondFromTempKernel(), and InitObject_Explicit().
◆ 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
|
protected |
Equation of system for computing temperature.
Definition at line 89 of file NavierStokesCFE.h.
◆ m_is_diffIP
|
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
|
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
|
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
|
protected |
Definition at line 92 of file NavierStokesCFE.h.
Referenced by GetViscosityFromTempKernel(), and InitObject_Explicit().
◆ m_physicalSensorType
|
protected |
Definition at line 84 of file NavierStokesCFE.h.
◆ 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
|
protected |
Definition at line 85 of file NavierStokesCFE.h.
◆ m_thermalConductivityRef
|
protected |
Definition at line 93 of file NavierStokesCFE.h.
Referenced by InitObject_Explicit().
◆ m_Twall
|
protected |
Definition at line 91 of file NavierStokesCFE.h.
Referenced by InitObject_Explicit(), and SpecialBndTreat().
◆ m_ViscosityType
|
protected |
Definition at line 69 of file NavierStokesCFE.h.
Referenced by InitObject_Explicit(), and Nektar::NavierStokesImplicitCFE::v_CalcMuDmuDT().
