Nektar++
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Friends | List of all members
Nektar::CompressibleFlowSystem Class Referenceabstract

#include <CompressibleFlowSystem.h>

Inheritance diagram for Nektar::CompressibleFlowSystem:
[legend]

Public Member Functions

NekDouble GetStabilityLimit (int n)
 Function to calculate the stability limit for DG/CG. More...
 
Array< OneD, NekDoubleGetStabilityLimitVector (const Array< OneD, int > &ExpOrder)
 Function to calculate the stability limit for DG/CG (a vector of them). More...
 
- Public Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT AdvectionSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
SOLVER_UTILS_EXPORT ~AdvectionSystem () override=default
 
SOLVER_UTILS_EXPORT AdvectionSharedPtr GetAdvObject ()
 Returns the advection object held by this instance. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleGetElmtCFLVals (const bool FlagAcousticCFL=true)
 
SOLVER_UTILS_EXPORT NekDouble GetCFLEstimate (int &elmtid)
 
- Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT ~UnsteadySystem () override=default
 Destructor. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Calculate the larger time-step mantaining the problem stable. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void SetTimeStep (const NekDouble timestep)
 
SOLVER_UTILS_EXPORT void SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeSharedPtrGetTimeIntegrationScheme ()
 Returns the time integration scheme. More...
 
SOLVER_UTILS_EXPORT LibUtilities::TimeIntegrationSchemeOperatorsGetTimeIntegrationSchemeOperators ()
 Returns the time integration scheme operators. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void InitObject (bool DeclareField=true)
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise (bool dumpInitialConditions=true)
 Perform any initialisation necessary before solving the problem. More...
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem. More...
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space. More...
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space. More...
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve. More...
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
std::shared_ptr< T > as ()
 
SOLVER_UTILS_EXPORT void ResetSessionName (std::string newname)
 Reset Session name. More...
 
SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr GetSession ()
 Get Session name. More...
 
SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr GetPressure ()
 Get pressure field if available. More...
 
SOLVER_UTILS_EXPORT void ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
SOLVER_UTILS_EXPORT void PrintSummary (std::ostream &out)
 Print a summary of parameters and solver characteristics. More...
 
SOLVER_UTILS_EXPORT void SetLambda (NekDouble lambda)
 Set parameter m_lambda. More...
 
SOLVER_UTILS_EXPORT SessionFunctionSharedPtr GetFunction (std::string name, const MultiRegions::ExpListSharedPtr &field=MultiRegions::NullExpListSharedPtr, bool cache=false)
 Get a SessionFunction by name. More...
 
SOLVER_UTILS_EXPORT void SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Initialise the data in the dependent fields. More...
 
SOLVER_UTILS_EXPORT void EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 Evaluates an exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the L2 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, bool Normalised=false)
 Compute the L2 error of the fields. More...
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT NekDouble H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the H1 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDoubleErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n)
 Write checkpoint file of m_fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_Output (const int n, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 Write checkpoint file of custom data fields. More...
 
SOLVER_UTILS_EXPORT void Checkpoint_BaseFlow (const int n)
 Write base flow file of m_fields. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname)
 Write field data to the given filename. More...
 
SOLVER_UTILS_EXPORT void WriteFld (const std::string &outname, MultiRegions::ExpListSharedPtr &field, std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 Write input fields to the given filename. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
 Input field data from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFldToMultiDomains (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const int ndomains)
 Input field data from the given file to multiple domains. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, std::vector< std::string > &fieldStr, Array< OneD, Array< OneD, NekDouble > > &coeffs)
 Output a field. Input field data into array from the given file. More...
 
SOLVER_UTILS_EXPORT void ImportFld (const std::string &infile, MultiRegions::ExpListSharedPtr &pField, std::string &pFieldName)
 Output a field. Input field data into ExpList from the given file. More...
 
SOLVER_UTILS_EXPORT void SessionSummary (SummaryList &vSummary)
 Write out a session summary. More...
 
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > & UpdateFields ()
 
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMapUpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTime ()
 Return final time. More...
 
SOLVER_UTILS_EXPORT int GetNcoeffs ()
 
SOLVER_UTILS_EXPORT int GetNcoeffs (const int eid)
 
SOLVER_UTILS_EXPORT int GetNumExpModes ()
 
SOLVER_UTILS_EXPORT const Array< OneD, int > GetNumExpModesPerExp ()
 
SOLVER_UTILS_EXPORT int GetNvariables ()
 
SOLVER_UTILS_EXPORT const std::string GetVariable (unsigned int i)
 
SOLVER_UTILS_EXPORT int GetTraceTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTraceNpoints ()
 
SOLVER_UTILS_EXPORT int GetExpSize ()
 
SOLVER_UTILS_EXPORT int GetPhys_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetCoeff_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTotPoints (int n)
 
SOLVER_UTILS_EXPORT int GetNpoints ()
 
SOLVER_UTILS_EXPORT int GetSteps ()
 
SOLVER_UTILS_EXPORT void SetSteps (const int steps)
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void CopyToPhysField (const int i, const Array< OneD, const NekDouble > &input)
 
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > & UpdatePhysField (const int i)
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void SetModifiedBasis (const bool modbasis)
 
SOLVER_UTILS_EXPORT int GetCheckpointNumber ()
 
SOLVER_UTILS_EXPORT void SetCheckpointNumber (int num)
 
SOLVER_UTILS_EXPORT int GetCheckpointSteps ()
 
SOLVER_UTILS_EXPORT void SetCheckpointSteps (int num)
 
SOLVER_UTILS_EXPORT int GetInfoSteps ()
 
SOLVER_UTILS_EXPORT void SetInfoSteps (int num)
 
SOLVER_UTILS_EXPORT void SetIterationNumberPIT (int num)
 
SOLVER_UTILS_EXPORT void SetWindowNumberPIT (int num)
 
SOLVER_UTILS_EXPORT Array< OneD, const Array< OneD, NekDouble > > GetTraceNormals ()
 
SOLVER_UTILS_EXPORT void SetTime (const NekDouble time)
 
SOLVER_UTILS_EXPORT void SetTimeStep (const NekDouble timestep)
 
SOLVER_UTILS_EXPORT void SetInitialStep (const int step)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
SOLVER_UTILS_EXPORT bool NegatedOp ()
 Identify if operator is negated in DoSolve. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::ALEHelper
virtual ~ALEHelper ()=default
 
virtual SOLVER_UTILS_EXPORT void v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
 
SOLVER_UTILS_EXPORT void InitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
 
virtual SOLVER_UTILS_EXPORT void v_UpdateGridVelocity (const NekDouble &time)
 
virtual SOLVER_UTILS_EXPORT void v_ALEPreMultiplyMass (Array< OneD, Array< OneD, NekDouble > > &fields)
 
SOLVER_UTILS_EXPORT void ALEDoElmtInvMass (Array< OneD, Array< OneD, NekDouble > > &traceNormals, Array< OneD, Array< OneD, NekDouble > > &fields, NekDouble time)
 Update m_fields with u^n by multiplying by inverse mass matrix. That's then used in e.g. checkpoint output and L^2 error calculation. More...
 
SOLVER_UTILS_EXPORT void ALEDoElmtInvMassBwdTrans (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
SOLVER_UTILS_EXPORT void MoveMesh (const NekDouble &time, Array< OneD, Array< OneD, NekDouble > > &traceNormals)
 
const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocity ()
 
SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocityTrace ()
 
SOLVER_UTILS_EXPORT void ExtraFldOutputGridVelocity (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
- Public Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual ~FluidInterface ()=default
 
SOLVER_UTILS_EXPORT void GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)
 Extract array with velocity from physfield. More...
 
SOLVER_UTILS_EXPORT bool HasConstantDensity ()
 
SOLVER_UTILS_EXPORT void GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density)
 Extract array with density from physfield. More...
 
SOLVER_UTILS_EXPORT void GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)
 Extract array with pressure from physfield. More...
 
SOLVER_UTILS_EXPORT void SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step)
 
SOLVER_UTILS_EXPORT bool GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step)
 
SOLVER_UTILS_EXPORT void SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step)
 
SOLVER_UTILS_EXPORT void SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot)
 
SOLVER_UTILS_EXPORT bool GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step)
 
SOLVER_UTILS_EXPORT void SetAeroForce (Array< OneD, NekDouble > forces)
 Set aerodynamic force and moment. More...
 
SOLVER_UTILS_EXPORT void GetAeroForce (Array< OneD, NekDouble > forces)
 Get aerodynamic force and moment. More...
 

Protected Member Functions

 CompressibleFlowSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 
 ~CompressibleFlowSystem () override=default
 
void v_InitObject (bool DeclareFields=true) override
 Initialization object for CompressibleFlowSystem class. More...
 
void v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure) override
 
void v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density) override
 
bool v_HasConstantDensity () override
 
void v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity) override
 
void v_ALEInitObject (int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields) override
 
void InitialiseParameters ()
 Load CFS parameters from the session file. More...
 
void InitAdvection ()
 Create advection and diffusion objects for CFS. More...
 
void DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Compute the right-hand side. More...
 
void DoOdeProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Compute the projection and call the method for imposing the boundary conditions in case of discontinuous projection. More...
 
void DoAdvection (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)
 Compute the advection terms for the right-hand side. More...
 
void DoDiffusion (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)
 Add the diffusions terms to the right-hand side. More...
 
void GetFluxVector (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &flux)
 Return the flux vector for the compressible Euler equations. More...
 
void GetFluxVectorDeAlias (const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &flux)
 Return the flux vector for the compressible Euler equations by using the de-aliasing technique. More...
 
void SetBoundaryConditions (Array< OneD, Array< OneD, NekDouble > > &physarray, NekDouble time)
 
void SetBoundaryConditionsBwdWeight ()
 Set up a weight on physical boundaries for boundary condition applications. More...
 
void GetElmtTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &tstep)
 Calculate the maximum timestep on each element subject to CFL restrictions. More...
 
NekDouble v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray) override
 Calculate the maximum timestep subject to CFL restrictions. More...
 
void v_GenerateSummary (SolverUtils::SummaryList &s) override
 Print a summary of time stepping parameters. More...
 
void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) override
 Set up logic for residual calculation. More...
 
void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time=0.0) override
 
NekDouble GetGamma ()
 
const Array< OneD, const Array< OneD, NekDouble > > & GetVecLocs ()
 
const Array< OneD, const Array< OneD, NekDouble > > & GetNormals ()
 
MultiRegions::ExpListSharedPtr v_GetPressure () override
 
void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables) override
 
virtual void v_DoDiffusion (const Array< OneD, Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const Array< OneD, Array< OneD, NekDouble > > &pFwd, const Array< OneD, Array< OneD, NekDouble > > &pBwd)=0
 
Array< OneD, NekDoublev_GetMaxStdVelocity (const NekDouble SpeedSoundFactor) override
 Compute the advection velocity in the standard space for each element of the expansion. More...
 
void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2) override
 
virtual bool v_SupportsShockCaptType (const std::string type) const =0
 
- Protected Member Functions inherited from Nektar::SolverUtils::AdvectionSystem
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Initialisation object for EquationSystem. More...
 
SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step) override
 
virtual SOLVER_UTILS_EXPORT Array< OneD, NekDoublev_GetMaxStdVelocity (const NekDouble SpeedSoundFactor=1.0)
 
- Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises UnsteadySystem class members. More...
 
SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareField=true) override
 Init object for UnsteadySystem class. More...
 
SOLVER_UTILS_EXPORT void v_DoSolve () override
 Solves an unsteady problem. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintStatusInformation (const int step, const NekDouble cpuTime)
 Print Status Information. More...
 
virtual SOLVER_UTILS_EXPORT void v_PrintSummaryStatistics (const NekDouble intTime)
 Print Summary Statistics. More...
 
SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true) override
 Sets up initial conditions. More...
 
SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &s) override
 Print a summary of time stepping parameters. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Return the timestep to be used for the next step in the time-marching loop. More...
 
virtual SOLVER_UTILS_EXPORT bool v_PreIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_PostIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_RequireFwdTrans ()
 
virtual SOLVER_UTILS_EXPORT void v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2)
 
virtual SOLVER_UTILS_EXPORT bool v_UpdateTimeStepCheck ()
 
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control. More...
 
SOLVER_UTILS_EXPORT void CheckForRestartTime (NekDouble &time, int &nchk)
 
SOLVER_UTILS_EXPORT void SVVVarDiffCoeff (const Array< OneD, Array< OneD, NekDouble > > vel, StdRegions::VarCoeffMap &varCoeffMap)
 Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h time velocity. More...
 
SOLVER_UTILS_EXPORT void DoDummyProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
 Perform dummy projection. More...
 
- Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
 Initialises EquationSystem class members. More...
 
virtual SOLVER_UTILS_EXPORT void v_InitObject (bool DeclareFeld=true)
 Initialisation object for EquationSystem. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoInitialise (bool dumpInitialConditions=true)
 Virtual function for initialisation implementation. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Virtual function for solve implementation. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Virtual function for the L_inf error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the L_2 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_H1Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the H_1 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys ()
 Virtual function for transformation to physical space. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space. More...
 
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary (SummaryList &l)
 Virtual function for generating summary information. More...
 
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure (void)
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp (void)
 Virtual function to identify if operator is negated in DoSolve. More...
 
virtual SOLVER_UTILS_EXPORT void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
- Protected Member Functions inherited from Nektar::SolverUtils::FluidInterface
virtual SOLVER_UTILS_EXPORT void v_GetVelocity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)=0
 
virtual SOLVER_UTILS_EXPORT bool v_HasConstantDensity ()=0
 
virtual SOLVER_UTILS_EXPORT void v_GetDensity (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &density)=0
 
virtual SOLVER_UTILS_EXPORT void v_GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)=0
 
virtual SOLVER_UTILS_EXPORT void v_SetMovingFrameVelocities (const Array< OneD, NekDouble > &vFrameVels, const int step)
 
virtual SOLVER_UTILS_EXPORT bool v_GetMovingFrameVelocities (Array< OneD, NekDouble > &vFrameVels, const int step)
 
virtual SOLVER_UTILS_EXPORT void v_SetMovingFrameDisp (const Array< OneD, NekDouble > &vFrameDisp, const int step)
 
virtual SOLVER_UTILS_EXPORT void v_SetMovingFramePivot (const Array< OneD, NekDouble > &vFramePivot)
 
virtual SOLVER_UTILS_EXPORT bool v_GetMovingFrameDisp (Array< OneD, NekDouble > &vFrameDisp, const int step)
 
virtual SOLVER_UTILS_EXPORT void v_SetAeroForce (Array< OneD, NekDouble > forces)
 
virtual SOLVER_UTILS_EXPORT void v_GetAeroForce (Array< OneD, NekDouble > forces)
 

Protected Attributes

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, NekDoublem_muav
 
Array< OneD, NekDoublem_muavTrace
 
VariableConverterSharedPtr m_varConv
 
std::vector< CFSBndCondSharedPtrm_bndConds
 
NekDouble m_bndEvaluateTime
 
std::vector< SolverUtils::ForcingSharedPtrm_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::SessionFunctionSharedPtrm_sessionFunctions
 Map of known SessionFunctions. More...
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output. More...
 
Array< OneD, MultiRegions::ExpListSharedPtrm_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, NekDoublem_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::ExpListSharedPtrm_fieldsALE
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocity
 
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
 
std::vector< ALEBaseShPtrm_ALEs
 
bool m_ALESolver = false
 
bool m_ImplicitALESolver = false
 
NekDouble m_prevStageTime = 0.0
 
int m_spaceDim
 

Private Member Functions

void EvaluateIsentropicVortex (unsigned int field, Array< OneD, NekDouble > &outfield, NekDouble time, const int o=0)
 Isentropic Vortex Test Case. More...
 
void GetExactRinglebFlow (int field, Array< OneD, NekDouble > &outarray)
 Ringleb Flow Test Case. More...
 

Friends

class MemoryManager< CompressibleFlowSystem >
 

Additional Inherited Members

- Static Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
static std::string cmdSetStartTime
 
static std::string cmdSetStartChkNum
 
- 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 56 of file CompressibleFlowSystem.h.

Constructor & Destructor Documentation

◆ CompressibleFlowSystem()

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

Definition at line 43 of file CompressibleFlowSystem.cpp.

46 : UnsteadySystem(pSession, pGraph), AdvectionSystem(pSession, pGraph)
47{
48}
SOLVER_UTILS_EXPORT AdvectionSystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.

◆ ~CompressibleFlowSystem()

Nektar::CompressibleFlowSystem::~CompressibleFlowSystem ( )
overrideprotecteddefault

Member Function Documentation

◆ DoAdvection()

void Nektar::CompressibleFlowSystem::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 
)
protected

Compute the advection terms for the right-hand side.

Definition at line 353 of file CompressibleFlowSystem.cpp.

358{
359 int nvariables = inarray.size();
360 Array<OneD, Array<OneD, NekDouble>> advVel(m_spacedim);
361
362 if (m_ALESolver)
363 {
364 auto advWeakDGObject =
365 std::dynamic_pointer_cast<SolverUtils::AdvectionWeakDG>(
367 advWeakDGObject->AdvectCoeffs(nvariables, m_fields, advVel, inarray,
368 outarray, time, pFwd, pBwd);
369 }
370 else
371 {
372 m_advObject->Advect(nvariables, m_fields, advVel, inarray, outarray,
373 time, pFwd, pBwd);
374 }
375}
SolverUtils::AdvectionSharedPtr m_advObject
Advection term.
int m_spacedim
Spatial dimension (>= expansion dim).
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.

References Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::ALEHelper::m_ALESolver, Nektar::SolverUtils::EquationSystem::m_fields, and Nektar::SolverUtils::EquationSystem::m_spacedim.

Referenced by DoOdeRhs().

◆ DoDiffusion()

void Nektar::CompressibleFlowSystem::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 
)
protected

Add the diffusions terms to the right-hand side.

Definition at line 380 of file CompressibleFlowSystem.cpp.

385{
386 v_DoDiffusion(inarray, outarray, pFwd, pBwd);
387}
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

References v_DoDiffusion().

Referenced by DoOdeRhs().

◆ DoOdeProjection()

void Nektar::CompressibleFlowSystem::DoOdeProjection ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protected

Compute the projection and call the method for imposing the boundary conditions in case of discontinuous projection.

Definition at line 306 of file CompressibleFlowSystem.cpp.

309{
310 size_t nvariables = inarray.size();
311
312 // Perform ALE movement
313 if (m_ALESolver)
314 {
316 }
317
318 switch (m_projectionType)
319 {
321 {
322 // Just copy over array
323 for (size_t i = 0; i < nvariables; ++i)
324 {
325 Vmath::Vcopy(inarray[i].size(), inarray[i], 1, outarray[i], 1);
326
327 if (m_useFiltering)
328 {
329 m_fields[i]->ExponentialFilter(outarray[i], m_filterAlpha,
332 }
333 }
334 SetBoundaryConditions(outarray, time);
335 break;
336 }
339 {
340 NEKERROR(ErrorUtil::efatal, "No Continuous Galerkin for full "
341 "compressible Navier-Stokes equations");
342 break;
343 }
344 default:
345 NEKERROR(ErrorUtil::efatal, "Unknown projection scheme");
346 break;
347 }
348}
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:202
void SetBoundaryConditions(Array< OneD, Array< OneD, NekDouble > > &physarray, NekDouble time)
SOLVER_UTILS_EXPORT void MoveMesh(const NekDouble &time, Array< OneD, Array< OneD, NekDouble > > &traceNormals)
Definition: ALEHelper.cpp:168
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
Array holding trace normals for DG simulations in the forwards direction.
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825

References Nektar::MultiRegions::eDiscontinuous, Nektar::ErrorUtil::efatal, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::ALEHelper::m_ALESolver, Nektar::SolverUtils::EquationSystem::m_fields, m_filterAlpha, m_filterCutoff, m_filterExponent, Nektar::SolverUtils::EquationSystem::m_projectionType, Nektar::SolverUtils::EquationSystem::m_traceNormals, m_useFiltering, Nektar::SolverUtils::ALEHelper::MoveMesh(), NEKERROR, SetBoundaryConditions(), and Vmath::Vcopy().

Referenced by Nektar::CFSImplicit::NonlinSysEvaluatorCoeff(), Nektar::CFSImplicit::PreconCoeff(), and v_InitObject().

◆ DoOdeRhs()

void Nektar::CompressibleFlowSystem::DoOdeRhs ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray,
const NekDouble  time 
)
protected

Compute the right-hand side.

Definition at line 212 of file CompressibleFlowSystem.cpp.

