#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 () |
| virtual void | v_InitObject (bool DeclareField=true) override |
| Initialization object for CompressibleFlowSystem class. More... | |
| virtual void | v_DoDiffusion (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd) override |
| virtual void | v_GetViscousFluxVector (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &derivatives, TensorOfArray3D< NekDouble > &viscousTensor) |
| Return the flux vector for the LDG diffusion problem. More... | |
| virtual void | v_GetViscousFluxVectorDeAlias (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &derivatives, TensorOfArray3D< NekDouble > &viscousTensor) |
| Return the flux vector for the LDG diffusion problem. More... | |
| void | GetPhysicalAV (const Array< OneD, const Array< OneD, NekDouble > > &physfield) |
| void | Ducros (Array< OneD, NekDouble > &field) |
| void | C0Smooth (Array< OneD, NekDouble > &field) |
| virtual void | v_GetFluxPenalty (const Array< OneD, const Array< OneD, NekDouble > > &uFwd, const Array< OneD, const Array< OneD, NekDouble > > &uBwd, Array< OneD, Array< OneD, NekDouble > > &penaltyCoeff) |
| Return the penalty vector for the LDGNS diffusion problem. More... | |
| void | GetViscosityAndThermalCondFromTemp (const Array< OneD, NekDouble > &temperature, Array< OneD, NekDouble > &mu, Array< OneD, NekDouble > &thermalCond) |
| Update viscosity todo: add artificial viscosity here. More... | |
| void | GetDivCurlSquared (const Array< OneD, MultiRegions::ExpListSharedPtr > &fields, const Array< OneD, Array< OneD, NekDouble > > &cnsVar, Array< OneD, NekDouble > &div, Array< OneD, NekDouble > &curlSquare, const Array< OneD, Array< OneD, NekDouble > > &cnsVarFwd, const Array< OneD, Array< OneD, NekDouble > > &cnsVarBwd) |
| Get divergence and curl squared. More... | |
| void | GetDivCurlFromDvelT (const TensorOfArray3D< NekDouble > &pVarDer, Array< OneD, NekDouble > &div, Array< OneD, NekDouble > &curlSquare) |
| Get divergence and curl from velocity derivative tensor. More... | |
| virtual void | v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables) override |
| template<class T , typename = typename std::enable_if< std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value>::type> | |
| void | GetViscosityAndThermalCondFromTempKernel (const T &temperature, T &mu, T &thermalCond) |
| template<class T , typename = typename std::enable_if< std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value>::type> | |
| void | GetViscosityFromTempKernel (const T &temperature, T &mu) |
| template<class T , typename = typename std::enable_if< std::is_floating_point<T>::value || tinysimd::is_vector_floating_point<T>::value>::type> | |
| void | GetViscousFluxBilinearFormKernel (const unsigned short nDim, const unsigned short FluxDirection, const unsigned short DerivDirection, const T *inaverg, const T *injumpp, const T &mu, T *outarray) |
| Calculate diffusion flux using the Jacobian form. More... | |
| template<bool IS_TRACE> | |
| void | GetViscousFluxVectorConservVar (const 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... | |
| virtual 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) | |
| virtual void | v_InitObject (bool DeclareFields=true) override |
| Initialization object for CompressibleFlowSystem class. More... | |
| virtual void | v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure) override |
| virtual void | v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density) override |
| virtual bool | v_HasConstantDensity () override |
| virtual void | v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity) 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... | |
| virtual NekDouble | v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray) override |
| Calculate the maximum timestep subject to CFL restrictions. More... | |
| virtual void | v_GenerateSummary (SolverUtils::SummaryList &s) override |
| Print a summary of time stepping parameters. More... | |
| virtual void | v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) override |
| Set up logic for residual calculation. More... | |
| virtual 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 () |
| virtual MultiRegions::ExpListSharedPtr | v_GetPressure () override |
| virtual 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 |
| virtual Array< OneD, NekDouble > | v_GetMaxStdVelocity (const NekDouble SpeedSoundFactor) override |
| Compute the advection velocity in the standard space for each element of the expansion. More... | |
| virtual void | v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2) override |
| virtual bool | v_SupportsShockCaptType (const std::string type) const =0 |
| Protected Member Functions inherited from Nektar::SolverUtils::AdvectionSystem | |
| virtual 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... | |
| virtual SOLVER_UTILS_EXPORT void | v_InitObject (bool DeclareField=true) override |
| Init object for UnsteadySystem class. More... | |
| virtual 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... | |
| virtual SOLVER_UTILS_EXPORT void | v_DoInitialise (bool dumpInitialConditions=true) override |
| Sets up initial conditions. More... | |
| virtual 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) |
| virtual SOLVER_UTILS_EXPORT void | v_GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels) |
| virtual SOLVER_UTILS_EXPORT void | v_SetMovingFrameProjectionMat (const boost::numeric::ublas::matrix< NekDouble > &vProjMat) |
| virtual SOLVER_UTILS_EXPORT void | v_GetMovingFrameProjectionMat (boost::numeric::ublas::matrix< NekDouble > &vProjMat) |
| virtual SOLVER_UTILS_EXPORT void | v_SetMovingFrameAngles (const Array< OneD, NekDouble > &vFrameTheta) |
| virtual SOLVER_UTILS_EXPORT void | v_GetMovingFrameAngles (Array< OneD, NekDouble > &vFrameTheta) |
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_movingFrameVelsxyz |
| Moving frame of reference velocities. More... | |
| Array< OneD, NekDouble > | m_movingFrameTheta |
| Moving frame of reference angles with respect to the. More... | |
| boost::numeric::ublas::matrix< NekDouble > | m_movingFrameProjMat |
| Projection matrix for transformation between inertial and moving. More... | |
| int | m_NumQuadPointsError |
| Number of Quadrature points used to work out the error. More... | |
| enum HomogeneousType | m_HomogeneousType |
| NekDouble | m_LhomX |
| physical length in X direction (if homogeneous) More... | |
| NekDouble | m_LhomY |
| physical length in Y direction (if homogeneous) More... | |
| NekDouble | m_LhomZ |
| physical length in Z direction (if homogeneous) More... | |
| int | m_npointsX |
| number of points in X direction (if homogeneous) More... | |
| int | m_npointsY |
| number of points in Y direction (if homogeneous) More... | |
| int | m_npointsZ |
| number of points in Z direction (if homogeneous) More... | |
| int | m_HomoDirec |
| number of homogenous directions More... | |
Friends | |
| class | MemoryManager< NavierStokesCFE > |
Additional Inherited Members | |
| 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()
|
virtual |
Definition at line 53 of file NavierStokesCFE.cpp.
54{
55}
◆ NavierStokesCFE()
|
protected |
Definition at line 46 of file NavierStokesCFE.cpp.
50{
51}
CompressibleFlowSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Definition: CompressibleFlowSystem.cpp:45
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
Definition: UnsteadySystem.cpp:76
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:168
std::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.
Definition: EquationSystem.h:66
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 772 of file NavierStokesCFE.cpp.
775{
776 size_t nDim = pVarDer.size();
777 size_t nPts = div.size();
778
779 // div velocity
781 {
782 NekDouble divTmp = 0;
783 for (unsigned short j = 0; j < nDim; ++j)
784 {
785 divTmp += pVarDer[j][j][p];
786 }
787 div[p] = divTmp;
788 }
789
790 // |curl velocity| ** 2
791 if (nDim > 2)
792 {
794 {
795 // curl[0] 3/2 - 2/3
798 NekDouble curl0 = curl032 - curl023;
799 // square curl[0]
800 NekDouble curl0sqr = curl0 * curl0;
801
802 // curl[1] 3/1 - 1/3
805 NekDouble curl1 = curl131 - curl113;
806 // square curl[1]
807 NekDouble curl1sqr = curl1 * curl1;
808
809 // curl[2] 1/2 - 2/1
812 NekDouble curl2 = curl212 - curl221;
813 // square curl[2]
814 NekDouble curl2sqr = curl2 * curl2;
815
816 // reduce
817 curl0sqr += curl1sqr + curl2sqr;
818 // store
820 }
821 }
822 else if (nDim > 1)
823 {
825 {
826 // curl[2] 1/2
828 // curl[2] 2/1
830 // curl[2] 1/2 - 2/1
831 NekDouble curl = c212 - c221;
832 // square curl[2]
834 }
835 }
836 else
837 {
838 Vmath::Fill(nPts, 0.0, curlSquare, 1);
839 }
840}
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:43
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 704 of file NavierStokesCFE.cpp.
710{
711 size_t nDim = fields[0]->GetCoordim(0);
712 size_t nVar = cnsVar.size();
713 size_t nPts = cnsVar[0].size();
714 size_t nPtsTrc = cnsVarFwd[0].size();
715
716 // These should be allocated once
717 Array<OneD, Array<OneD, NekDouble>> primVar(nVar - 1), primVarFwd(nVar - 1),
718 primVarBwd(nVar - 1);
719
721 {
725 }
726 size_t ergLoc = nVar - 2;
727 primVar[ergLoc] = Array<OneD, NekDouble>(nPts, 0.0);
728 primVarFwd[ergLoc] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
729 primVarBwd[ergLoc] = Array<OneD, NekDouble>(nPtsTrc, 0.0);
730
731 // Get primitive variables [u,v,w,T=0]
732 // Possibly should be changed to [rho,u,v,w,T] to make IP and LDGNS more
733 // consistent with each other
735 {
736 // Volume
738 {
740 }
741 // Trace
743 {
746 }
747 }
748
749 // this should be allocated once
750 Array<OneD, Array<OneD, Array<OneD, NekDouble>>> primVarDer(nDim);
751 for (unsigned short j = 0; j < nDim; ++j)
752 {
753 primVarDer[j] = Array<OneD, Array<OneD, NekDouble>>(nVar - 1);
754 for (unsigned short i = 0; i < nVar - 1; ++i)
755 {
756 primVarDer[j][i] = Array<OneD, NekDouble>(nPts, 0.0);
757 }
758 }
759
760 // Get derivative tensor
761 m_diffusion->DiffuseCalcDerivative(fields, primVar, primVarDer, primVarFwd,
762 primVarBwd);
763
764 // Get div curl squared
765 GetDivCurlFromDvelT(primVarDer, div, curlSquare);
766}
Definition: SharedArray.hpp:53
SolverUtils::DiffusionSharedPtr m_diffusion
Definition: CompressibleFlowSystem.h:78
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 659 of file NavierStokesCFE.cpp.
662{
663 size_t nPts = temperature.size();
664
666 {
668 thermalCond[p]);
669 }
670
671 // Add artificial viscosity if wanted
672 // move this above and add in kernel
674 {
676 if (nPts != nTracePts)
677 {
679 }
680 else
681 {
683 }
684
685 // Update thermal conductivity
687 Vmath::Smul(nPts, tRa, mu, 1, thermalCond, 1);
688 }
689}
VariableConverterSharedPtr m_varConv
Definition: CompressibleFlowSystem.h:100
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:363
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:354
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.cpp:245
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 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<T>::value || tinysimd::is_vector_floating_point<T>::value>::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<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 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 565 of file NavierStokesCFE.cpp.
570{
571 size_t nConvectiveFields = inarray.size();
572 size_t nPts = inaverg[nConvectiveFields - 1].size();
573 nonZeroIndex = Array<OneD, int>{nConvectiveFields - 1, 0};
574 for (size_t i = 0; i < nConvectiveFields - 1; ++i)
575 {
576 nonZeroIndex[i] = i + 1;
577 }
578
579 Array<OneD, NekDouble> mu(nPts, 0.0);
580 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
581 Array<OneD, NekDouble> temperature(nPts, 0.0);
582 m_varConv->GetTemperature(inaverg, temperature);
583 GetViscosityAndThermalCondFromTemp(temperature, mu, thermalConductivity);
584
585 std::vector<NekDouble> inAvgTmp(nConvectiveFields);
586 std::vector<NekDouble> inTmp(nConvectiveFields);
587 std::vector<NekDouble> outTmp(nConvectiveFields);
589 {
590 for (size_t nderiv = 0; nderiv < nDim; ++nderiv)
591 {
593 {
594 // rearrenge data
595 for (size_t f = 0; f < nConvectiveFields; ++f)
596 {
597 inAvgTmp[f] = inaverg[f][p];
598 inTmp[f] = inarray[f][p];
599 }
600
602 inAvgTmp.data(), inTmp.data(),
603 mu[p], outTmp.data());
604
605 for (size_t f = 0; f < nConvectiveFields; ++f)
606 {
608 }
609 }
610 }
611 }
612}
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 69 of file NavierStokesCFE.cpp.
70{
71 // Get gas constant from session file and compute Cp
72 NekDouble gasConstant;
76
78
79 // Viscosity
83 {
85 }
86
87 // Thermal conductivity or Prandtl
89 {
91 "Cannot define both Pr and thermalConductivity.");
92
96 }
97 else
98 {
101 }
102
104 {
106 }
107
108 string diffName;
110
111 m_diffusion =
113 if ("InteriorPenalty" == diffName)
114 {
117 }
118
119 if ("LDGNS" == diffName || "LDGNS3DHomogeneous1D" == diffName)
120 {
122 }
123
125 {
126 m_diffusion->SetFluxVectorNS(
128 }
129 else
130 {
132 this);
133 }
134
135 m_diffusion->SetDiffusionFluxCons(
136 &NavierStokesCFE::GetViscousFluxVectorConservVar<false>, this);
137
138 m_diffusion->SetDiffusionFluxConsTrace(
139 &NavierStokesCFE::GetViscousFluxVectorConservVar<true>, this);
140
142
143 m_diffusion->SetDiffusionSymmFluxCons(
145
146 // Concluding initialisation of diffusion operator
148}
std::string m_shockCaptureType
Definition: CompressibleFlowSystem.h:82
void SetBoundaryConditionsBwdWeight()
Set up a weight on physical boundaries for boundary condition applications.
Definition: CompressibleFlowSystem.cpp:392
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:144
bool m_specHP_dealiasing
Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
Definition: EquationSystem.h:420
DiffusionFactory & GetDiffusionFactory()
Definition: Diffusion.cpp:41
References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::SolverUtils::GetDiffusionFactory(), GetViscousSymmtrFluxConservVar(), m_Cp, m_Cv, Nektar::CompressibleFlowSystem::m_diffusion, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::CompressibleFlowSystem::m_gamma, m_is_diffIP, m_is_mu_variable, m_is_shockCaptPhys, m_muRef, m_Prandtl, Nektar::SolverUtils::EquationSystem::m_session, Nektar::CompressibleFlowSystem::m_shockCaptureType, Nektar::SolverUtils::EquationSystem::m_specHP_dealiasing, m_thermalConductivityRef, m_Twall, m_ViscosityType, Nektar::CompressibleFlowSystem::SetBoundaryConditionsBwdWeight(), SpecialBndTreat(), v_GetFluxPenalty(), v_GetViscousFluxVector(), and v_GetViscousFluxVectorDeAlias().
Referenced by v_InitObject(), and Nektar::NavierStokesImplicitCFE::v_InitObject().
◆ SpecialBndTreat()
|
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 476 of file NavierStokesCFE.cpp.
478{
479 size_t nConvectiveFields = consvar.size();
480 size_t ndens = 0;
481 size_t nengy = nConvectiveFields - 1;
482
483 Array<OneD, Array<OneD, NekDouble>> bndCons{nConvectiveFields};
484 Array<OneD, NekDouble> bndTotEngy;
485 Array<OneD, NekDouble> bndPressure;
486 Array<OneD, NekDouble> bndRho;
487 Array<OneD, NekDouble> bndIntEndy;
488 size_t nLengthArray = 0;
489
490 size_t cnt = 0;
492 for (size_t j = 0; j < nBndRegions; ++j)
493 {
495 ->GetBndConditions()[j]
496 ->GetBoundaryConditionType() == SpatialDomains::ePeriodic)
497 {
498 continue;
499 }
500
501 size_t nBndEdges =
502 m_fields[nengy]->GetBndCondExpansions()[j]->GetExpSize();
503 for (size_t e = 0; e < nBndEdges; ++e)
504 {
506 ->GetBndCondExpansions()[j]
507 ->GetExp(e)
508 ->GetTotPoints();
509
511 m_fields[0]->GetTraceMap()->GetBndCondIDToGlobalTraceID(cnt++));
512
513 // Imposing Temperature Twall at the wall
514 if (boost::iequals(
515 m_fields[nengy]->GetBndConditions()[j]->GetUserDefined(),
516 "WallViscous"))
517 {
518 if (nBndEdgePts != nLengthArray)
519 {
520 for (size_t i = 0; i < nConvectiveFields; ++i)
521 {
522 bndCons[i] = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
523 }
524 bndTotEngy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
525 bndPressure = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
526 bndRho = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
527 bndIntEndy = Array<OneD, NekDouble>{nBndEdgePts, 0.0};
528 nLengthArray = nBndEdgePts;
529 }
530 else
531 {
532 Vmath::Zero(nLengthArray, bndPressure, 1);
533 Vmath::Zero(nLengthArray, bndRho, 1);
534 Vmath::Zero(nLengthArray, bndIntEndy, 1);
535 }
536
537 Array<OneD, NekDouble> tmp;
538
539 for (size_t k = 0; k < nConvectiveFields; ++k)
540 {
541 Vmath::Vcopy(nBndEdgePts, tmp = consvar[k] + id2, 1,
542 bndCons[k], 1);
543 }
544
545 m_varConv->GetPressure(bndCons, bndPressure);
547 m_varConv->GetRhoFromPT(bndPressure, bndTotEngy, bndRho);
548 m_varConv->GetEFromRhoP(bndRho, bndPressure, bndIntEndy);
549 m_varConv->GetDynamicEnergy(bndCons, bndTotEngy);
550
551 Vmath::Vvtvp(nBndEdgePts, bndIntEndy, 1, bndCons[ndens], 1,
552 bndTotEngy, 1, bndTotEngy, 1);
553
554 Vmath::Vcopy(nBndEdgePts, bndTotEngy, 1,
555 tmp = consvar[nengy] + id2, 1);
556 }
557 }
558 }
559}
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:569
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1191
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::NavierStokesCFEAxisym, and Nektar::NavierStokesImplicitCFE.
Definition at line 150 of file NavierStokesCFE.cpp.
155{
156 size_t nvariables = inarray.size();
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>(npoints, 0.0);
165 }
166
167 // Set artificial viscosity based on NS viscous tensor
169 {
171 {
172 Array<OneD, NekDouble> div(npoints), curlSquare(npoints);
174
175 // Set volume and trace artificial viscosity
177 }
178 else
179 {
181 }
182 }
183
185 {
187 {
189 }
191 m_bndEvaluateTime, pFwd, pBwd);
192 for (size_t i = 0; i < nvariables; ++i)
193 {
194 Vmath::Vadd(npoints, outarrayDiff[i], 1, outarray[i], 1,
195 outarray[i], 1);
196 }
197 }
198 else
199 {
200 // Get primitive variables [u,v,w,T]
201 Array<OneD, Array<OneD, NekDouble>> inarrayDiff(nvariables - 1);
202 Array<OneD, Array<OneD, NekDouble>> inFwd(nvariables - 1);
203 Array<OneD, Array<OneD, NekDouble>> inBwd(nvariables - 1);
204
205 for (size_t i = 0; i < nvariables - 1; ++i)
206 {
207 inarrayDiff[i] = Array<OneD, NekDouble>{npoints};
208 inFwd[i] = Array<OneD, NekDouble>{nTracePts};
209 inBwd[i] = Array<OneD, NekDouble>{nTracePts};
210 }
211
212 // Extract pressure
213 // (use inarrayDiff[0] as a temporary storage for the pressure)
214 m_varConv->GetPressure(inarray, inarrayDiff[0]);
215
216 // Extract temperature
217 m_varConv->GetTemperature(inarray, inarrayDiff[nvariables - 2]);
218
219 // Extract velocities
220 m_varConv->GetVelocityVector(inarray, inarrayDiff);
221
222 // Repeat calculation for trace space
224 pBwd == NullNekDoubleArrayOfArray)
225 {
226 inFwd = NullNekDoubleArrayOfArray;
227 inBwd = NullNekDoubleArrayOfArray;
228 }
229 else
230 {
231 m_varConv->GetPressure(pFwd, inFwd[0]);
232 m_varConv->GetPressure(pBwd, inBwd[0]);
233
234 m_varConv->GetTemperature(pFwd, inFwd[nvariables - 2]);
235 m_varConv->GetTemperature(pBwd, inBwd[nvariables - 2]);
236
237 m_varConv->GetVelocityVector(pFwd, inFwd);
238 m_varConv->GetVelocityVector(pBwd, inBwd);
239 }
240
241 // Diffusion term in physical rhs form
243 inFwd, inBwd);
244
245 for (size_t i = 0; i < nvariables; ++i)
246 {
247 Vmath::Vadd(npoints, outarrayDiff[i], 1, outarray[i], 1,
248 outarray[i], 1);
249 }
250 }
251
252 // Add artificial diffusion through Laplacian operator
254 {
255 m_artificialDiffusion->DoArtificialDiffusion(inarray, outarray);
256 }
257}
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:209
NekDouble m_bndEvaluateTime
Definition: CompressibleFlowSystem.h:105
ArtificialDiffusionSharedPtr m_artificialDiffusion
Definition: CompressibleFlowSystem.h:79
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
Definition: EquationSystem.h:740
SOLVER_UTILS_EXPORT int GetNpoints()
Definition: EquationSystem.h:775
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray
Definition: SharedArray.hpp:889
References Nektar::ErrorUtil::efatal, GetDivCurlSquared(), Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::CompressibleFlowSystem::m_artificialDiffusion, Nektar::CompressibleFlowSystem::m_bndEvaluateTime, Nektar::CompressibleFlowSystem::m_diffusion, Nektar::SolverUtils::EquationSystem::m_fields, m_is_diffIP, m_is_shockCaptPhys, Nektar::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 842 of file NavierStokesCFE.cpp.
845{
846 bool extraFields;
848 if (extraFields)
849 {
853
855 {
856 cnsVar[i] = m_fields[i]->GetPhys();
857 }
858
862 {
863 velocity[i] = Array<OneD, NekDouble>(nPhys);
864 velFwd[i] = Array<OneD, NekDouble>(nCoeffs);
865 }
866
868 Array<OneD, NekDouble> entropy(nPhys);
869 Array<OneD, NekDouble> soundspeed(nPhys), mach(nPhys);
870 Array<OneD, NekDouble> sensor(nPhys), SensorKappa(nPhys);
871
872 m_varConv->GetVelocityVector(cnsVar, velocity);
874 m_varConv->GetTemperature(cnsVar, temperature);
875 m_varConv->GetEntropy(cnsVar, entropy);
876 m_varConv->GetSoundSpeed(cnsVar, soundspeed);
877 m_varConv->GetMach(cnsVar, soundspeed, mach);
878
879 int sensorOffset;
882 sensorOffset);
883
884 Array<OneD, NekDouble> pFwd(nCoeffs), TFwd(nCoeffs);
885 Array<OneD, NekDouble> sFwd(nCoeffs);
886 Array<OneD, NekDouble> aFwd(nCoeffs), mFwd(nCoeffs);
887 Array<OneD, NekDouble> sensFwd(nCoeffs);
888
889 string velNames[3] = {"u", "v", "w"};
891 {
892 m_fields[0]->FwdTransLocalElmt(velocity[i], velFwd[i]);
893 variables.push_back(velNames[i]);
894 fieldcoeffs.push_back(velFwd[i]);
895 }
896
898 m_fields[0]->FwdTransLocalElmt(temperature, TFwd);
899 m_fields[0]->FwdTransLocalElmt(entropy, sFwd);
900 m_fields[0]->FwdTransLocalElmt(soundspeed, aFwd);
901 m_fields[0]->FwdTransLocalElmt(mach, mFwd);
902 m_fields[0]->FwdTransLocalElmt(sensor, sensFwd);
903
904 variables.push_back("p");
905 variables.push_back("T");
906 variables.push_back("s");
907 variables.push_back("a");
908 variables.push_back("Mach");
909 variables.push_back("Sensor");
910 fieldcoeffs.push_back(pFwd);
911 fieldcoeffs.push_back(TFwd);
912 fieldcoeffs.push_back(sFwd);
913 fieldcoeffs.push_back(aFwd);
914 fieldcoeffs.push_back(mFwd);
915 fieldcoeffs.push_back(sensFwd);
916
918 {
919 // reuse pressure
920 Array<OneD, NekDouble> sensorFwd(nCoeffs);
923
924 variables.push_back("ArtificialVisc");
925 fieldcoeffs.push_back(sensorFwd);
926 }
927
929 {
930
932 cnsVarBwd(m_fields.size());
933
935 {
938 m_fields[i]->GetFwdBwdTracePhys(cnsVar[i], cnsVarFwd[i],
939 cnsVarBwd[i]);
940 }
941
942 Array<OneD, NekDouble> div(nPhys), curlSquare(nPhys);
944 cnsVarBwd);
945
946 Array<OneD, NekDouble> divFwd(nCoeffs, 0.0);
947 m_fields[0]->FwdTransLocalElmt(div, divFwd);
948 variables.push_back("div");
949 fieldcoeffs.push_back(divFwd);
950
951 Array<OneD, NekDouble> curlFwd(nCoeffs, 0.0);
952 m_fields[0]->FwdTransLocalElmt(curlSquare, curlFwd);
953 variables.push_back("curl^2");
954 fieldcoeffs.push_back(curlFwd);
955
957
958 Array<OneD, NekDouble> muavFwd(nCoeffs);
960 variables.push_back("ArtificialVisc");
961 fieldcoeffs.push_back(muavFwd);
962 }
963 }
964}
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 617 of file NavierStokesCFE.cpp.
621{
622 size_t nTracePts = uFwd[0].size();
623
624 // Compute average temperature
625 size_t nVariables = uFwd.size();
626 Array<OneD, NekDouble> tAve{nTracePts, 0.0};
627 Vmath::Svtsvtp(nTracePts, 0.5, uFwd[nVariables - 1], 1, 0.5,
628 uBwd[nVariables - 1], 1, tAve, 1);
629
630 // Get average viscosity and thermal conductivity
631 Array<OneD, NekDouble> muAve{nTracePts, 0.0};
632 Array<OneD, NekDouble> tcAve{nTracePts, 0.0};
633
634 GetViscosityAndThermalCondFromTemp(tAve, muAve, tcAve);
635
636 // Compute penalty term
637 for (size_t i = 0; i < nVariables; ++i)
638 {
639 // Get jump of u variables
640 Vmath::Vsub(nTracePts, uFwd[i], 1, uBwd[i], 1, penaltyCoeff[i], 1);
641 // Multiply by variable coefficient = {coeff} ( u^+ - u^- )
642 if (i < nVariables - 1)
643 {
644 Vmath::Vmul(nTracePts, muAve, 1, penaltyCoeff[i], 1,
645 penaltyCoeff[i], 1);
646 }
647 else
648 {
649 Vmath::Vmul(nTracePts, tcAve, 1, penaltyCoeff[i], 1,
650 penaltyCoeff[i], 1);
651 }
652 }
653}
void Svtsvtp(int n, const T alpha, const T *x, int incx, const T beta, const T *y, int incy, T *z, int incz)
svtvvtp (scalar times vector plus scalar times vector):
Definition: Vmath.cpp:746
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:207
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:414
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 263 of file NavierStokesCFE.cpp.
267{
268 // Auxiliary variables
269 size_t nScalar = physfield.size();
270 size_t nPts = physfield[0].size();
271 Array<OneD, NekDouble> divVel(nPts, 0.0);
272
273 // Stokes hypothesis
275
276 // Update viscosity and thermal conductivity
277 Array<OneD, NekDouble> mu(nPts, 0.0);
278 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
279 GetViscosityAndThermalCondFromTemp(physfield[nScalar - 1], mu,
280 thermalConductivity);
281
282 // Velocity divergence
284 {
285 Vmath::Vadd(nPts, divVel, 1, derivativesO1[j][j], 1, divVel, 1);
286 }
287
288 // Velocity divergence scaled by lambda * mu
289 Vmath::Smul(nPts, lambda, divVel, 1, divVel, 1);
290 Vmath::Vmul(nPts, mu, 1, divVel, 1, divVel, 1);
291
292 // Viscous flux vector for the rho equation = 0
294 {
295 Vmath::Zero(nPts, viscousTensor[i][0], 1);
296 }
297
298 // Viscous stress tensor (for the momentum equations)
300 {
302 {
303 Vmath::Vadd(nPts, derivativesO1[i][j], 1, derivativesO1[j][i], 1,
304 viscousTensor[i][j + 1], 1);
305
306 Vmath::Vmul(nPts, mu, 1, viscousTensor[i][j + 1], 1,
307 viscousTensor[i][j + 1], 1);
308
309 if (i == j)
310 {
311 // Add divergence term to diagonal
312 Vmath::Vadd(nPts, viscousTensor[i][j + 1], 1, divVel, 1,
313 viscousTensor[i][j + 1], 1);
314 }
315 else
316 {
317 // Copy to make symmetric
318 Vmath::Vcopy(nPts, viscousTensor[i][j + 1], 1,
319 viscousTensor[j][i + 1], 1);
320 }
321 }
322 }
323
324 // Terms for the energy equation
326 {
328 // u_j * tau_ij
330 {
331 Vmath::Vvtvp(nPts, physfield[j], 1, viscousTensor[i][j + 1], 1,
332 viscousTensor[i][m_spacedim + 1], 1,
333 viscousTensor[i][m_spacedim + 1], 1);
334 }
335 // Add k*T_i
337 1, viscousTensor[i][m_spacedim + 1], 1,
338 viscousTensor[i][m_spacedim + 1], 1);
339 }
340}
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 346 of file NavierStokesCFE.cpp.
350{
351 // Factor to rescale 1d points in dealiasing.
352 NekDouble OneDptscale = 2;
353 // Get number of points to dealias a cubic non-linearity
354 size_t nScalar = physfield.size();
356 size_t nPts_orig = physfield[0].size();
357
358 // Auxiliary variables
359 Array<OneD, NekDouble> divVel(nPts, 0.0);
360
361 // Stokes hypothesis
363
364 // Update viscosity and thermal conductivity
365 Array<OneD, NekDouble> mu(nPts, 0.0);
366 Array<OneD, NekDouble> thermalConductivity(nPts, 0.0);
367 GetViscosityAndThermalCondFromTemp(physfield[nScalar - 1], mu,
368 thermalConductivity);
369
370 // Interpolate inputs and initialise interpolated output
375 {
376 // Interpolate velocity
377 vel_interp[i] = Array<OneD, NekDouble>(nPts);
378 m_fields[0]->PhysInterp1DScaled(OneDptscale, physfield[i],
379 vel_interp[i]);
380
381 // Interpolate derivatives
384 {
385 deriv_interp[i][j] = Array<OneD, NekDouble>(nPts);
386 m_fields[0]->PhysInterp1DScaled(OneDptscale, derivativesO1[i][j],
387 deriv_interp[i][j]);
388 }
389
390 // Output (start from j=1 since flux is zero for rho)
393 {
394 out_interp[i][j] = Array<OneD, NekDouble>(nPts);
395 }
396 }
397
398 // Velocity divergence
400 {
401 Vmath::Vadd(nPts, divVel, 1, deriv_interp[j][j], 1, divVel, 1);
402 }
403
404 // Velocity divergence scaled by lambda * mu
405 Vmath::Smul(nPts, lambda, divVel, 1, divVel, 1);
406 Vmath::Vmul(nPts, mu, 1, divVel, 1, divVel, 1);
407
408 // Viscous flux vector for the rho equation = 0 (no need to dealias)
410 {
411 Vmath::Zero(nPts_orig, viscousTensor[i][0], 1);
412 }
413
414 // Viscous stress tensor (for the momentum equations)
416 {
418 {
419 Vmath::Vadd(nPts, deriv_interp[i][j], 1, deriv_interp[j][i], 1,
420 out_interp[i][j + 1], 1);
421
422 Vmath::Vmul(nPts, mu, 1, out_interp[i][j + 1], 1,
423 out_interp[i][j + 1], 1);
424
425 if (i == j)
426 {
427 // Add divergence term to diagonal
428 Vmath::Vadd(nPts, out_interp[i][j + 1], 1, divVel, 1,
429 out_interp[i][j + 1], 1);
430 }
431 else
432 {
433 // Make symmetric
434 out_interp[j][i + 1] = out_interp[i][j + 1];
435 }
436 }
437 }
438
439 // Terms for the energy equation
441 {
443 // u_j * tau_ij
445 {
446 Vmath::Vvtvp(nPts, vel_interp[j], 1, out_interp[i][j + 1], 1,
447 out_interp[i][m_spacedim + 1], 1,
448 out_interp[i][m_spacedim + 1], 1);
449 }
450 // Add k*T_i
452 1, out_interp[i][m_spacedim + 1], 1,
453 out_interp[i][m_spacedim + 1], 1);
454 }
455
456 // Project to original space
458 {
460 {
461 m_fields[0]->PhysGalerkinProjection1DScaled(
462 OneDptscale, out_interp[i][j], viscousTensor[i][j]);
463 }
464 }
465}
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 60 of file NavierStokesCFE.cpp.
61{
62 CompressibleFlowSystem::v_InitObject(DeclareFields);
63
64 // rest of initialisation is in this routine so it can also be called
65 // in NavierStokesImplicitCFE initialisation
66 InitObject_Explicit();
67}
virtual void v_InitObject(bool DeclareFields=true) override
Initialization object for CompressibleFlowSystem class.
Definition: CompressibleFlowSystem.cpp:55
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 966 of file NavierStokesCFE.cpp.
967{
968 if (type == "NonSmooth" || type == "Physical" || type == "Off")
969 {
970 return true;
971 }
972 else
973 {
974 return false;
975 }
976}
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: NekFactory.hpp:198
EquationSystemFactory & GetEquationSystemFactory()
Definition: EquationSystem.cpp:103
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().
