#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) | |
| 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<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 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) | |
| 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 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 void | v_TransCoeffToPhys () |
| Virtual function for transformation to physical space. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_TransPhysToCoeff () |
| Virtual function for transformation to coefficient space. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_GenerateSummary (SummaryList &l) |
| Virtual function for generating summary information. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) |
| virtual SOLVER_UTILS_EXPORT void | v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time) |
| virtual SOLVER_UTILS_EXPORT void | v_Output (void) |
| virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr | v_GetPressure (void) |
| virtual SOLVER_UTILS_EXPORT bool | v_NegatedOp (void) |
| Virtual function to identify if operator is negated in DoSolve. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables) |
| Protected Member Functions inherited from Nektar::SolverUtils::FluidInterface | |
| virtual SOLVER_UTILS_EXPORT void | v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)=0 |
| virtual SOLVER_UTILS_EXPORT bool | v_HasConstantDensity ()=0 |
| virtual SOLVER_UTILS_EXPORT void | v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density)=0 |
| virtual SOLVER_UTILS_EXPORT void | v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)=0 |
| virtual SOLVER_UTILS_EXPORT void | v_SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step) |
| virtual SOLVER_UTILS_EXPORT bool | v_GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step) |
| virtual SOLVER_UTILS_EXPORT void | v_SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step) |
| virtual SOLVER_UTILS_EXPORT void | v_SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot) |
| virtual SOLVER_UTILS_EXPORT bool | v_GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step) |
| virtual SOLVER_UTILS_EXPORT void | v_SetAeroForce (Array< OneD, NekDouble > forces) |
| virtual SOLVER_UTILS_EXPORT void | v_GetAeroForce (Array< OneD, NekDouble > forces) |
Protected Attributes | |
| std::string | m_ViscosityType |
| bool | m_is_mu_variable {false} |
| flag to switch between constant viscosity and Sutherland an enum could be added for more options More... | |
| bool | m_is_diffIP {false} |
| flag to switch between IP and LDG an enum could be added for more options More... | |
| bool | m_is_shockCaptPhys {false} |
| flag for shock capturing switch on/off an enum could be added for more options More... | |
| NekDouble | m_Cp |
| NekDouble | m_Cv |
| NekDouble | m_Prandtl |
| std::string | m_physicalSensorType |
| std::string | m_smoothing |
| MultiRegions::ContFieldSharedPtr | m_C0ProjectExp |
| EquationOfStateSharedPtr | m_eos |
| Equation of system for computing temperature. More... | |
| NekDouble | m_Twall |
| NekDouble | m_muRef |
| NekDouble | m_thermalConductivityRef |
| Protected Attributes inherited from Nektar::CompressibleFlowSystem | |
| SolverUtils::DiffusionSharedPtr | m_diffusion |
| ArtificialDiffusionSharedPtr | m_artificialDiffusion |
| Array< OneD, Array< OneD, NekDouble > > | m_vecLocs |
| NekDouble | m_gamma |
| std::string | m_shockCaptureType |
| NekDouble | m_filterAlpha |
| NekDouble | m_filterExponent |
| NekDouble | m_filterCutoff |
| bool | m_useFiltering |
| bool | m_useLocalTimeStep |
| Array< OneD, NekDouble > | m_muav |
| Array< OneD, NekDouble > | m_muavTrace |
| VariableConverterSharedPtr | m_varConv |
| std::vector< CFSBndCondSharedPtr > | m_bndConds |
| NekDouble | m_bndEvaluateTime |
| std::vector< SolverUtils::ForcingSharedPtr > | m_forcing |
| Protected Attributes inherited from Nektar::SolverUtils::AdvectionSystem | |
| SolverUtils::AdvectionSharedPtr | m_advObject |
| Advection term. More... | |
| Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem | |
| LibUtilities::TimeIntegrationSchemeSharedPtr | m_intScheme |
| Wrapper to the time integration scheme. More... | |
| LibUtilities::TimeIntegrationSchemeOperators | m_ode |
| The time integration scheme operators to use. More... | |
| Array< OneD, Array< OneD, NekDouble > > | m_previousSolution |
| Storage for previous solution for steady-state check. More... | |
| std::vector< int > | m_intVariables |
| NekDouble | m_cflSafetyFactor |
| CFL safety factor (comprise between 0 to 1). More... | |
| NekDouble | m_CFLGrowth |
| CFL growth rate. More... | |
| NekDouble | m_CFLEnd |
| Maximun cfl in cfl growth. More... | |
| int | m_abortSteps |
| Number of steps between checks for abort conditions. More... | |
| bool | m_explicitDiffusion |
| Indicates if explicit or implicit treatment of diffusion is used. More... | |
| bool | m_explicitAdvection |
| Indicates if explicit or implicit treatment of advection is used. More... | |
| bool | m_explicitReaction |
| Indicates if explicit or implicit treatment of reaction is used. More... | |
| int | m_steadyStateSteps |
| Check for steady state at step interval. More... | |
| NekDouble | m_steadyStateTol |
| Tolerance to which steady state should be evaluated at. More... | |
| int | m_filtersInfosteps |
| Number of time steps between outputting filters information. More... | |
| std::vector< std::pair< std::string, FilterSharedPtr > > | m_filters |
| bool | m_homoInitialFwd |
| Flag to determine if simulation should start in homogeneous forward transformed state. More... | |
| std::ofstream | m_errFile |
| NekDouble | m_epsilon |
| Diffusion coefficient. More... | |
| Protected Attributes inherited from Nektar::SolverUtils::EquationSystem | |
| LibUtilities::CommSharedPtr | m_comm |
| Communicator. More... | |
| bool | m_verbose |
| LibUtilities::SessionReaderSharedPtr | m_session |
| The session reader. More... | |
| std::map< std::string, SolverUtils::SessionFunctionSharedPtr > | m_sessionFunctions |
| Map of known SessionFunctions. More... | |
| LibUtilities::FieldIOSharedPtr | m_fld |
| Field input/output. More... | |
| Array< OneD, MultiRegions::ExpListSharedPtr > | m_fields |
| Array holding all dependent variables. More... | |
| SpatialDomains::BoundaryConditionsSharedPtr | m_boundaryConditions |
| Pointer to boundary conditions object. More... | |
| SpatialDomains::MeshGraphSharedPtr | m_graph |
| Pointer to graph defining mesh. More... | |
| std::string | m_sessionName |
| Name of the session. More... | |
| NekDouble | m_time |
| Current time of simulation. More... | |
| int | m_initialStep |
| Number of the step where the simulation should begin. More... | |
| NekDouble | m_fintime |
| Finish time of the simulation. More... | |
| NekDouble | m_timestep |
| Time step size. More... | |
| NekDouble | m_lambda |
| Lambda constant in real system if one required. More... | |
| NekDouble | m_checktime |
| Time between checkpoints. More... | |
| NekDouble | m_lastCheckTime |
| NekDouble | m_TimeIncrementFactor |
| int | m_nchk |
| Number of checkpoints written so far. More... | |
| int | m_steps |
| Number of steps to take. More... | |
| int | m_checksteps |
| Number of steps between checkpoints. More... | |
| int | m_infosteps |
| Number of time steps between outputting status information. More... | |
| int | m_iterPIT = 0 |
| Number of parallel-in-time time iteration. More... | |
| int | m_windowPIT = 0 |
| Index of windows for parallel-in-time time iteration. More... | |
| int | m_spacedim |
| Spatial dimension (>= expansion dim). More... | |
| int | m_expdim |
| Expansion dimension. More... | |
| bool | m_singleMode |
| Flag to determine if single homogeneous mode is used. More... | |
| bool | m_halfMode |
| Flag to determine if half homogeneous mode is used. More... | |
| bool | m_multipleModes |
| Flag to determine if use multiple homogenenous modes are used. More... | |
| bool | m_useFFT |
| Flag to determine if FFT is used for homogeneous transform. More... | |
| bool | m_homogen_dealiasing |
| Flag to determine if dealiasing is used for homogeneous simulations. More... | |
| bool | m_specHP_dealiasing |
| Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More... | |
| enum MultiRegions::ProjectionType | m_projectionType |
| Type of projection; e.g continuous or discontinuous. More... | |
| Array< OneD, Array< OneD, NekDouble > > | m_traceNormals |
| Array holding trace normals for DG simulations in the forwards direction. More... | |
| Array< OneD, bool > | m_checkIfSystemSingular |
| Flag to indicate if the fields should be checked for singularity. More... | |
| LibUtilities::FieldMetaDataMap | m_fieldMetaDataMap |
| Map to identify relevant solver info to dump in output fields. More... | |
| Array< OneD, NekDouble > | m_movingFrameData |
| Moving reference frame status in the inertial frame X, Y, Z, Theta_x, Theta_y, Theta_z, U, V, W, Omega_x, Omega_y, Omega_z, A_x, A_y, A_z, DOmega_x, DOmega_y, DOmega_z, pivot_x, pivot_y, pivot_z. More... | |
| std::vector< std::string > | m_strFrameData |
| variable name in m_movingFrameData More... | |
| int | m_NumQuadPointsError |
| Number of Quadrature points used to work out the error. More... | |
| enum HomogeneousType | m_HomogeneousType |
| NekDouble | m_LhomX |
| physical length in X direction (if homogeneous) More... | |
| NekDouble | m_LhomY |
| physical length in Y direction (if homogeneous) More... | |
| NekDouble | m_LhomZ |
| physical length in Z direction (if homogeneous) More... | |
| int | m_npointsX |
| number of points in X direction (if homogeneous) More... | |
| int | m_npointsY |
| number of points in Y direction (if homogeneous) More... | |
| int | m_npointsZ |
| number of points in Z direction (if homogeneous) More... | |
| int | m_HomoDirec |
| number of homogenous directions More... | |
| Protected Attributes inherited from Nektar::SolverUtils::ALEHelper | |
| Array< OneD, MultiRegions::ExpListSharedPtr > | m_fieldsALE |
| Array< OneD, Array< OneD, NekDouble > > | m_gridVelocity |
| Array< OneD, Array< OneD, NekDouble > > | m_gridVelocityTrace |
| std::vector< ALEBaseShPtr > | m_ALEs |
| bool | m_ALESolver = false |
| bool | m_ImplicitALESolver = false |
| NekDouble | m_prevStageTime = 0.0 |
| int | m_spaceDim |
Friends | |
| class | MemoryManager< NavierStokesCFE > |
Additional Inherited Members | |
| Protected Types inherited from Nektar::SolverUtils::EquationSystem | |
| enum | HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous } |
| Parameter for homogeneous expansions. More... | |
| Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem | |
| static std::string | equationSystemTypeLookupIds [] |
| static std::string | projectionTypeLookupIds [] |
Detailed Description
Definition at line 49 of file NavierStokesCFE.h.
Constructor & Destructor Documentation
◆ ~NavierStokesCFE()
|
overridedefault |
◆ NavierStokesCFE()
|
protected |
Definition at line 46 of file NavierStokesCFE.cpp.
50{
51}
CompressibleFlowSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Definition: CompressibleFlowSystem.cpp:44
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
Definition: UnsteadySystem.cpp:74
Member Function Documentation
◆ C0Smooth()
◆ CalcViscosity()
|
protected |
◆ create()
|
inlinestatic |
Definition at line 55 of file NavierStokesCFE.h.
58 {
60 MemoryManager<NavierStokesCFE>::AllocateSharedPtr(pSession, pGraph);
61 p->InitObject();
63 }
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 792 of file NavierStokesCFE.cpp.
795{
796 size_t nDim = pVarDer.size();
797 size_t nPts = div.size();
798
799 // div velocity
801 {
802 NekDouble divTmp = 0;
803 for (unsigned short j = 0; j < nDim; ++j)
804 {
805 divTmp += pVarDer[j][j][p];
806 }
807 div[p] = divTmp;
808 }
809
810 // |curl velocity| ** 2
811 if (nDim > 2)
812 {
814 {
815 // curl[0] 3/2 - 2/3
818 NekDouble curl0 = curl032 - curl023;
819 // square curl[0]
820 NekDouble curl0sqr = curl0 * curl0;
821
822 // curl[1] 3/1 - 1/3
825 NekDouble curl1 = curl131 - curl113;
826 // square curl[1]
827 NekDouble curl1sqr = curl1 * curl1;
828
829 // curl[2] 1/2 - 2/1
832 NekDouble curl2 = curl212 - curl221;
833 // square curl[2]
834 NekDouble curl2sqr = curl2 * curl2;
835
836 // reduce
837 curl0sqr += curl1sqr + curl2sqr;
838 // store
840 }
841 }
842 else if (nDim > 1)
843 {
845 {
846 // curl[2] 1/2
848 // curl[2] 2/1
850 // curl[2] 1/2 - 2/1
851 NekDouble curl = c212 - c221;
852 // square curl[2]
854 }
855 }
856 else
857 {
858 Vmath::Fill(nPts, 0.0, curlSquare, 1);
859 }
860}
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 724 of file NavierStokesCFE.cpp.
730{
731 size_t nDim = fields[0]->GetCoordim(0);
732 size_t nVar = cnsVar.size();
733 size_t nPts = cnsVar[0].size();
734 size_t nPtsTrc = cnsVarFwd[0].size();
735
736 // These should be allocated once
737 Array<OneD, Array<OneD, NekDouble>> primVar(nVar - 1), primVarFwd(nVar - 1),
738 primVarBwd(nVar - 1);
739
741 {
745 }
746 size_t ergLoc = nVar - 2;
747 primVar[ergLoc] = Array<OneD, NekDouble>(nPts, 0.0);
748 primVarFwd[ergLoc] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
749 primVarBwd[ergLoc] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
750
751 // Get primitive variables [u,v,w,T=0]
752 // Possibly should be changed to [rho,u,v,w,T] to make IP and LDGNS more
753 // consistent with each other
755 {
756 // Volume
758 {
760 }
761 // Trace
763 {
766 }
767 }
768
769 // this should be allocated once
770 Array<OneD, Array<OneD, Array<OneD, NekDouble>>> primVarDer(nDim);
771 for (unsigned short j = 0; j < nDim; ++j)
772 {
773 primVarDer[j] = Array<OneD, Array<OneD, NekDouble>>(nVar - 1);
774 for (unsigned short i = 0; i < nVar - 1; ++i)
775 {
776 primVarDer[j][i] = Array<OneD, NekDouble>(nPts, 0.0);
777 }
778 }
779
780 // Get derivative tensor
781 m_diffusion->DiffuseCalcDerivative(fields, primVar, primVarDer, primVarFwd,
782 primVarBwd);
783
784 // Get div curl squared
785 GetDivCurlFromDvelT(primVarDer, div, curlSquare);
786}
Definition: BasicUtils/SharedArray.hpp:57
SolverUtils::DiffusionSharedPtr m_diffusion
Definition: CompressibleFlowSystem.h:73
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 679 of file NavierStokesCFE.cpp.
682{
683 size_t nPts = temperature.size();
684
686 {
688 thermalCond[p]);
689 }
690
691 // Add artificial viscosity if wanted
692 // move this above and add in kernel
694 {
696 if (nPts != nTracePts)
697 {
699 }
700 else
701 {
703 }
704
705 // Update thermal conductivity
707 Vmath::Smul(nPts, tRa, mu, 1, thermalCond, 1);
708 }
709}
VariableConverterSharedPtr m_varConv
Definition: CompressibleFlowSystem.h:95
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:359
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<T>::value || tinysimd::is_vector_floating_point<T>::value>::type>
|
inlineprotected |
Definition at line 175 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<T>::value || tinysimd::is_vector_floating_point<T>::value>::type>
|
inlineprotected |
Definition at line 186 of file NavierStokesCFE.h.
187 {
188 // Variable viscosity through the Sutherland's law
190 {
191 mu = m_varConv->GetDynamicViscosity(temperature);
192 }
193 else
194 {
195 mu = m_muRef;
196 }
197 }
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>
|
inlineprotected |
Calculate diffusion flux using the Jacobian form.
- Parameters
-
in out outarray[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
222 NekDouble one_minus_gammaoPr = 1.0 - gammaoPr;
223
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{};
240 {
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;
265 {
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
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{};
299 {
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::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 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
374 size_t sizeVec = (nPts / vec_t::width) * vec_t::width;
376
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 {
390 // zero output vector
391 if (IS_TRACE)
392 {
393 outArrTmp[f] = 0.0;
394 }
395 else
396 {
398 {
399 outArrTmp[f + nConvectiveFields * d] = 0.0;
400 }
401 }
402 }
403 if (IS_TRACE)
404 {
406 {
408 }
409 }
410
411 // get viscosity
412 vec_t muV{};
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
425 {
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 (size_t f = 0; f < nConvectiveFields; ++f)
451 {
453 }
454 }
455 else
456 {
458 {
459 for (size_t f = 0; f < nConvectiveFields; ++f)
460 {
461 outArrTmp[f + nConvectiveFields * d].store(
463 }
464 }
465 }
466 }
467
468 // scalar loop
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 (size_t 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 {
486 {
487 outArrTmp[f + nConvectiveFields * d] = 0.0;
488 }
489 }
490 }
491
492 if (IS_TRACE)
493 {
495 {
497 }
498 }
499
500 // get viscosity
502
503 for (size_t nderiv = 0; nderiv < nDim; ++nderiv)
504 {
505 // rearrenge and load data
506 for (size_t f = 0; f < nConvectiveFields; ++f)
507 {
508 qfieldsTmp[f] = qfields[nderiv][f][p];
509 }
510
512 {
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 (size_t f = 0; f < nConvectiveFields; ++f)
538 {
539 outarray[0][f][p] = outArrTmp[f];
540 }
541 }
542 else
543 {
545 {
546 for (size_t f = 0; f < nConvectiveFields; ++f)
547 {
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 }
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 585 of file NavierStokesCFE.cpp.
590{
591 size_t nConvectiveFields = inarray.size();
592 size_t nPts = inaverg[nConvectiveFields - 1].size();
593 nonZeroIndex = Array<OneD, int>{nConvectiveFields - 1, 0};
594 for (size_t i = 0; i < nConvectiveFields - 1; ++i)
595 {
596 nonZeroIndex[i] = i + 1;
597 }
598
599 Array<OneD, NekDouble> mu(nPts, 0.0);
600 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
601 Array<OneD, NekDouble> temperature(nPts, 0.0);
602 m_varConv->GetTemperature(inaverg, temperature);
603 GetViscosityAndThermalCondFromTemp(temperature, mu, thermalConductivity);
604
605 std::vector<NekDouble> inAvgTmp(nConvectiveFields);
606 std::vector<NekDouble> inTmp(nConvectiveFields);
607 std::vector<NekDouble> outTmp(nConvectiveFields);
609 {
610 for (size_t nderiv = 0; nderiv < nDim; ++nderiv)
611 {
613 {
614 // rearrenge data
615 for (size_t f = 0; f < nConvectiveFields; ++f)
616 {
617 inAvgTmp[f] = inaverg[f][p];
618 inTmp[f] = inarray[f][p];
619 }
620
622 inAvgTmp.data(), inTmp.data(),
623 mu[p], outTmp.data());
624
625 for (size_t f = 0; f < nConvectiveFields; ++f)
626 {
628 }
629 }
630 }
631 }
632}
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 65 of file NavierStokesCFE.cpp.
66{
67 // Get gas constant from session file and compute Cp
68 NekDouble gasConstant;
72
74
75 // Viscosity
79 {
81 }
82
83 // Thermal conductivity or Prandtl
85 {
87 "Cannot define both Pr and thermalConductivity.");
88
92 }
93 else
94 {
97 }
98
100 {
102 }
103
104 string diffName;
106
107 m_diffusion =
109 if ("InteriorPenalty" == diffName)
110 {
113 }
114
115 if ("LDGNS" == diffName || "LDGNS3DHomogeneous1D" == diffName)
116 {
118 }
119
121 {
122 m_diffusion->SetFluxVectorNS(
124 }
125 else
126 {
128 this);
129 }
130
131 m_diffusion->SetDiffusionFluxCons(
132 &NavierStokesCFE::GetViscousFluxVectorConservVar<false>, this);
133
134 m_diffusion->SetDiffusionFluxConsTrace(
135 &NavierStokesCFE::GetViscousFluxVectorConservVar<true>, this);
136
138
139 m_diffusion->SetDiffusionSymmFluxCons(
141
142 // Concluding initialisation of diffusion operator
144 m_diffusion->SetGridVelocityTrace(
146}
std::string m_shockCaptureType
Definition: CompressibleFlowSystem.h:77
void SetBoundaryConditionsBwdWeight()
Set up a weight on physical boundaries for boundary condition applications.
Definition: CompressibleFlowSystem.cpp:428
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:91
bool m_specHP_dealiasing
Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
Definition: EquationSystem.h:416
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 496 of file NavierStokesCFE.cpp.
498{
499 size_t nConvectiveFields = consvar.size();
500 size_t ndens = 0;
501 size_t nengy = nConvectiveFields - 1;
502
503 Array<OneD, Array<OneD, NekDouble>> bndCons{nConvectiveFields};
504 Array<OneD, NekDouble> bndTotEngy;
505 Array<OneD, NekDouble> bndPressure;
506 Array<OneD, NekDouble> bndRho;
507 Array<OneD, NekDouble> bndIntEndy;
508 size_t nLengthArray = 0;
509
510 size_t cnt = 0;
512 for (size_t j = 0; j < nBndRegions; ++j)
513 {
515 ->GetBndConditions()[j]
516 ->GetBoundaryConditionType() == SpatialDomains::ePeriodic)
517 {
518 continue;
519 }
520
521 size_t nBndEdges =
522 m_fields[nengy]->GetBndCondExpansions()[j]->GetExpSize();
523 for (size_t e = 0; e < nBndEdges; ++e)
524 {
526 ->GetBndCondExpansions()[j]
527 ->GetExp(e)
528 ->GetTotPoints();
529
531 m_fields[0]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt++));
532
533 // Imposing Temperature Twall at the wall
534 if (boost::iequals(
535 m_fields[nengy]->GetBndConditions()[j]->GetUserDefined(),
536 "WallViscous"))
537 {
538 if (nBndEdgePts != nLengthArray)
539 {
540 for (size_t i = 0; i < nConvectiveFields; ++i)
541 {
542 bndCons[i] = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
543 }
544 bndTotEngy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
545 bndPressure = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
546 bndRho = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
547 bndIntEndy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
548 nLengthArray = nBndEdgePts;
549 }
550 else
551 {
552 Vmath::Zero(nLengthArray, bndPressure, 1);
553 Vmath::Zero(nLengthArray, bndRho, 1);
554 Vmath::Zero(nLengthArray, bndIntEndy, 1);
555 }
556
557 Array<OneD, NekDouble> tmp;
558
559 for (size_t k = 0; k < nConvectiveFields; ++k)
560 {
561 Vmath::Vcopy(nBndEdgePts, tmp = consvar[k] + id2, 1,
562 bndCons[k], 1);
563 }
564
565 m_varConv->GetPressure(bndCons, bndPressure);
567 m_varConv->GetRhoFromPT(bndPressure, bndTotEngy, bndRho);
568 m_varConv->GetEFromRhoP(bndRho, bndPressure, bndIntEndy);
569 m_varConv->GetDynamicEnergy(bndCons, bndTotEngy);
570
571 Vmath::Vvtvp(nBndEdgePts, bndIntEndy, 1, bndCons[ndens], 1,
572 bndTotEngy, 1, bndTotEngy, 1);
573
574 Vmath::Vcopy(nBndEdgePts, bndTotEngy, 1,
575 tmp = consvar[nengy] + id2, 1);
576 }
577 }
578 }
579}
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 148 of file NavierStokesCFE.cpp.
153{
154 size_t nvariables = inarray.size();
156 size_t npointsOut =
158 : npointsIn; // If ALE then outarray is in coefficient space
160
161 // this should be preallocated
162 Array<OneD, Array<OneD, NekDouble>> outarrayDiff(nvariables);
163 for (size_t i = 0; i < nvariables; ++i)
164 {
165 outarrayDiff[i] = Array<OneD, NekDouble>(npointsOut, 0.0);
166 }
167
168 // Set artificial viscosity based on NS viscous tensor
170 {
172 {
173 Array<OneD, NekDouble> div(npointsIn), curlSquare(npointsIn);
175
176 // Set volume and trace artificial viscosity
178 }
179 else
180 {
182 }
183 }
184
186 {
188 {
190 }
191
192 // Diffusion term in physical rhs form
194 {
196 outarrayDiff, m_bndEvaluateTime, pFwd,
197 pBwd);
198 }
199 else
200 {
202 m_bndEvaluateTime, pFwd, pBwd);
203 }
204 for (size_t i = 0; i < nvariables; ++i)
205 {
206 Vmath::Vadd(npointsOut, outarrayDiff[i], 1, outarray[i], 1,
207 outarray[i], 1);
208 }
209 }
210 else
211 {
212 // Get primitive variables [u,v,w,T]
213 Array<OneD, Array<OneD, NekDouble>> inarrayDiff(nvariables - 1);
214 Array<OneD, Array<OneD, NekDouble>> inFwd(nvariables - 1);
215 Array<OneD, Array<OneD, NekDouble>> inBwd(nvariables - 1);
216
217 for (size_t i = 0; i < nvariables - 1; ++i)
218 {
219 inarrayDiff[i] = Array<OneD, NekDouble>{npointsIn};
220 inFwd[i] = Array<OneD, NekDouble>{nTracePts};
221 inBwd[i] = Array<OneD, NekDouble>{nTracePts};
222 }
223
224 // Extract pressure
225 // (use inarrayDiff[0] as a temporary storage for the pressure)
226 m_varConv->GetPressure(inarray, inarrayDiff[0]);
227
228 // Extract temperature
229 m_varConv->GetTemperature(inarray, inarrayDiff[nvariables - 2]);
230
231 // Extract velocities
232 m_varConv->GetVelocityVector(inarray, inarrayDiff);
233
234 // Repeat calculation for trace space
236 pBwd == NullNekDoubleArrayOfArray)
237 {
238 inFwd = NullNekDoubleArrayOfArray;
239 inBwd = NullNekDoubleArrayOfArray;
240 }
241 else
242 {
243 m_varConv->GetPressure(pFwd, inFwd[0]);
244 m_varConv->GetPressure(pBwd, inBwd[0]);
245
246 m_varConv->GetTemperature(pFwd, inFwd[nvariables - 2]);
247 m_varConv->GetTemperature(pBwd, inBwd[nvariables - 2]);
248
249 m_varConv->GetVelocityVector(pFwd, inFwd);
250 m_varConv->GetVelocityVector(pBwd, inBwd);
251 }
252
253 // Diffusion term in physical rhs form
255 {
257 outarrayDiff, inFwd, inBwd);
258 }
259 else
260 {
262 outarrayDiff, inFwd, inBwd);
263 }
264
265 for (size_t i = 0; i < nvariables; ++i)
266 {
267 Vmath::Vadd(npointsOut, outarrayDiff[i], 1, outarray[i], 1,
268 outarray[i], 1);
269 }
270 }
271
272 // Add artificial diffusion through Laplacian operator
274 {
275 m_artificialDiffusion->DoArtificialDiffusion(inarray, outarray);
276 }
277}
#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:100
ArtificialDiffusionSharedPtr m_artificialDiffusion
Definition: CompressibleFlowSystem.h:74
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
Definition: EquationSystem.h:734
SOLVER_UTILS_EXPORT int GetNpoints()
Definition: EquationSystem.h:769
SOLVER_UTILS_EXPORT int GetNcoeffs()
Definition: EquationSystem.h:701
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray
Definition: BasicUtils/SharedArray.hpp:928
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 862 of file NavierStokesCFE.cpp.
865{
866 bool extraFields;
868 if (extraFields)
869 {
873
875 {
876 cnsVar[i] = m_fields[i]->GetPhys();
877 }
878
882 {
883 velocity[i] = Array<OneD, NekDouble>(nPhys);
884 velFwd[i] = Array<OneD, NekDouble>(nCoeffs);
885 }
886
888 Array<OneD, NekDouble> entropy(nPhys);
889 Array<OneD, NekDouble> soundspeed(nPhys), mach(nPhys);
890 Array<OneD, NekDouble> sensor(nPhys), SensorKappa(nPhys);
891
892 m_varConv->GetVelocityVector(cnsVar, velocity);
894 m_varConv->GetTemperature(cnsVar, temperature);
895 m_varConv->GetEntropy(cnsVar, entropy);
896 m_varConv->GetSoundSpeed(cnsVar, soundspeed);
897 m_varConv->GetMach(cnsVar, soundspeed, mach);
898
899 int sensorOffset;
902 sensorOffset);
903
904 Array<OneD, NekDouble> pFwd(nCoeffs), TFwd(nCoeffs);
905 Array<OneD, NekDouble> sFwd(nCoeffs);
906 Array<OneD, NekDouble> aFwd(nCoeffs), mFwd(nCoeffs);
907 Array<OneD, NekDouble> sensFwd(nCoeffs);
908
909 string velNames[3] = {"u", "v", "w"};
911 {
912 m_fields[0]->FwdTransLocalElmt(velocity[i], velFwd[i]);
913 variables.push_back(velNames[i]);
914 fieldcoeffs.push_back(velFwd[i]);
915 }
916
918 m_fields[0]->FwdTransLocalElmt(temperature, TFwd);
919 m_fields[0]->FwdTransLocalElmt(entropy, sFwd);
920 m_fields[0]->FwdTransLocalElmt(soundspeed, aFwd);
921 m_fields[0]->FwdTransLocalElmt(mach, mFwd);
922 m_fields[0]->FwdTransLocalElmt(sensor, sensFwd);
923
924 variables.push_back("p");
925 variables.push_back("T");
926 variables.push_back("s");
927 variables.push_back("a");
928 variables.push_back("Mach");
929 variables.push_back("Sensor");
930 fieldcoeffs.push_back(pFwd);
931 fieldcoeffs.push_back(TFwd);
932 fieldcoeffs.push_back(sFwd);
933 fieldcoeffs.push_back(aFwd);
934 fieldcoeffs.push_back(mFwd);
935 fieldcoeffs.push_back(sensFwd);
936
938 {
939 // reuse pressure
940 Array<OneD, NekDouble> sensorFwd(nCoeffs);
943
944 variables.push_back("ArtificialVisc");
945 fieldcoeffs.push_back(sensorFwd);
946 }
947
949 {
950
952 cnsVarBwd(m_fields.size());
953
955 {
958 m_fields[i]->GetFwdBwdTracePhys(cnsVar[i], cnsVarFwd[i],
959 cnsVarBwd[i]);
960 }
961
962 Array<OneD, NekDouble> div(nPhys), curlSquare(nPhys);
964 cnsVarBwd);
965
966 Array<OneD, NekDouble> divFwd(nCoeffs, 0.0);
967 m_fields[0]->FwdTransLocalElmt(div, divFwd);
968 variables.push_back("div");
969 fieldcoeffs.push_back(divFwd);
970
971 Array<OneD, NekDouble> curlFwd(nCoeffs, 0.0);
972 m_fields[0]->FwdTransLocalElmt(curlSquare, curlFwd);
973 variables.push_back("curl^2");
974 fieldcoeffs.push_back(curlFwd);
975
977
978 Array<OneD, NekDouble> muavFwd(nCoeffs);
980 variables.push_back("ArtificialVisc");
981 fieldcoeffs.push_back(muavFwd);
982 }
983 }
984}
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 637 of file NavierStokesCFE.cpp.
641{
642 size_t nTracePts = uFwd[0].size();
643
644 // Compute average temperature
645 size_t nVariables = uFwd.size();
646 Array<OneD, NekDouble> tAve{nTracePts, 0.0};
647 Vmath::Svtsvtp(nTracePts, 0.5, uFwd[nVariables - 1], 1, 0.5,
648 uBwd[nVariables - 1], 1, tAve, 1);
649
650 // Get average viscosity and thermal conductivity
651 Array<OneD, NekDouble> muAve{nTracePts, 0.0};
652 Array<OneD, NekDouble> tcAve{nTracePts, 0.0};
653
654 GetViscosityAndThermalCondFromTemp(tAve, muAve, tcAve);
655
656 // Compute penalty term
657 for (size_t i = 0; i < nVariables; ++i)
658 {
659 // Get jump of u variables
660 Vmath::Vsub(nTracePts, uFwd[i], 1, uBwd[i], 1, penaltyCoeff[i], 1);
661 // Multiply by variable coefficient = {coeff} ( u^+ - u^- )
662 if (i < nVariables - 1)
663 {
664 Vmath::Vmul(nTracePts, muAve, 1, penaltyCoeff[i], 1,
665 penaltyCoeff[i], 1);
666 }
667 else
668 {
669 Vmath::Vmul(nTracePts, tcAve, 1, penaltyCoeff[i], 1,
670 penaltyCoeff[i], 1);
671 }
672 }
673}
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 283 of file NavierStokesCFE.cpp.
287{
288 // Auxiliary variables
289 size_t nScalar = physfield.size();
290 size_t nPts = physfield[0].size();
291 Array<OneD, NekDouble> divVel(nPts, 0.0);
292
293 // Stokes hypothesis
295
296 // Update viscosity and thermal conductivity
297 Array<OneD, NekDouble> mu(nPts, 0.0);
298 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
299 GetViscosityAndThermalCondFromTemp(physfield[nScalar - 1], mu,
300 thermalConductivity);
301
302 // Velocity divergence
304 {
305 Vmath::Vadd(nPts, divVel, 1, derivativesO1[j][j], 1, divVel, 1);
306 }
307
308 // Velocity divergence scaled by lambda * mu
309 Vmath::Smul(nPts, lambda, divVel, 1, divVel, 1);
310 Vmath::Vmul(nPts, mu, 1, divVel, 1, divVel, 1);
311
312 // Viscous flux vector for the rho equation = 0
314 {
315 Vmath::Zero(nPts, viscousTensor[i][0], 1);
316 }
317
318 // Viscous stress tensor (for the momentum equations)
320 {
322 {
323 Vmath::Vadd(nPts, derivativesO1[i][j], 1, derivativesO1[j][i], 1,
324 viscousTensor[i][j + 1], 1);
325
326 Vmath::Vmul(nPts, mu, 1, viscousTensor[i][j + 1], 1,
327 viscousTensor[i][j + 1], 1);
328
329 if (i == j)
330 {
331 // Add divergence term to diagonal
332 Vmath::Vadd(nPts, viscousTensor[i][j + 1], 1, divVel, 1,
333 viscousTensor[i][j + 1], 1);
334 }
335 else
336 {
337 // Copy to make symmetric
338 Vmath::Vcopy(nPts, viscousTensor[i][j + 1], 1,
339 viscousTensor[j][i + 1], 1);
340 }
341 }
342 }
343
344 // Terms for the energy equation
346 {
348 // u_j * tau_ij
350 {
351 Vmath::Vvtvp(nPts, physfield[j], 1, viscousTensor[i][j + 1], 1,
352 viscousTensor[i][m_spacedim + 1], 1,
353 viscousTensor[i][m_spacedim + 1], 1);
354 }
355 // Add k*T_i
357 1, viscousTensor[i][m_spacedim + 1], 1,
358 viscousTensor[i][m_spacedim + 1], 1);
359 }
360}
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 366 of file NavierStokesCFE.cpp.
370{
371 // Factor to rescale 1d points in dealiasing.
372 NekDouble OneDptscale = 2;
373 // Get number of points to dealias a cubic non-linearity
374 size_t nScalar = physfield.size();
376 size_t nPts_orig = physfield[0].size();
377
378 // Auxiliary variables
379 Array<OneD, NekDouble> divVel(nPts, 0.0);
380
381 // Stokes hypothesis
383
384 // Update viscosity and thermal conductivity
385 Array<OneD, NekDouble> mu(nPts, 0.0);
386 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
387 GetViscosityAndThermalCondFromTemp(physfield[nScalar - 1], mu,
388 thermalConductivity);
389
390 // Interpolate inputs and initialise interpolated output
395 {
396 // Interpolate velocity
397 vel_interp[i] = Array<OneD, NekDouble>(nPts);
398 m_fields[0]->PhysInterp1DScaled(OneDptscale, physfield[i],
399 vel_interp[i]);
400
401 // Interpolate derivatives
404 {
405 deriv_interp[i][j] = Array<OneD, NekDouble>(nPts);
406 m_fields[0]->PhysInterp1DScaled(OneDptscale, derivativesO1[i][j],
407 deriv_interp[i][j]);
408 }
409
410 // Output (start from j=1 since flux is zero for rho)
413 {
414 out_interp[i][j] = Array<OneD, NekDouble>(nPts);
415 }
416 }
417
418 // Velocity divergence
420 {
421 Vmath::Vadd(nPts, divVel, 1, deriv_interp[j][j], 1, divVel, 1);
422 }
423
424 // Velocity divergence scaled by lambda * mu
425 Vmath::Smul(nPts, lambda, divVel, 1, divVel, 1);
426 Vmath::Vmul(nPts, mu, 1, divVel, 1, divVel, 1);
427
428 // Viscous flux vector for the rho equation = 0 (no need to dealias)
430 {
431 Vmath::Zero(nPts_orig, viscousTensor[i][0], 1);
432 }
433
434 // Viscous stress tensor (for the momentum equations)
436 {
438 {
439 Vmath::Vadd(nPts, deriv_interp[i][j], 1, deriv_interp[j][i], 1,
440 out_interp[i][j + 1], 1);
441
442 Vmath::Vmul(nPts, mu, 1, out_interp[i][j + 1], 1,
443 out_interp[i][j + 1], 1);
444
445 if (i == j)
446 {
447 // Add divergence term to diagonal
448 Vmath::Vadd(nPts, out_interp[i][j + 1], 1, divVel, 1,
449 out_interp[i][j + 1], 1);
450 }
451 else
452 {
453 // Make symmetric
454 out_interp[j][i + 1] = out_interp[i][j + 1];
455 }
456 }
457 }
458
459 // Terms for the energy equation
461 {
463 // u_j * tau_ij
465 {
466 Vmath::Vvtvp(nPts, vel_interp[j], 1, out_interp[i][j + 1], 1,
467 out_interp[i][m_spacedim + 1], 1,
468 out_interp[i][m_spacedim + 1], 1);
469 }
470 // Add k*T_i
472 1, out_interp[i][m_spacedim + 1], 1,
473 out_interp[i][m_spacedim + 1], 1);
474 }
475
476 // Project to original space
478 {
480 {
481 m_fields[0]->PhysGalerkinProjection1DScaled(
482 OneDptscale, out_interp[i][j], viscousTensor[i][j]);
483 }
484 }
485}
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 56 of file NavierStokesCFE.cpp.
57{
58 CompressibleFlowSystem::v_InitObject(DeclareFields);
59
60 // rest of initialisation is in this routine so it can also be called
61 // in NavierStokesImplicitCFE initialisation
62 InitObject_Explicit();
63}
void v_InitObject(bool DeclareFields=true) override
Initialization object for CompressibleFlowSystem class.
Definition: CompressibleFlowSystem.cpp:54
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 986 of file NavierStokesCFE.cpp.
987{
988 if (type == "NonSmooth" || type == "Physical" || type == "Off")
989 {
990 return true;
991 }
992 else
993 {
994 return false;
995 }
996}
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 65 of file NavierStokesCFE.h.
◆ m_C0ProjectExp
|
protected |
Definition at line 87 of file NavierStokesCFE.h.
◆ m_Cp
|
protected |
Definition at line 81 of file NavierStokesCFE.h.
Referenced by GetViscosityAndThermalCondFromTemp(), GetViscosityAndThermalCondFromTempKernel(), and InitObject_Explicit().
◆ 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
|
protected |
Equation of system for computing temperature.
Definition at line 90 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 76 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 73 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 79 of file NavierStokesCFE.h.
Referenced by GetViscosityAndThermalCondFromTemp(), InitObject_Explicit(), v_DoDiffusion(), Nektar::NavierStokesImplicitCFE::v_DoDiffusionCoeff(), and v_ExtraFldOutput().
◆ m_muRef
|
protected |
Definition at line 93 of file NavierStokesCFE.h.
Referenced by GetViscosityFromTempKernel(), and InitObject_Explicit().
◆ m_physicalSensorType
|
protected |
Definition at line 85 of file NavierStokesCFE.h.
◆ 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
|
protected |
Definition at line 86 of file NavierStokesCFE.h.
◆ m_thermalConductivityRef
|
protected |
Definition at line 94 of file NavierStokesCFE.h.
Referenced by InitObject_Explicit().
◆ m_Twall
|
protected |
Definition at line 92 of file NavierStokesCFE.h.
Referenced by InitObject_Explicit(), and SpecialBndTreat().
◆ m_ViscosityType
|
protected |
Definition at line 70 of file NavierStokesCFE.h.
Referenced by InitObject_Explicit(), and Nektar::NavierStokesImplicitCFE::v_CalcMuDmuDT().