215{
216 LibUtilities::Timer timer;
217
218 size_t nvariables = inarray.size();
219 size_t nTracePts = GetTraceTotPoints();
220
221 // This converts our Mu in coefficient space to u in physical space for ALE
222 Array<OneD, Array<OneD, NekDouble>> tmpIn(nvariables);
223 if (m_ALESolver)
224 {
226 }
227 else
228 {
229 tmpIn = inarray;
230 }
231
232 m_bndEvaluateTime = time;
233
234 // Store forwards/backwards space along trace space
235 Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables);
236 Array<OneD, Array<OneD, NekDouble>> Bwd(nvariables);
237
239 {
242 }
243 else
244 {
245 for (size_t i = 0; i < nvariables; ++i)
246 {
247 Fwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
248 Bwd[i] = Array<OneD, NekDouble>(nTracePts, 0.0);
249 m_fields[i]->GetFwdBwdTracePhys(tmpIn[i], Fwd[i], Bwd[i]);
250 }
251 }
252
253 // Calculate advection
254 timer.Start();
255 DoAdvection(tmpIn, outarray, time, Fwd, Bwd);
256 timer.Stop();
257 timer.AccumulateRegion("DoAdvection");
258
259 // Negate results
260 for (size_t i = 0; i < nvariables; ++i)
261 {
262 Vmath::Neg(outarray[i].size(), outarray[i], 1);
263 }
264
265 // Add diffusion terms
266 timer.Start();
267 DoDiffusion(tmpIn, outarray, Fwd, Bwd);
268 timer.Stop();
269 timer.AccumulateRegion("DoDiffusion");
270
271 // Add forcing terms
272 for (auto &x : m_forcing)
273 {
274 x->Apply(m_fields, tmpIn, outarray, time);
275 }
276
278 {
279 size_t nElements = m_fields[0]->GetExpSize();
280 int nq, offset;
281 NekDouble fac;
282 Array<OneD, NekDouble> tmp;
283
284 Array<OneD, NekDouble> tstep(nElements, 0.0);
285 GetElmtTimeStep(tmpIn, tstep);
286
287 // Loop over elements
288 for (size_t n = 0; n < nElements; ++n)
289 {
290 nq = m_fields[0]->GetExp(n)->GetTotPoints();
291 offset = m_fields[0]->GetPhys_Offset(n);
292 fac = tstep[n] / m_timestep;
293 for (size_t i = 0; i < nvariables; ++i)
294 {
295 Vmath::Smul(nq, fac, outarray[i] + offset, 1,
296 tmp = outarray[i] + offset, 1);
297 }
298 }
299 }
300}
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.
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
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.
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.
SOLVER_UTILS_EXPORT void ALEDoElmtInvMassBwdTrans(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: ALEHelper.cpp:148
NekDouble m_timestep
Time step size.
enum HomogeneousType m_HomogeneousType
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
static Array< OneD, Array< OneD, NekDouble > > NullNekDoubleArrayOfArray
double NekDouble
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.hpp:292
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 Nektar::LibUtilities::Timer::AccumulateRegion(), Nektar::SolverUtils::ALEHelper::ALEDoElmtInvMassBwdTrans(), DoAdvection(), DoDiffusion(), Nektar::SolverUtils::EquationSystem::eHomogeneous1D, GetElmtTimeStep(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::ALEHelper::m_ALESolver, m_bndEvaluateTime, Nektar::SolverUtils::EquationSystem::m_fields, m_forcing, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, Nektar::SolverUtils::EquationSystem::m_timestep, m_useLocalTimeStep, Vmath::Neg(), Nektar::NullNekDoubleArrayOfArray, Vmath::Smul(), Nektar::LibUtilities::Timer::Start(), and Nektar::LibUtilities::Timer::Stop().

Referenced by v_InitObject(), and v_SteadyStateResidual().

◆ EvaluateIsentropicVortex()

void Nektar::CompressibleFlowSystem::EvaluateIsentropicVortex ( unsigned int  field,
Array< OneD, NekDouble > &  outfield,
NekDouble  time,
const int  o = 0 
)
private

Isentropic Vortex Test Case.

Definition at line 1115 of file CompressibleFlowSystem.cpp.

1118{
1119 NekDouble beta, u0, v0, x0, y0;
1120
1121 int nTotQuadPoints = GetTotPoints();
1122 Array<OneD, NekDouble> x(nTotQuadPoints);
1123 Array<OneD, NekDouble> y(nTotQuadPoints);
1124 Array<OneD, NekDouble> z(nTotQuadPoints);
1125 Array<OneD, Array<OneD, NekDouble>> u(m_spacedim + 2);
1126
1127 m_fields[0]->GetCoords(x, y, z);
1128
1129 for (int i = 0; i < m_spacedim + 2; ++i)
1130 {
1131 u[i] = Array<OneD, NekDouble>(nTotQuadPoints);
1132 }
1133 m_session->LoadParameter("IsentropicBeta", beta, 5.0);
1134 m_session->LoadParameter("IsentropicU0", u0, 1.0);
1135 m_session->LoadParameter("IsentropicV0", v0, 0.5);
1136 m_session->LoadParameter("IsentropicX0", x0, 5.0);
1137 m_session->LoadParameter("IsentropicY0", y0, 0.0);
1138
1139 // Flow parameters
1140 NekDouble r, xbar, ybar, tmp;
1141 NekDouble fac = 1.0 / (16.0 * m_gamma * M_PI * M_PI);
1142
1143 // In 3D zero rhow field.
1144 if (m_spacedim == 3)
1145 {
1146 Vmath::Zero(nTotQuadPoints, &u[3][o], 1);
1147 }
1148
1149 // Fill storage
1150 for (int i = 0; i < nTotQuadPoints; ++i)
1151 {
1152 xbar = x[i] - u0 * time - x0;
1153 ybar = y[i] - v0 * time - y0;
1154 r = sqrt(xbar * xbar + ybar * ybar);
1155 tmp = beta * exp(1 - r * r);
1156 u[0][i + o] =
1157 pow(1.0 - (m_gamma - 1.0) * tmp * tmp * fac, 1.0 / (m_gamma - 1.0));
1158 u[1][i + o] = u[0][i + o] * (u0 - tmp * ybar / (2 * M_PI));
1159 u[2][i + o] = u[0][i + o] * (v0 + tmp * xbar / (2 * M_PI));
1160 u[m_spacedim + 1][i + o] =
1161 pow(u[0][i + o], m_gamma) / (m_gamma - 1.0) +
1162 0.5 * (u[1][i + o] * u[1][i + o] + u[2][i + o] * u[2][i + o]) /
1163 u[0][i + o];
1164 }
1165 Vmath::Vcopy(nTotQuadPoints, u[field].data(), 1, outfield.data(), 1);
1166}
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
SOLVER_UTILS_EXPORT int GetTotPoints()
@ beta
Gauss Radau pinned at x=-1,.
Definition: PointsType.h:59
std::vector< double > z(NPUPPER)
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.hpp:273
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:285

References Nektar::LibUtilities::beta, FilterPython_Function::field, Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, m_gamma, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, tinysimd::sqrt(), Vmath::Vcopy(), Nektar::UnitTests::z(), and Vmath::Zero().

Referenced by v_EvaluateExactSolution(), and v_SetInitialConditions().

◆ GetElmtTimeStep()

void Nektar::CompressibleFlowSystem::GetElmtTimeStep ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray,
Array< OneD, NekDouble > &  tstep 
)
protected

Calculate the maximum timestep on each element subject to CFL restrictions.

Definition at line 614 of file CompressibleFlowSystem.cpp.

617{
618 size_t nElements = m_fields[0]->GetExpSize();
619
620 // Change value of m_timestep (in case it is set to zero)
621 NekDouble tmp = m_timestep;
622 m_timestep = 1.0;
623
624 Array<OneD, NekDouble> cfl(nElements);
625 cfl = GetElmtCFLVals();
626
627 // Factors to compute the time-step limit
629
630 // Loop over elements to compute the time-step limit for each element
631 for (size_t n = 0; n < nElements; ++n)
632 {
633 tstep[n] = m_cflSafetyFactor * alpha / cfl[n];
634 }
635
636 // Restore value of m_timestep
637 m_timestep = tmp;
638}
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > GetElmtCFLVals(const bool FlagAcousticCFL=true)
NekDouble m_cflSafetyFactor
CFL safety factor (comprise between 0 to 1).
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator()
Get the maximum timestep estimator for cfl control.

References Nektar::SolverUtils::AdvectionSystem::GetElmtCFLVals(), Nektar::SolverUtils::UnsteadySystem::m_cflSafetyFactor, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_timestep, and Nektar::SolverUtils::UnsteadySystem::MaxTimeStepEstimator().

Referenced by DoOdeRhs(), and v_GetTimeStep().

◆ GetExactRinglebFlow()

void Nektar::CompressibleFlowSystem::GetExactRinglebFlow ( int  field,
Array< OneD, NekDouble > &  outarray 
)
private

Ringleb Flow Test Case.

Compute the exact solution for the Ringleb flow problem.

Definition at line 1171 of file CompressibleFlowSystem.cpp.

1173{
1174 int nTotQuadPoints = GetTotPoints();
1175
1176 Array<OneD, NekDouble> rho(nTotQuadPoints, 100.0);
1177 Array<OneD, NekDouble> rhou(nTotQuadPoints);
1178 Array<OneD, NekDouble> rhov(nTotQuadPoints);
1179 Array<OneD, NekDouble> E(nTotQuadPoints);
1180 Array<OneD, NekDouble> x(nTotQuadPoints);
1181 Array<OneD, NekDouble> y(nTotQuadPoints);
1182 Array<OneD, NekDouble> z(nTotQuadPoints);
1183
1184 m_fields[0]->GetCoords(x, y, z);
1185
1186 // Flow parameters
1187 NekDouble c, k, phi, r, J, VV, pp, sint, P, ss;
1188 NekDouble J11, J12, J21, J22, det;
1189 NekDouble Fx, Fy;
1190 NekDouble xi, yi;
1191 NekDouble dV;
1192 NekDouble dtheta;
1193 NekDouble par1;
1194 NekDouble theta = M_PI / 4.0;
1195 NekDouble kExt = 0.7;
1196 NekDouble V = kExt * sin(theta);
1197 NekDouble toll = 1.0e-8;
1198 NekDouble errV = 1.0;
1199 NekDouble errTheta = 1.0;
1200 NekDouble gamma = m_gamma;
1201 NekDouble gamma_1_2 = (gamma - 1.0) / 2.0;
1202
1203 for (int i = 0; i < nTotQuadPoints; ++i)
1204 {
1205 while ((abs(errV) > toll) || (abs(errTheta) > toll))
1206 {
1207 VV = V * V;
1208 sint = sin(theta);
1209 c = sqrt(1.0 - gamma_1_2 * VV);
1210 k = V / sint;
1211 phi = 1.0 / k;
1212 pp = phi * phi;
1213 J = 1.0 / c + 1.0 / (3.0 * c * c * c) +
1214 1.0 / (5.0 * c * c * c * c * c) -
1215 0.5 * log((1.0 + c) / (1.0 - c));
1216
1217 r = pow(c, 1.0 / gamma_1_2);
1218 xi = 1.0 / (2.0 * r) * (1.0 / VV - 2.0 * pp) + J / 2.0;
1219 yi = phi / (r * V) * sqrt(1.0 - VV * pp);
1220 par1 = 25.0 - 5.0 * VV;
1221 ss = sint * sint;
1222
1223 Fx = xi - x[i];
1224 Fy = yi - y[i];
1225
1226 J11 =
1227 39062.5 / pow(par1, 3.5) * (1.0 / VV - 2.0 / VV * ss) * V +
1228 1562.5 / pow(par1, 2.5) *
1229 (-2.0 / (VV * V) + 4.0 / (VV * V) * ss) +
1230 12.5 / pow(par1, 1.5) * V + 312.5 / pow(par1, 2.5) * V +
1231 7812.5 / pow(par1, 3.5) * V -
1232 0.25 *
1233 (-1.0 / pow(par1, 0.5) * V / (1.0 - 0.2 * pow(par1, 0.5)) -
1234 (1.0 + 0.2 * pow(par1, 0.5)) /
1235 pow((1.0 - 0.2 * pow(par1, 0.5)), 2.0) /
1236 pow(par1, 0.5) * V) /
1237 (1.0 + 0.2 * pow(par1, 0.5)) * (1.0 - 0.2 * pow(par1, 0.5));
1238
1239 J12 = -6250.0 / pow(par1, 2.5) / VV * sint * cos(theta);
1240 J21 = -6250.0 / (VV * V) * sint / pow(par1, 2.5) *
1241 pow((1.0 - ss), 0.5) +
1242 78125.0 / V * sint / pow(par1, 3.5) * pow((1.0 - ss), 0.5);
1243
1244 // the matrix is singular when theta = pi/2
1245 if (abs(y[i]) < toll && abs(cos(theta)) < toll)
1246 {
1247 J22 = -39062.5 / pow(par1, 3.5) / V +
1248 3125 / pow(par1, 2.5) / (VV * V) +
1249 12.5 / pow(par1, 1.5) * V + 312.5 / pow(par1, 2.5) * V +
1250 7812.5 / pow(par1, 3.5) * V -
1251 0.25 *
1252 (-1.0 / pow(par1, 0.5) * V /
1253 (1.0 - 0.2 * pow(par1, 0.5)) -
1254 (1.0 + 0.2 * pow(par1, 0.5)) /
1255 pow((1.0 - 0.2 * pow(par1, 0.5)), 2.0) /
1256 pow(par1, 0.5) * V) /
1257 (1.0 + 0.2 * pow(par1, 0.5)) *
1258 (1.0 - 0.2 * pow(par1, 0.5));
1259
1260 // dV = -dV/dx * Fx
1261 dV = -1.0 / J22 * Fx;
1262 dtheta = 0.0;
1263 theta = M_PI / 2.0;
1264 }
1265 else
1266 {
1267 J22 = 3125.0 / VV * cos(theta) / pow(par1, 2.5) *
1268 pow((1.0 - ss), 0.5) -
1269 3125.0 / VV * ss / pow(par1, 2.5) / pow((1.0 - ss), 0.5) *
1270 cos(theta);
1271
1272 det = -1.0 / (J11 * J22 - J12 * J21);
1273
1274 // [dV dtheta]' = -[invJ]*[Fx Fy]'
1275 dV = det * (J22 * Fx - J12 * Fy);
1276 dtheta = det * (-J21 * Fx + J11 * Fy);
1277 }
1278
1279 V = V + dV;
1280 theta = theta + dtheta;
1281
1282 errV = abs(dV);
1283 errTheta = abs(dtheta);
1284 }
1285
1286 c = sqrt(1.0 - gamma_1_2 * VV);
1287 r = pow(c, 1.0 / gamma_1_2);
1288
1289 rho[i] = r;
1290 rhou[i] = rho[i] * V * cos(theta);
1291 rhov[i] = rho[i] * V * sin(theta);
1292 P = (c * c) * rho[i] / gamma;
1293 E[i] = P / (gamma - 1.0) +
1294 0.5 * (rhou[i] * rhou[i] / rho[i] + rhov[i] * rhov[i] / rho[i]);
1295
1296 // Resetting the guess value
1297 errV = 1.0;
1298 errTheta = 1.0;
1299 theta = M_PI / 4.0;
1300 V = kExt * sin(theta);
1301 }
1302
1303 switch (field)
1304 {
1305 case 0:
1306 outarray = rho;
1307 break;
1308 case 1:
1309 outarray = rhou;
1310 break;
1311 case 2:
1312 outarray = rhov;
1313 break;
1314 case 3:
1315 outarray = E;
1316 break;
1317 default:
1318 ASSERTL0(false, "Error in variable number!");
1319 break;
1320 }
1321}
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208
@ P
Monomial polynomials .
Definition: BasisType.h:62
scalarT< T > abs(scalarT< T > in)
Definition: scalar.hpp:289
scalarT< T > log(scalarT< T > in)
Definition: scalar.hpp:294

References tinysimd::abs(), ASSERTL0, FilterPython_Function::field, Nektar::SolverUtils::EquationSystem::GetTotPoints(), tinysimd::log(), Nektar::SolverUtils::EquationSystem::m_fields, m_gamma, Nektar::LibUtilities::P, tinysimd::sqrt(), and Nektar::UnitTests::z().

Referenced by v_EvaluateExactSolution().

◆ GetFluxVector()

void Nektar::CompressibleFlowSystem::GetFluxVector ( const Array< OneD, const Array< OneD, NekDouble > > &  physfield,
TensorOfArray3D< NekDouble > &  flux 
)
protected

Return the flux vector for the compressible Euler equations.

Parameters
physfieldFields.
fluxResulting flux.

Definition at line 445 of file CompressibleFlowSystem.cpp.

448{
449 size_t nVariables = physfield.size();
450 size_t nPts = physfield[0].size();
451
452 constexpr unsigned short maxVel = 3;
453 constexpr unsigned short maxFld = 5;
454
455 // hardcoding done for performance reasons
456 ASSERTL1(nVariables <= maxFld, "GetFluxVector, hard coded max fields");
457
458 for (size_t p = 0; p < nPts; ++p)
459 {
460 // local storage
461 std::array<NekDouble, maxFld> fieldTmp = {0};
462 std::array<NekDouble, maxVel> velocity = {0};
463
464 // rearrenge and load data
465 for (size_t f = 0; f < nVariables; ++f)
466 {
467 fieldTmp[f] = physfield[f][p]; // load
468 }
469
470 // 1 / rho
471 NekDouble oneOrho = 1.0 / fieldTmp[0];
472
473 for (size_t d = 0; d < m_spacedim; ++d)
474 {
475 // Flux vector for the rho equation
476 flux[0][d][p] = fieldTmp[d + 1]; // store
477 // compute velocity
478 velocity[d] = fieldTmp[d + 1] * oneOrho;
479 }
480
481 NekDouble pressure = m_varConv->GetPressure(fieldTmp.data());
482 NekDouble ePlusP = fieldTmp[m_spacedim + 1] + pressure;
483 for (size_t f = 0; f < m_spacedim; ++f)
484 {
485 // Flux vector for the velocity fields
486 for (size_t d = 0; d < m_spacedim; ++d)
487 {
488 flux[f + 1][d][p] = velocity[d] * fieldTmp[f + 1]; // store
489 }
490
491 // Add pressure to appropriate field
492 flux[f + 1][f][p] += pressure;
493
494 // Flux vector for energy
495 flux[m_spacedim + 1][f][p] = ePlusP * velocity[f]; // store
496 }
497 }
498
499 // @TODO : for each row (3 columns) negative grid velocity component (d * d
500 // + 2 (4 rows)) rho, rhou, rhov, rhow, E,
501 // @TODO : top row is flux for rho etc... each row subtract v_g * conserved
502 // variable for that row... For grid velocity subtract v_g * conserved
503 // variable
504 if (m_ALESolver)
505 {
506 for (int i = 0; i < m_spacedim + 2; ++i)
507 {
508 for (int j = 0; j < m_spacedim; ++j)
509 {
510 for (int k = 0; k < nPts; ++k)
511 {
512 flux[i][j][k] -= physfield[i][k] * m_gridVelocity[j][k];
513 }
514 }
515 }
516 }
517}
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:242
VariableConverterSharedPtr m_varConv
Array< OneD, Array< OneD, NekDouble > > m_gridVelocity
Definition: ALEHelper.h:89
std::vector< double > d(NPUPPER *NPUPPER)

References ASSERTL1, Nektar::UnitTests::d(), Nektar::SolverUtils::ALEHelper::m_ALESolver, Nektar::SolverUtils::ALEHelper::m_gridVelocity, Nektar::SolverUtils::EquationSystem::m_spacedim, m_varConv, CellMLToNektar.cellml_metadata::p, and CG_Iterations::pressure.

Referenced by InitAdvection().

◆ GetFluxVectorDeAlias()

void Nektar::CompressibleFlowSystem::GetFluxVectorDeAlias ( const Array< OneD, const Array< OneD, NekDouble > > &  physfield,
TensorOfArray3D< NekDouble > &  flux 
)
protected

Return the flux vector for the compressible Euler equations by using the de-aliasing technique.

Parameters
physfieldFields.
fluxResulting flux.

Definition at line 526 of file CompressibleFlowSystem.cpp.

529{
530 int i, j;
531 size_t nq = physfield[0].size();
532 size_t nVariables = m_fields.size();
533
534 // Factor to rescale 1d points in dealiasing
535 NekDouble OneDptscale = 2;
536 nq = m_fields[0]->Get1DScaledTotPoints(OneDptscale);
537
538 Array<OneD, NekDouble> pressure(nq);
539 Array<OneD, Array<OneD, NekDouble>> velocity(m_spacedim);
540
541 Array<OneD, Array<OneD, NekDouble>> physfield_interp(nVariables);
542 TensorOfArray3D<NekDouble> flux_interp(nVariables);
543
544 for (size_t i = 0; i < nVariables; ++i)
545 {
546 physfield_interp[i] = Array<OneD, NekDouble>(nq);
547 flux_interp[i] = Array<OneD, Array<OneD, NekDouble>>(m_spacedim);
548 m_fields[0]->PhysInterp1DScaled(OneDptscale, physfield[i],
549 physfield_interp[i]);
550
551 for (j = 0; j < m_spacedim; ++j)
552 {
553 flux_interp[i][j] = Array<OneD, NekDouble>(nq);
554 }
555 }
556
557 // Flux vector for the rho equation
558 for (i = 0; i < m_spacedim; ++i)
559 {
560 velocity[i] = Array<OneD, NekDouble>(nq);
561
562 // Galerkin project solution back to original space
563 m_fields[0]->PhysGalerkinProjection1DScaled(
564 OneDptscale, physfield_interp[i + 1], flux[0][i]);
565 }
566
567 m_varConv->GetVelocityVector(physfield_interp, velocity);
568 m_varConv->GetPressure(physfield_interp, pressure);
569
570 // Evaluation of flux vector for the velocity fields
571 for (i = 0; i < m_spacedim; ++i)
572 {
573 for (j = 0; j < m_spacedim; ++j)
574 {
575 Vmath::Vmul(nq, velocity[j], 1, physfield_interp[i + 1], 1,
576 flux_interp[i + 1][j], 1);
577 }
578
579 // Add pressure to appropriate field
580 Vmath::Vadd(nq, flux_interp[i + 1][i], 1, pressure, 1,
581 flux_interp[i + 1][i], 1);
582 }
583
584 // Galerkin project solution back to original space
585 for (i = 0; i < m_spacedim; ++i)
586 {
587 for (j = 0; j < m_spacedim; ++j)
588 {
589 m_fields[0]->PhysGalerkinProjection1DScaled(
590 OneDptscale, flux_interp[i + 1][j], flux[i + 1][j]);
591 }
592 }
593
594 // Evaluation of flux vector for energy
595 Vmath::Vadd(nq, physfield_interp[m_spacedim + 1], 1, pressure, 1, pressure,
596 1);
597
598 for (j = 0; j < m_spacedim; ++j)
599 {
600 Vmath::Vmul(nq, velocity[j], 1, pressure, 1,
601 flux_interp[m_spacedim + 1][j], 1);
602
603 // Galerkin project solution back to original space
604 m_fields[0]->PhysGalerkinProjection1DScaled(
605 OneDptscale, flux_interp[m_spacedim + 1][j],
606 flux[m_spacedim + 1][j]);
607 }
608}
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 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

References Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, m_varConv, CG_Iterations::pressure, Vmath::Vadd(), and Vmath::Vmul().

Referenced by InitAdvection().

◆ GetGamma()

NekDouble Nektar::CompressibleFlowSystem::GetGamma ( )
inlineprotected

Definition at line 182 of file CompressibleFlowSystem.h.

183 {
184 return m_gamma;
185 }

References m_gamma.

Referenced by InitAdvection().

◆ GetNormals()

const Array< OneD, const Array< OneD, NekDouble > > & Nektar::CompressibleFlowSystem::GetNormals ( )
inlineprotected

Definition at line 192 of file CompressibleFlowSystem.h.

193 {
194 return m_traceNormals;
195 }

References Nektar::SolverUtils::EquationSystem::m_traceNormals.

Referenced by InitAdvection().

◆ GetStabilityLimit()

NekDouble Nektar::CompressibleFlowSystem::GetStabilityLimit ( int  n)

Function to calculate the stability limit for DG/CG.

Set the denominator to compute the time step when a cfl control is employed. This function is no longer used but is still here for being utilised in the future.

Parameters
nOrder of expansion element by element.

Definition at line 908 of file CompressibleFlowSystem.cpp.

909{
910 ASSERTL0(n <= 20, "Illegal modes dimension for CFL calculation "
911 "(P has to be less then 20)");
912
913 NekDouble CFLDG[21] = {2.0000, 6.0000, 11.8424, 19.1569, 27.8419,
914 37.8247, 49.0518, 61.4815, 75.0797, 89.8181,
915 105.6700, 122.6200, 140.6400, 159.7300, 179.8500,
916 201.0100, 223.1800, 246.3600, 270.5300, 295.6900,
917 321.8300}; // CFLDG 1D [0-20]
918 NekDouble CFL = 0.0;
919
921 {
922 CFL = CFLDG[n];
923 }
924 else
925 {
926 NEKERROR(ErrorUtil::efatal, "Continuous Galerkin stability "
927 "coefficients not introduced yet.");
928 }
929
930 return CFL;
931}

References ASSERTL0, Nektar::MultiRegions::eDiscontinuous, Nektar::ErrorUtil::efatal, Nektar::SolverUtils::EquationSystem::m_projectionType, and NEKERROR.

Referenced by GetStabilityLimitVector().

◆ GetStabilityLimitVector()

Array< OneD, NekDouble > Nektar::CompressibleFlowSystem::GetStabilityLimitVector ( const Array< OneD, int > &  ExpOrder)

Function to calculate the stability limit for DG/CG (a vector of them).

Compute the vector of denominators to compute the time step when a cfl control is employed. This function is no longer used but is still here for being utilised in the future.

Parameters
ExpOrderOrder of expansion element by element.

Definition at line 940 of file CompressibleFlowSystem.cpp.

942{
943 int i;
944 Array<OneD, NekDouble> returnval(m_fields[0]->GetExpSize(), 0.0);
945 for (i = 0; i < m_fields[0]->GetExpSize(); i++)
946 {
947 returnval[i] = GetStabilityLimit(ExpOrder[i]);
948 }
949 return returnval;
950}
NekDouble GetStabilityLimit(int n)
Function to calculate the stability limit for DG/CG.
SOLVER_UTILS_EXPORT int GetExpSize()

References Nektar::SolverUtils::EquationSystem::GetExpSize(), GetStabilityLimit(), and Nektar::SolverUtils::EquationSystem::m_fields.

◆ GetVecLocs()

const Array< OneD, const Array< OneD, NekDouble > > & Nektar::CompressibleFlowSystem::GetVecLocs ( )
inlineprotected

Definition at line 187 of file CompressibleFlowSystem.h.

188 {
189 return m_vecLocs;
190 }
Array< OneD, Array< OneD, NekDouble > > m_vecLocs

References m_vecLocs.

Referenced by InitAdvection().

◆ InitAdvection()

void Nektar::CompressibleFlowSystem::InitAdvection ( )
protected

Create advection and diffusion objects for CFS.

Definition at line 164 of file CompressibleFlowSystem.cpp.

165{
166 // Check if projection type is correct
168 "Unsupported projection type.");
169
170 std::string advName, riemName;
171 m_session->LoadSolverInfo("AdvectionType", advName, "WeakDG");
172
175
177 {
178 m_advObject->SetFluxVector(
180 }
181 else
182 {
184 this);
185 }
186
187 // Setting up Riemann solver for advection operator
188 m_session->LoadSolverInfo("UpwindType", riemName, "Average");
189
192 riemName, m_session);
193
194 // Tell Riemann Solver if doing ALE and provide trace grid velocity
195 riemannSolver->SetALEFlag(m_ALESolver);
196 riemannSolver->SetVector("vgt", &ALEHelper::GetGridVelocityTrace, this);
197
198 // Setting up parameters for advection operator Riemann solver
199 riemannSolver->SetParam("gamma", &CompressibleFlowSystem::GetGamma, this);
200 riemannSolver->SetAuxVec("vecLocs", &CompressibleFlowSystem::GetVecLocs,
201 this);
202 riemannSolver->SetVector("N", &CompressibleFlowSystem::GetNormals, this);
203
204 // Concluding initialisation of advection / diffusion operators
205 m_advObject->SetRiemannSolver(riemannSolver);
206 m_advObject->InitObject(m_session, m_fields);
207}
void GetFluxVector(const Array< OneD, const Array< OneD, NekDouble > > &physfield, TensorOfArray3D< NekDouble > &flux)
Return the flux vector for the compressible Euler equations.
const Array< OneD, const Array< OneD, NekDouble > > & GetNormals()
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.
const Array< OneD, const Array< OneD, NekDouble > > & GetVecLocs()
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
SOLVER_UTILS_EXPORT const Array< OneD, const Array< OneD, NekDouble > > & GetGridVelocityTrace()
Definition: ALEHelper.cpp:289
bool m_specHP_dealiasing
Flag to determine if dealisising is usde for the Spectral/hp element discretisation.
std::shared_ptr< RiemannSolver > RiemannSolverSharedPtr
A shared pointer to an EquationSystem object.
AdvectionFactory & GetAdvectionFactory()
Gets the factory for initialising advection objects.
Definition: Advection.cpp:43
RiemannSolverFactory & GetRiemannSolverFactory()

References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::MultiRegions::eDiscontinuous, Nektar::SolverUtils::GetAdvectionFactory(), GetFluxVector(), GetFluxVectorDeAlias(), GetGamma(), Nektar::SolverUtils::ALEHelper::GetGridVelocityTrace(), GetNormals(), Nektar::SolverUtils::GetRiemannSolverFactory(), GetVecLocs(), Nektar::SolverUtils::AdvectionSystem::m_advObject, Nektar::SolverUtils::ALEHelper::m_ALESolver, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_projectionType, Nektar::SolverUtils::EquationSystem::m_session, and Nektar::SolverUtils::EquationSystem::m_specHP_dealiasing.

Referenced by v_InitObject().

◆ InitialiseParameters()

void Nektar::CompressibleFlowSystem::InitialiseParameters ( )
protected

Load CFS parameters from the session file.

Definition at line 128 of file CompressibleFlowSystem.cpp.

129{
130 // Get gamma parameter from session file.
131 m_session->LoadParameter("Gamma", m_gamma, 1.4);
132
133 // Shock capture
134 m_session->LoadSolverInfo("ShockCaptureType", m_shockCaptureType, "Off");
135
136 // Check if the shock capture type is supported
137 std::string err_msg = "Warning, ShockCaptureType = " + m_shockCaptureType +
138 " is not supported by this solver";
140
141 // Load parameters for exponential filtering
142 m_session->MatchSolverInfo("ExponentialFiltering", "True", m_useFiltering,
143 false);
144 if (m_useFiltering)
145 {
146 m_session->LoadParameter("FilterAlpha", m_filterAlpha, 36);
147 m_session->LoadParameter("FilterExponent", m_filterExponent, 16);
148 m_session->LoadParameter("FilterCutoff", m_filterCutoff, 0);
149 }
150
151 // Load CFL for local time-stepping (for steady state)
152 m_session->MatchSolverInfo("LocalTimeStep", "True", m_useLocalTimeStep,
153 false);
155 {
157 "Local time stepping requires CFL parameter.");
158 }
159}
virtual bool v_SupportsShockCaptType(const std::string type) const =0

References ASSERTL0, Nektar::SolverUtils::UnsteadySystem::m_cflSafetyFactor, m_filterAlpha, m_filterCutoff, m_filterExponent, m_gamma, Nektar::SolverUtils::EquationSystem::m_session, m_shockCaptureType, m_useFiltering, m_useLocalTimeStep, and v_SupportsShockCaptType().

Referenced by v_InitObject().

◆ SetBoundaryConditions()

void Nektar::CompressibleFlowSystem::SetBoundaryConditions ( Array< OneD, Array< OneD, NekDouble > > &  physarray,
NekDouble  time 
)
protected

Definition at line 389 of file CompressibleFlowSystem.cpp.

391{
392 size_t nTracePts = GetTraceTotPoints();
393 size_t nvariables = physarray.size();
394
395 // This converts our Mu in coefficient space to u in physical space for ALE
396 Array<OneD, Array<OneD, NekDouble>> tmpIn(nvariables);
397
399 {
400 ALEHelper::ALEDoElmtInvMassBwdTrans(physarray, tmpIn);
401 }
402 else
403 {
404 tmpIn = physarray;
405 }
406
407 Array<OneD, Array<OneD, NekDouble>> Fwd(nvariables);
408 for (size_t i = 0; i < nvariables; ++i)
409 {
410 Fwd[i] = Array<OneD, NekDouble>(nTracePts);
411 m_fields[i]->ExtractTracePhys(tmpIn[i], Fwd[i]);
412 }
413
414 if (!m_bndConds.empty())
415 {
416 // Loop over user-defined boundary conditions
417 for (auto &x : m_bndConds)
418 {
419 x->Apply(Fwd, tmpIn, time);
420 }
421 }
422}
std::vector< CFSBndCondSharedPtr > m_bndConds

References Nektar::SolverUtils::ALEHelper::ALEDoElmtInvMassBwdTrans(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::ALEHelper::m_ALESolver, m_bndConds, Nektar::SolverUtils::EquationSystem::m_fields, and Nektar::SolverUtils::ALEHelper::m_ImplicitALESolver.

Referenced by DoOdeProjection().

◆ SetBoundaryConditionsBwdWeight()

void Nektar::CompressibleFlowSystem::SetBoundaryConditionsBwdWeight ( )
protected

Set up a weight on physical boundaries for boundary condition applications.

Definition at line 427 of file CompressibleFlowSystem.cpp.

428{
429 if (m_bndConds.size())
430 {
431 // Loop over user-defined boundary conditions
432 for (auto &x : m_bndConds)
433 {
434 x->ApplyBwdWeight();
435 }
436 }
437}

References m_bndConds.

Referenced by Nektar::NavierStokesCFE::InitObject_Explicit(), and v_InitObject().

◆ v_ALEInitObject()

void Nektar::CompressibleFlowSystem::v_ALEInitObject ( int  spaceDim,
Array< OneD, MultiRegions::ExpListSharedPtr > &  fields 
)
overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::ALEHelper.

Reimplemented in Nektar::CFSImplicit.

Definition at line 1323 of file CompressibleFlowSystem.cpp.

1325{
1326 m_spaceDim = spaceDim;
1327 m_fieldsALE = fields;
1328
1329 // Initialise grid velocities as 0s
1330 m_gridVelocity = Array<OneD, Array<OneD, NekDouble>>(m_spaceDim);
1331 m_gridVelocityTrace = Array<OneD, Array<OneD, NekDouble>>(m_spaceDim);
1332 for (int i = 0; i < spaceDim; ++i)
1333 {
1334 m_gridVelocity[i] =
1335 Array<OneD, NekDouble>(fields[0]->GetTotPoints(), 0.0);
1337 Array<OneD, NekDouble>(fields[0]->GetTrace()->GetTotPoints(), 0.0);
1338 }
1339
1340 ALEHelper::InitObject(spaceDim, fields);
1341}
Array< OneD, MultiRegions::ExpListSharedPtr > m_fieldsALE
Definition: ALEHelper.h:88
SOLVER_UTILS_EXPORT void InitObject(int spaceDim, Array< OneD, MultiRegions::ExpListSharedPtr > &fields)
Definition: ALEHelper.cpp:48
Array< OneD, Array< OneD, NekDouble > > m_gridVelocityTrace
Definition: ALEHelper.h:90

References Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::ALEHelper::InitObject(), Nektar::SolverUtils::ALEHelper::m_fieldsALE, Nektar::SolverUtils::ALEHelper::m_gridVelocity, Nektar::SolverUtils::ALEHelper::m_gridVelocityTrace, and Nektar::SolverUtils::ALEHelper::m_spaceDim.

◆ v_DoDiffusion()

virtual void Nektar::CompressibleFlowSystem::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 
)
protectedpure virtual

◆ v_EvaluateExactSolution()

void Nektar::CompressibleFlowSystem::v_EvaluateExactSolution ( unsigned int  field,
Array< OneD, NekDouble > &  outfield,
const NekDouble  time = 0.0 
)
overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 747 of file CompressibleFlowSystem.cpp.

749{
750
751 if (!m_session->DefinesFunction("ExactSolution") &&
752 m_session->DefinesSolverInfo("ICTYPE"))
753 {
754 if (boost::iequals(m_session->GetSolverInfo("ICTYPE"),
755 "IsentropicVortex"))
756 {
757 EvaluateIsentropicVortex(field, outfield, time);
758 }
759 else if (boost::iequals(m_session->GetSolverInfo("ICTYPE"),
760 "RinglebFlow"))
761 {
762 GetExactRinglebFlow(field, outfield);
763 }
764 }
765 else
766 {
768 }
769}
void GetExactRinglebFlow(int field, Array< OneD, NekDouble > &outarray)
Ringleb Flow Test Case.
void EvaluateIsentropicVortex(unsigned int field, Array< OneD, NekDouble > &outfield, NekDouble time, const int o=0)
Isentropic Vortex Test Case.
virtual SOLVER_UTILS_EXPORT void v_EvaluateExactSolution(unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)

References EvaluateIsentropicVortex(), FilterPython_Function::field, GetExactRinglebFlow(), Nektar::SolverUtils::EquationSystem::m_session, and Nektar::SolverUtils::EquationSystem::v_EvaluateExactSolution().

◆ v_ExtraFldOutput()

void Nektar::CompressibleFlowSystem::v_ExtraFldOutput ( std::vector< Array< OneD, NekDouble > > &  fieldcoeffs,
std::vector< std::string > &  variables 
)
overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::EquationSystem.

Reimplemented in Nektar::NavierStokesCFE.

Definition at line 952 of file CompressibleFlowSystem.cpp.

955{
956 bool extraFields;
957 m_session->MatchSolverInfo("OutputExtraFields", "True", extraFields, true);
958 if (extraFields)
959 {
960 const int nPhys = m_fields[0]->GetNpoints();
961 const int nCoeffs = m_fields[0]->GetNcoeffs();
962 Array<OneD, Array<OneD, NekDouble>> tmp(m_fields.size());
963
964 for (int i = 0; i < m_fields.size(); ++i)
965 {
966 tmp[i] = m_fields[i]->GetPhys();
967 }
968
969 Array<OneD, Array<OneD, NekDouble>> velocity(m_spacedim);
970 Array<OneD, Array<OneD, NekDouble>> velFwd(m_spacedim);
971 for (int i = 0; i < m_spacedim; ++i)
972 {
973 velocity[i] = Array<OneD, NekDouble>(nPhys);
974 velFwd[i] = Array<OneD, NekDouble>(nCoeffs);
975 }
976
977 Array<OneD, NekDouble> pressure(nPhys), temperature(nPhys);
978 Array<OneD, NekDouble> entropy(nPhys);
979 Array<OneD, NekDouble> soundspeed(nPhys), mach(nPhys);
980 Array<OneD, NekDouble> sensor(nPhys), SensorKappa(nPhys);
981
982 m_varConv->GetVelocityVector(tmp, velocity);
983 m_varConv->GetPressure(tmp, pressure);
984 m_varConv->GetTemperature(tmp, temperature);
985 m_varConv->GetEntropy(tmp, entropy);
986 m_varConv->GetSoundSpeed(tmp, soundspeed);
987 m_varConv->GetMach(tmp, soundspeed, mach);
988
989 int sensorOffset;
990 m_session->LoadParameter("SensorOffset", sensorOffset, 1);
991 m_varConv->GetSensor(m_fields[0], tmp, sensor, SensorKappa,
992 sensorOffset);
993
994 Array<OneD, NekDouble> pFwd(nCoeffs), TFwd(nCoeffs);
995 Array<OneD, NekDouble> sFwd(nCoeffs);
996 Array<OneD, NekDouble> aFwd(nCoeffs), mFwd(nCoeffs);
997 Array<OneD, NekDouble> sensFwd(nCoeffs);
998
999 std::string velNames[3] = {"u", "v", "w"};
1000 for (int i = 0; i < m_spacedim; ++i)
1001 {
1002 m_fields[0]->FwdTransLocalElmt(velocity[i], velFwd[i]);
1003 variables.push_back(velNames[i]);
1004 fieldcoeffs.push_back(velFwd[i]);
1005 }
1006
1007 m_fields[0]->FwdTransLocalElmt(pressure, pFwd);
1008 m_fields[0]->FwdTransLocalElmt(temperature, TFwd);
1009 m_fields[0]->FwdTransLocalElmt(entropy, sFwd);
1010 m_fields[0]->FwdTransLocalElmt(soundspeed, aFwd);
1011 m_fields[0]->FwdTransLocalElmt(mach, mFwd);
1012 m_fields[0]->FwdTransLocalElmt(sensor, sensFwd);
1013
1014 variables.push_back("p");
1015 variables.push_back("T");
1016 variables.push_back("s");
1017 variables.push_back("a");
1018 variables.push_back("Mach");
1019 variables.push_back("Sensor");
1020 fieldcoeffs.push_back(pFwd);
1021 fieldcoeffs.push_back(TFwd);
1022 fieldcoeffs.push_back(sFwd);
1023 fieldcoeffs.push_back(aFwd);
1024 fieldcoeffs.push_back(mFwd);
1025 fieldcoeffs.push_back(sensFwd);
1026
1028 {
1029 // reuse pressure
1030 Array<OneD, NekDouble> sensorFwd(nCoeffs);
1031 m_artificialDiffusion->GetArtificialViscosity(tmp, pressure);
1032 m_fields[0]->FwdTransLocalElmt(pressure, sensorFwd);
1033
1034 variables.push_back("ArtificialVisc");
1035 fieldcoeffs.push_back(sensorFwd);
1036 }
1037
1038 if (m_ALESolver)
1039 {
1040 ExtraFldOutputGridVelocity(fieldcoeffs, variables);
1041 }
1042 }
1043}
ArtificialDiffusionSharedPtr m_artificialDiffusion
SOLVER_UTILS_EXPORT void ExtraFldOutputGridVelocity(std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
Definition: ALEHelper.cpp:389

References Nektar::SolverUtils::ALEHelper::ExtraFldOutputGridVelocity(), Nektar::SolverUtils::ALEHelper::m_ALESolver, m_artificialDiffusion, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, m_varConv, and CG_Iterations::pressure.

◆ v_GenerateSummary()

void Nektar::CompressibleFlowSystem::v_GenerateSummary ( SolverUtils::SummaryList s)
overrideprotectedvirtual

Print a summary of time stepping parameters.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 658 of file CompressibleFlowSystem.cpp.

659{
661 if (m_session->DefinesSolverInfo("ICTYPE"))
662 {
663 if (boost::iequals(m_session->GetSolverInfo("ICTYPE"),
664 "IsentropicVortex"))
665 {
666 SolverUtils::AddSummaryItem(s, "Problem Type", "IsentropicVortex");
667 }
668 else if (boost::iequals(m_session->GetSolverInfo("ICTYPE"),
669 "RinglebFlow"))
670 {
671 SolverUtils::AddSummaryItem(s, "Problem Type", "RinglebFlow");
672 }
673 else
674 {
675 NEKERROR(ErrorUtil::efatal, "unknow initial condition");
676 }
677 }
678}
SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s) override
Print a summary of time stepping parameters.
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
Definition: Misc.cpp:47

References Nektar::SolverUtils::AddSummaryItem(), Nektar::ErrorUtil::efatal, Nektar::SolverUtils::EquationSystem::m_session, NEKERROR, and Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary().

◆ v_GetDensity()

void Nektar::CompressibleFlowSystem::v_GetDensity ( const Array< OneD, const Array< OneD, NekDouble > > &  physfield,
Array< OneD, NekDouble > &  density 
)
overrideprotectedvirtual

Implements Nektar::SolverUtils::FluidInterface.

Definition at line 1058 of file CompressibleFlowSystem.cpp.

1061{
1062 density = physfield[0];
1063}

◆ v_GetMaxStdVelocity()

Array< OneD, NekDouble > Nektar::CompressibleFlowSystem::v_GetMaxStdVelocity ( const NekDouble  SpeedSoundFactor)
overrideprotectedvirtual

Compute the advection velocity in the standard space for each element of the expansion.

Reimplemented from Nektar::SolverUtils::AdvectionSystem.

Definition at line 775 of file CompressibleFlowSystem.cpp.

777{
778 size_t nTotQuadPoints = GetTotPoints();
779 size_t n_element = m_fields[0]->GetExpSize();
780 size_t expdim = m_fields[0]->GetGraph()->GetMeshDimension();
781 size_t nfields = m_fields.size();
782 int offset;
783 Array<OneD, NekDouble> tmp;
784
785 Array<OneD, Array<OneD, NekDouble>> physfields(nfields);
786 for (size_t i = 0; i < nfields; ++i)
787 {
788 physfields[i] = m_fields[i]->GetPhys();
789 }
790
791 Array<OneD, NekDouble> stdV(n_element, 0.0);
792
793 // Getting the velocity vector on the 2D normal space
794 Array<OneD, Array<OneD, NekDouble>> velocity(m_spacedim);
795 Array<OneD, Array<OneD, NekDouble>> stdVelocity(m_spacedim);
796 Array<OneD, Array<OneD, NekDouble>> stdSoundSpeed(m_spacedim);
797 Array<OneD, NekDouble> soundspeed(nTotQuadPoints);
799
800 for (int i = 0; i < m_spacedim; ++i)
801 {
802 velocity[i] = Array<OneD, NekDouble>(nTotQuadPoints);
803 stdVelocity[i] = Array<OneD, NekDouble>(nTotQuadPoints, 0.0);
804 stdSoundSpeed[i] = Array<OneD, NekDouble>(nTotQuadPoints, 0.0);
805 }
806
807 m_varConv->GetVelocityVector(physfields, velocity);
808 m_varConv->GetSoundSpeed(physfields, soundspeed);
809
810 // Subtract Ug from the velocity for the ALE formulation
811 for (size_t i = 0; i < m_spacedim; ++i)
812 {
813 Vmath::Vsub(nTotQuadPoints, velocity[i], 1, m_gridVelocity[i], 1,
814 velocity[i], 1);
815 }
816
817 for (int el = 0; el < n_element; ++el)
818 {
819 ptsKeys = m_fields[0]->GetExp(el)->GetPointsKeys();
820 offset = m_fields[0]->GetPhys_Offset(el);
821 int nq = m_fields[0]->GetExp(el)->GetTotPoints();
822
823 const SpatialDomains::GeomFactorsSharedPtr metricInfo =
824 m_fields[0]->GetExp(el)->GetGeom()->GetMetricInfo();
825 const Array<TwoD, const NekDouble> &gmat =
826 m_fields[0]
827 ->GetExp(el)
828 ->GetGeom()
829 ->GetMetricInfo()
830 ->GetDerivFactors(ptsKeys);
831
832 // Convert to standard element
833 // consider soundspeed in all directions
834 // (this might overestimate the cfl)
835 if (metricInfo->GetGtype() == SpatialDomains::eDeformed)
836 {
837 // d xi/ dx = gmat = 1/J * d x/d xi
838 for (size_t i = 0; i < expdim; ++i)
839 {
840 Vmath::Vmul(nq, gmat[i], 1, velocity[0] + offset, 1,
841 tmp = stdVelocity[i] + offset, 1);
842 Vmath::Vmul(nq, gmat[i], 1, soundspeed + offset, 1,
843 tmp = stdSoundSpeed[i] + offset, 1);
844 for (size_t j = 1; j < expdim; ++j)
845 {
846 Vmath::Vvtvp(nq, gmat[expdim * j + i], 1,
847 velocity[j] + offset, 1,
848 stdVelocity[i] + offset, 1,
849 tmp = stdVelocity[i] + offset, 1);
850 Vmath::Vvtvp(nq, gmat[expdim * j + i], 1,
851 soundspeed + offset, 1,
852 stdSoundSpeed[i] + offset, 1,
853 tmp = stdSoundSpeed[i] + offset, 1);
854 }
855 }
856 }
857 else
858 {
859 for (size_t i = 0; i < expdim; ++i)
860 {
861 Vmath::Smul(nq, gmat[i][0], velocity[0] + offset, 1,
862 tmp = stdVelocity[i] + offset, 1);
863 Vmath::Smul(nq, gmat[i][0], soundspeed + offset, 1,
864 tmp = stdSoundSpeed[i] + offset, 1);
865 for (size_t j = 1; j < expdim; ++j)
866 {
867 Vmath::Svtvp(nq, gmat[expdim * j + i][0],
868 velocity[j] + offset, 1,
869 stdVelocity[i] + offset, 1,
870 tmp = stdVelocity[i] + offset, 1);
871 Vmath::Svtvp(nq, gmat[expdim * j + i][0],
872 soundspeed + offset, 1,
873 stdSoundSpeed[i] + offset, 1,
874 tmp = stdSoundSpeed[i] + offset, 1);
875 }
876 }
877 }
878
879 NekDouble vel;
880 for (size_t i = 0; i < nq; ++i)
881 {
882 NekDouble pntVelocity = 0.0;
883 for (size_t j = 0; j < expdim; ++j)
884 {
885 // Add sound speed
886 vel = std::abs(stdVelocity[j][offset + i]) +
887 SpeedSoundFactor * std::abs(stdSoundSpeed[j][offset + i]);
888 pntVelocity += vel * vel;
889 }
890 pntVelocity = sqrt(pntVelocity);
891 if (pntVelocity > stdV[el])
892 {
893 stdV[el] = pntVelocity;
894 }
895 }
896 }
897
898 return stdV;
899}
std::vector< PointsKey > PointsKeyVector
Definition: Points.h:231
std::shared_ptr< GeomFactors > GeomFactorsSharedPtr
Pointer to a GeomFactors object.
Definition: GeomFactors.h:60
@ eDeformed
Geometry is curved or has non-constant factors.
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Svtvp (scalar times vector plus vector): z = alpha*x + y.
Definition: Vmath.hpp:396
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 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 tinysimd::abs(), Nektar::SpatialDomains::eDeformed, Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::ALEHelper::m_gridVelocity, Nektar::SolverUtils::EquationSystem::m_spacedim, m_varConv, Vmath::Smul(), tinysimd::sqrt(), Vmath::Svtvp(), Vmath::Vmul(), Vmath::Vsub(), and Vmath::Vvtvp().

◆ v_GetPressure() [1/2]

MultiRegions::ExpListSharedPtr Nektar::CompressibleFlowSystem::v_GetPressure ( void  )
inlineoverrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 197 of file CompressibleFlowSystem.h.

198 {
199 ASSERTL0(false, "This function is not valid for this class");
201 return null;
202 }
std::shared_ptr< ExpList > ExpListSharedPtr
Shared pointer to an ExpList object.

References ASSERTL0.

◆ v_GetPressure() [2/2]

void Nektar::CompressibleFlowSystem::v_GetPressure ( const Array< OneD, const Array< OneD, NekDouble > > &  physfield,
Array< OneD, NekDouble > &  pressure 
)
overrideprotectedvirtual

Implements Nektar::SolverUtils::FluidInterface.

Definition at line 1048 of file CompressibleFlowSystem.cpp.

1051{
1052 m_varConv->GetPressure(physfield, pressure);
1053}

References m_varConv, and CG_Iterations::pressure.

◆ v_GetTimeStep()

NekDouble Nektar::CompressibleFlowSystem::v_GetTimeStep ( const Array< OneD, const Array< OneD, NekDouble > > &  inarray)
overrideprotectedvirtual

Calculate the maximum timestep subject to CFL restrictions.

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 643 of file CompressibleFlowSystem.cpp.

645{
646 int nElements = m_fields[0]->GetExpSize();
647 Array<OneD, NekDouble> tstep(nElements, 0.0);
648
649 GetElmtTimeStep(inarray, tstep);
650
651 // Get the minimum time-step limit and return the time-step
652 NekDouble TimeStep = Vmath::Vmin(nElements, tstep, 1);
653 m_comm->GetSpaceComm()->AllReduce(TimeStep, LibUtilities::ReduceMin);
654
655 return TimeStep;
656}
LibUtilities::CommSharedPtr m_comm
Communicator.
T Vmin(int n, const T *x, const int incx)
Return the minimum element in x - called vmin to avoid conflict with min.
Definition: Vmath.hpp:725

References GetElmtTimeStep(), Nektar::SolverUtils::EquationSystem::m_comm, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::LibUtilities::ReduceMin, and Vmath::Vmin().

◆ v_GetVelocity()

void Nektar::CompressibleFlowSystem::v_GetVelocity ( const Array< OneD, const Array< OneD, NekDouble > > &  physfield,
Array< OneD, Array< OneD, NekDouble > > &  velocity 
)
overrideprotectedvirtual

Implements Nektar::SolverUtils::FluidInterface.

Definition at line 1068 of file CompressibleFlowSystem.cpp.

1071{
1072 m_varConv->GetVelocityVector(physfield, velocity);
1073}

References m_varConv.

◆ v_HasConstantDensity()

bool Nektar::CompressibleFlowSystem::v_HasConstantDensity ( )
inlineoverrideprotectedvirtual

Implements Nektar::SolverUtils::FluidInterface.

Definition at line 118 of file CompressibleFlowSystem.h.

119 {
120 return false;
121 }

◆ v_InitObject()

void Nektar::CompressibleFlowSystem::v_InitObject ( bool  DeclareFields = true)
overrideprotectedvirtual

Initialization object for CompressibleFlowSystem class.

Reimplemented from Nektar::SolverUtils::AdvectionSystem.

Reimplemented in Nektar::NavierStokesCFE, Nektar::CFSImplicit, Nektar::EulerCFE, Nektar::EulerImplicitCFE, Nektar::NavierStokesCFEAxisym, and Nektar::NavierStokesImplicitCFE.

Definition at line 53 of file CompressibleFlowSystem.cpp.

54{
55 AdvectionSystem::v_InitObject(DeclareFields);
56
57 for (size_t i = 0; i < m_fields.size(); i++)
58 {
59 // Use BwdTrans to make sure initial condition is in solution space
60 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
61 m_fields[i]->UpdatePhys());
62 }
63
66
67 ASSERTL0(m_session->DefinesSolverInfo("UPWINDTYPE"),
68 "No UPWINDTYPE defined in session.");
69
70 // Do not forwards transform initial condition
71 m_homoInitialFwd = false;
72
73 // Set up locations of velocity vector.
74 m_vecLocs = Array<OneD, Array<OneD, NekDouble>>(1);
75 m_vecLocs[0] = Array<OneD, NekDouble>(m_spacedim);
76 for (int i = 0; i < m_spacedim; ++i)
77 {
78 m_vecLocs[0][i] = 1 + i;
79 }
80
81 // Loading parameters from session file
83
84 // Setting up advection and diffusion operators
86
87 // Create artificial diffusion with laplacian operator
88 if (m_shockCaptureType == "NonSmooth")
89 {
92 }
93
94 // Forcing terms for the sponge region
96 m_fields, m_fields.size());
97
98 // User-defined boundary conditions
99 size_t cnt = 0;
100 for (size_t n = 0; n < (size_t)m_fields[0]->GetBndConditions().size(); ++n)
101 {
102 std::string type = m_fields[0]->GetBndConditions()[n]->GetUserDefined();
103
104 if (m_fields[0]->GetBndConditions()[n]->GetBoundaryConditionType() ==
106 {
107 continue;
108 }
109
110 if (!type.empty())
111 {
114 m_spacedim, n, cnt));
115 }
116 cnt += m_fields[0]->GetBndCondExpansions()[n]->GetExpSize();
117 }
118
121
123}
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 discontinu...
void InitAdvection()
Create advection and diffusion objects for CFS.
void SetBoundaryConditionsBwdWeight()
Set up a weight on physical boundaries for boundary condition applications.
void InitialiseParameters()
Load CFS parameters from the session file.
void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Compute the right-hand side.
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
SOLVER_UTILS_EXPORT void v_InitObject(bool DeclareField=true) override
Initialisation object for EquationSystem.
SpatialDomains::MeshGraphSharedPtr m_graph
Pointer to graph defining mesh.
static SOLVER_UTILS_EXPORT std::vector< ForcingSharedPtr > Load(const LibUtilities::SessionReaderSharedPtr &pSession, const std::weak_ptr< EquationSystem > &pEquation, const Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const unsigned int &pNumForcingFields=0)
Definition: Forcing.cpp:76
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
bool m_homoInitialFwd
Flag to determine if simulation should start in homogeneous forward transformed state.
CFSBndCondFactory & GetCFSBndCondFactory()
Declaration of the boundary condition factory singleton.
Definition: CFSBndCond.cpp:40
ArtificialDiffusionFactory & GetArtificialDiffusionFactory()
Declaration of the artificial diffusion factory singleton.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), DoOdeProjection(), DoOdeRhs(), Nektar::SpatialDomains::ePeriodic, Nektar::GetArtificialDiffusionFactory(), Nektar::GetCFSBndCondFactory(), InitAdvection(), InitialiseParameters(), Nektar::SolverUtils::Forcing::Load(), m_artificialDiffusion, m_bndConds, Nektar::SolverUtils::EquationSystem::m_fields, m_forcing, Nektar::SolverUtils::EquationSystem::m_graph, Nektar::SolverUtils::ALEHelper::m_gridVelocityTrace, Nektar::SolverUtils::UnsteadySystem::m_homoInitialFwd, Nektar::SolverUtils::UnsteadySystem::m_ode, Nektar::SolverUtils::EquationSystem::m_session, m_shockCaptureType, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::SolverUtils::EquationSystem::m_traceNormals, m_varConv, m_vecLocs, SetBoundaryConditionsBwdWeight(), and Nektar::SolverUtils::AdvectionSystem::v_InitObject().

Referenced by Nektar::NavierStokesCFE::v_InitObject(), Nektar::CFSImplicit::v_InitObject(), and Nektar::EulerCFE::v_InitObject().

◆ v_SetInitialConditions()

void Nektar::CompressibleFlowSystem::v_SetInitialConditions ( NekDouble  initialtime = 0.0,
bool  dumpInitialConditions = true,
const int  domain = 0 
)
overrideprotectedvirtual

Set up logic for residual calculation.

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 683 of file CompressibleFlowSystem.cpp.

686{
687 if (m_session->DefinesSolverInfo("ICTYPE") &&
688 boost::iequals(m_session->GetSolverInfo("ICTYPE"), "IsentropicVortex"))
689 {
690 // Forward transform to fill the coefficient space
691 for (int i = 0; i < m_fields.size(); ++i)
692 {
693 EvaluateIsentropicVortex(i, m_fields[i]->UpdatePhys(), initialtime);
694 m_fields[i]->SetPhysState(true);
695 m_fields[i]->FwdTrans(m_fields[i]->GetPhys(),
696 m_fields[i]->UpdateCoeffs());
697 }
698 }
699 else
700 {
701 EquationSystem::v_SetInitialConditions(initialtime, false);
702 m_nchk--; // Note: m_nchk has been incremented in EquationSystem.
703
704 // insert white noise in initial condition
705 NekDouble Noise;
706 int phystot = m_fields[0]->GetTotPoints();
707 Array<OneD, NekDouble> noise(phystot);
708
709 m_session->LoadParameter("Noise", Noise, 0.0);
710 int m_nConvectiveFields = m_fields.size();
711
712 if (Noise > 0.0)
713 {
714 int seed = -m_comm->GetSpaceComm()->GetRank() * m_nConvectiveFields;
715 for (int i = 0; i < m_nConvectiveFields; i++)
716 {
717 Vmath::FillWhiteNoise(phystot, Noise, noise, 1, seed);
718 --seed;
719 Vmath::Vadd(phystot, m_fields[i]->GetPhys(), 1, noise, 1,
720 m_fields[i]->UpdatePhys(), 1);
721 m_fields[i]->FwdTransLocalElmt(m_fields[i]->GetPhys(),
722 m_fields[i]->UpdateCoeffs());
723 }
724 }
725 }
726
727 if (dumpInitialConditions && m_nchk == 0 && m_checksteps &&
728 !m_comm->IsParallelInTime())
729 {
731 }
732 else if (dumpInitialConditions && m_nchk == 0 && m_comm->IsParallelInTime())
733 {
734 std::string newdir = m_sessionName + ".pit";
735 if (!fs::is_directory(newdir))
736 {
737 fs::create_directory(newdir);
738 }
739 if (m_comm->GetTimeComm()->GetRank() == 0)
740 {
741 WriteFld(newdir + "/" + m_sessionName + "_0.fld");
742 }
743 }
744 m_nchk++;
745}
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
SOLVER_UTILS_EXPORT void Checkpoint_Output(const int n)
Write checkpoint file of m_fields.
SOLVER_UTILS_EXPORT void WriteFld(const std::string &outname)
Write field data to the given filename.
std::string m_sessionName
Name of the session.
int m_nchk
Number of checkpoints written so far.
int m_checksteps
Number of steps between checkpoints.
void FillWhiteNoise(int n, const T eps, T *x, const int incx, int outseed)
Fills a vector with white noise.
Definition: Vmath.cpp:154

References Nektar::SolverUtils::EquationSystem::Checkpoint_Output(), EvaluateIsentropicVortex(), Vmath::FillWhiteNoise(), Nektar::SolverUtils::EquationSystem::m_checksteps, Nektar::SolverUtils::EquationSystem::m_comm, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_nchk, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_sessionName, Nektar::SolverUtils::EquationSystem::v_SetInitialConditions(), Vmath::Vadd(), and Nektar::SolverUtils::EquationSystem::WriteFld().

◆ v_SteadyStateResidual()

void Nektar::CompressibleFlowSystem::v_SteadyStateResidual ( int  step,
Array< OneD, NekDouble > &  L2 
)
overrideprotectedvirtual

Reimplemented from Nektar::SolverUtils::UnsteadySystem.

Definition at line 1075 of file CompressibleFlowSystem.cpp.

1077{
1078 const size_t nPoints = GetTotPoints();
1079 const size_t nFields = m_fields.size();
1080 Array<OneD, Array<OneD, NekDouble>> rhs(nFields);
1081 Array<OneD, Array<OneD, NekDouble>> inarray(nFields);
1082 for (size_t i = 0; i < nFields; ++i)
1083 {
1084 rhs[i] = Array<OneD, NekDouble>(nPoints, 0.0);
1085 inarray[i] = m_fields[i]->UpdatePhys();
1086 }
1087
1088 DoOdeRhs(inarray, rhs, m_time);
1089
1090 // Holds L2 errors.
1091 Array<OneD, NekDouble> tmp;
1092 Array<OneD, NekDouble> RHSL2(nFields);
1093 Array<OneD, NekDouble> residual(nFields);
1094
1095 for (size_t i = 0; i < nFields; ++i)
1096 {
1097 tmp = rhs[i];
1098
1099 Vmath::Vmul(nPoints, tmp, 1, tmp, 1, tmp, 1);
1100 residual[i] = Vmath::Vsum(nPoints, tmp, 1);
1101 }
1102
1103 m_comm->GetSpaceComm()->AllReduce(residual, LibUtilities::ReduceSum);
1104
1105 NekDouble onPoints = 1.0 / NekDouble(nPoints);
1106 for (size_t i = 0; i < nFields; ++i)
1107 {
1108 L2[i] = sqrt(residual[i] * onPoints);
1109 }
1110}
NekDouble m_time
Current time of simulation.
T Vsum(int n, const T *x, const int incx)
Subtract return sum(x)
Definition: Vmath.hpp:608

References DoOdeRhs(), Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_comm, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_time, Nektar::LibUtilities::ReduceSum, tinysimd::sqrt(), Vmath::Vmul(), and Vmath::Vsum().

◆ v_SupportsShockCaptType()

virtual bool Nektar::CompressibleFlowSystem::v_SupportsShockCaptType ( const std::string  type) const
protectedpure virtual

Friends And Related Function Documentation

◆ MemoryManager< CompressibleFlowSystem >

friend class MemoryManager< CompressibleFlowSystem >
friend

Definition at line 1 of file CompressibleFlowSystem.h.

Member Data Documentation

◆ m_artificialDiffusion

ArtificialDiffusionSharedPtr Nektar::CompressibleFlowSystem::m_artificialDiffusion
protected

◆ m_bndConds

std::vector<CFSBndCondSharedPtr> Nektar::CompressibleFlowSystem::m_bndConds
protected

◆ m_bndEvaluateTime

NekDouble Nektar::CompressibleFlowSystem::m_bndEvaluateTime
protected

◆ m_diffusion

SolverUtils::DiffusionSharedPtr Nektar::CompressibleFlowSystem::m_diffusion
protected

◆ m_filterAlpha

NekDouble Nektar::CompressibleFlowSystem::m_filterAlpha
protected

Definition at line 78 of file CompressibleFlowSystem.h.

Referenced by DoOdeProjection(), and InitialiseParameters().

◆ m_filterCutoff

NekDouble Nektar::CompressibleFlowSystem::m_filterCutoff
protected

Definition at line 80 of file CompressibleFlowSystem.h.

Referenced by DoOdeProjection(), and InitialiseParameters().

◆ m_filterExponent

NekDouble Nektar::CompressibleFlowSystem::m_filterExponent
protected

Definition at line 79 of file CompressibleFlowSystem.h.

Referenced by DoOdeProjection(), and InitialiseParameters().

◆ m_forcing

std::vector<SolverUtils::ForcingSharedPtr> Nektar::CompressibleFlowSystem::m_forcing
protected

◆ m_gamma

NekDouble Nektar::CompressibleFlowSystem::m_gamma
protected

◆ m_muav

Array<OneD, NekDouble> Nektar::CompressibleFlowSystem::m_muav
protected

Definition at line 87 of file CompressibleFlowSystem.h.

◆ m_muavTrace

Array<OneD, NekDouble> Nektar::CompressibleFlowSystem::m_muavTrace
protected

Definition at line 90 of file CompressibleFlowSystem.h.

◆ m_shockCaptureType

std::string Nektar::CompressibleFlowSystem::m_shockCaptureType
protected

◆ m_useFiltering

bool Nektar::CompressibleFlowSystem::m_useFiltering
protected

Definition at line 81 of file CompressibleFlowSystem.h.

Referenced by DoOdeProjection(), and InitialiseParameters().

◆ m_useLocalTimeStep

bool Nektar::CompressibleFlowSystem::m_useLocalTimeStep
protected

◆ m_varConv

VariableConverterSharedPtr Nektar::CompressibleFlowSystem::m_varConv
protected

◆ m_vecLocs

Array<OneD, Array<OneD, NekDouble> > Nektar::CompressibleFlowSystem::m_vecLocs
protected

Definition at line 73 of file CompressibleFlowSystem.h.

Referenced by GetVecLocs(), and v_InitObject().