Nektar++
Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Private Member Functions | Friends | List of all members
Nektar::EulerCFE Class Reference

#include <EulerCFE.h>

Inheritance diagram for Nektar::EulerCFE:
Inheritance graph
[legend]
Collaboration diagram for Nektar::EulerCFE:
Collaboration graph
[legend]

Public Member Functions

virtual ~EulerCFE ()
 problem type selector More...
 
- Public Member Functions inherited from Nektar::CompressibleFlowSystem
virtual ~CompressibleFlowSystem ()
 Destructor for CompressibleFlowSystem class. More...
 
NekDouble GetStabilityLimit (int n)
 Function to calculate the stability limit for DG/CG. More...
 
Array< OneD, NekDouble > GetStabilityLimitVector (const Array< OneD, int > &ExpOrder)
 Function to calculate the stability limit for DG/CG (a vector of them). More...
 
- Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
virtual SOLVER_UTILS_EXPORT ~UnsteadySystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
 Calculate the larger time-step mantaining the problem stable. More...
 
- Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT ~EquationSystem ()
 Destructor. More...
 
SOLVER_UTILS_EXPORT void SetUpTraceNormals (void)
 
SOLVER_UTILS_EXPORT void InitObject ()
 Initialises the members of this object. More...
 
SOLVER_UTILS_EXPORT void DoInitialise ()
 Perform any initialisation necessary before solving the problem. More...
 
SOLVER_UTILS_EXPORT void DoSolve ()
 Solve the problem. More...
 
SOLVER_UTILS_EXPORT void TransCoeffToPhys ()
 Transform from coefficient to physical space. More...
 
SOLVER_UTILS_EXPORT void TransPhysToCoeff ()
 Transform from physical to coefficient space. More...
 
SOLVER_UTILS_EXPORT void Output ()
 Perform output operations after solve. More...
 
SOLVER_UTILS_EXPORT NekDouble LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Linf error computation. More...
 
SOLVER_UTILS_EXPORT std::string GetSessionName ()
 Get Session name. More...
 
template<class T >
boost::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 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 void EvaluateFunction (Array< OneD, Array< OneD, NekDouble > > &pArray, std::string pFunctionName, const NekDouble pTime=0.0, const int domain=0)
 Evaluates a function as specified in the session file. More...
 
SOLVER_UTILS_EXPORT void EvaluateFunction (std::vector< std::string > pFieldNames, Array< OneD, Array< OneD, NekDouble > > &pFields, const std::string &pName, const int domain=0)
 Populate given fields with the function from session. More...
 
SOLVER_UTILS_EXPORT void EvaluateFunction (std::vector< std::string > pFieldNames, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields, const std::string &pName, const int domain=0)
 Populate given fields with the function from session. More...
 
SOLVER_UTILS_EXPORT void EvaluateFunction (std::string pFieldName, Array< OneD, NekDouble > &pArray, const std::string &pFunctionName, const NekDouble &pTime=0.0, const int domain=0)
 
SOLVER_UTILS_EXPORT std::string DescribeFunction (std::string pFieldName, const std::string &pFunctionName, const int domain)
 Provide a description of a function for a given field name. More...
 
SOLVER_UTILS_EXPORT void InitialiseBaseFlow (Array< OneD, Array< OneD, NekDouble > > &base)
 Perform initialisation of the base flow. More...
 
SOLVER_UTILS_EXPORT void SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Initialise the data in the dependent fields. More...
 
SOLVER_UTILS_EXPORT void EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
 Evaluates an exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln, bool Normalised=false)
 Compute the L2 error between fields and a given exact solution. More...
 
SOLVER_UTILS_EXPORT NekDouble L2Error (unsigned int field, bool Normalised=false)
 Compute the L2 error of the fields. More...
 
SOLVER_UTILS_EXPORT Array< OneD, NekDouble > ErrorExtraPoints (unsigned int field)
 Compute error (L2 and L_inf) over an larger set of quadrature points return [L2 Linf]. More...
 
SOLVER_UTILS_EXPORT void WeakAdvectionGreensDivergenceForm (const Array< OneD, Array< OneD, NekDouble > > &F, Array< OneD, NekDouble > &outarray)
 Compute the inner product $ (\nabla \phi \cdot F) $. More...
 
SOLVER_UTILS_EXPORT void WeakAdvectionDivergenceForm (const Array< OneD, Array< OneD, NekDouble > > &F, Array< OneD, NekDouble > &outarray)
 Compute the inner product $ (\phi, \nabla \cdot F) $. More...
 
SOLVER_UTILS_EXPORT void WeakAdvectionNonConservativeForm (const Array< OneD, Array< OneD, NekDouble > > &V, const Array< OneD, const NekDouble > &u, Array< OneD, NekDouble > &outarray, bool UseContCoeffs=false)
 Compute the inner product $ (\phi, V\cdot \nabla u) $. More...
 
f SOLVER_UTILS_EXPORT void AdvectionNonConservativeForm (const Array< OneD, Array< OneD, NekDouble > > &V, const Array< OneD, const NekDouble > &u, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wk=NullNekDouble1DArray)
 Compute the non-conservative advection. More...
 
SOLVER_UTILS_EXPORT void WeakDGAdvection (const Array< OneD, Array< OneD, NekDouble > > &InField, Array< OneD, Array< OneD, NekDouble > > &OutField, bool NumericalFluxIncludesNormal=true, bool InFieldIsInPhysSpace=false, int nvariables=0)
 Calculate the weak discontinuous Galerkin advection. More...
 
SOLVER_UTILS_EXPORT void WeakDGDiffusion (const Array< OneD, Array< OneD, NekDouble > > &InField, Array< OneD, Array< OneD, NekDouble > > &OutField, bool NumericalFluxIncludesNormal=true, bool InFieldIsInPhysSpace=false)
 Calculate weak DG Diffusion in the LDG form. 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 ScanForHistoryPoints ()
 Builds map of which element holds each history point. More...
 
SOLVER_UTILS_EXPORT void WriteHistoryData (std::ostream &out)
 Probe each history point and write to file. More...
 
SOLVER_UTILS_EXPORT void SessionSummary (SummaryList &vSummary)
 Write out a session summary. More...
 
SOLVER_UTILS_EXPORT Array< OneD, MultiRegions::ExpListSharedPtr > & UpdateFields ()
 
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMap & UpdateFieldMetaDataMap ()
 Get hold of FieldInfoMap so it can be updated. More...
 
SOLVER_UTILS_EXPORT NekDouble GetFinalTime ()
 Return final time. More...
 
SOLVER_UTILS_EXPORT int GetNcoeffs ()
 
SOLVER_UTILS_EXPORT int GetNcoeffs (const int eid)
 
SOLVER_UTILS_EXPORT int GetNumExpModes ()
 
SOLVER_UTILS_EXPORT const Array< OneD, int > GetNumExpModesPerExp ()
 
SOLVER_UTILS_EXPORT int GetNvariables ()
 
SOLVER_UTILS_EXPORT const std::string GetVariable (unsigned int i)
 
SOLVER_UTILS_EXPORT int GetTraceTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTraceNpoints ()
 
SOLVER_UTILS_EXPORT int GetExpSize ()
 
SOLVER_UTILS_EXPORT int GetPhys_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetCoeff_Offset (int n)
 
SOLVER_UTILS_EXPORT int GetTotPoints ()
 
SOLVER_UTILS_EXPORT int GetTotPoints (int n)
 
SOLVER_UTILS_EXPORT int GetNpoints ()
 
SOLVER_UTILS_EXPORT int GetNumElmVelocity ()
 
SOLVER_UTILS_EXPORT int GetSteps ()
 
SOLVER_UTILS_EXPORT NekDouble GetTimeStep ()
 
SOLVER_UTILS_EXPORT void CopyFromPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void CopyToPhysField (const int i, Array< OneD, NekDouble > &output)
 
SOLVER_UTILS_EXPORT void SetStepsToOne ()
 
SOLVER_UTILS_EXPORT void ZeroPhysFields ()
 
SOLVER_UTILS_EXPORT void FwdTransFields ()
 
SOLVER_UTILS_EXPORT void GetFluxVector (const int i, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)
 
SOLVER_UTILS_EXPORT void GetFluxVector (const int i, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &fluxX, Array< OneD, Array< OneD, NekDouble > > &fluxY)
 
SOLVER_UTILS_EXPORT void GetFluxVector (const int i, const int j, Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &flux)
 
SOLVER_UTILS_EXPORT void NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numflux)
 
SOLVER_UTILS_EXPORT void NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxX, Array< OneD, Array< OneD, NekDouble > > &numfluxY)
 
SOLVER_UTILS_EXPORT void NumFluxforScalar (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &uflux)
 
SOLVER_UTILS_EXPORT void NumFluxforVector (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &qfield, Array< OneD, Array< OneD, NekDouble > > &qflux)
 
SOLVER_UTILS_EXPORT void SetModifiedBasis (const bool modbasis)
 
SOLVER_UTILS_EXPORT int NoCaseStringCompare (const string &s1, const string &s2)
 Perform a case-insensitive string comparison. More...
 
virtual SOLVER_UTILS_EXPORT bool v_NegatedOp ()
 Virtual function to identify if operator is negated in DoSolve. More...
 

Static Public Member Functions

static SolverUtils::EquationSystemSharedPtr create (const LibUtilities::SessionReaderSharedPtr &pSession)
 Creates an instance of this class. More...
 
- Static Public Member Functions inherited from Nektar::CompressibleFlowSystem
static SolverUtils::EquationSystemSharedPtr create (const LibUtilities::SessionReaderSharedPtr &pSession)
 Creates an instance of this class. More...
 

Public Attributes

ProblemType m_problemType
 
- Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem
NekDouble m_cflSafetyFactor
 CFL safety factor (comprise between 0 to 1). More...
 

Static Public Attributes

static std::string className
 Name of class. More...
 
- Static Public Attributes inherited from Nektar::CompressibleFlowSystem
static std::string className
 Name of class. More...
 

Protected Member Functions

 EulerCFE (const LibUtilities::SessionReaderSharedPtr &pSession)
 
virtual void v_InitObject ()
 Initialization object for CompressibleFlowSystem class. More...
 
virtual void v_GenerateSummary (SolverUtils::SummaryList &s)
 Print a summary of time stepping parameters. 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...
 
virtual void v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
 Set the initial conditions. More...
 
virtual void v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time=0.0)
 Get the exact solutions for isentropic vortex and Ringleb flow problems. More...
 
- Protected Member Functions inherited from Nektar::CompressibleFlowSystem
 CompressibleFlowSystem (const LibUtilities::SessionReaderSharedPtr &pSession)
 
void GetFluxVector (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
 Return the flux vector for the compressible Euler equations. More...
 
void GetFluxVectorDeAlias (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
 Return the flux vector for the compressible Euler equations by using the de-aliasing technique. More...
 
void GetViscousFluxVector (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &derivatives, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &viscousTensor)
 Return the flux vector for the LDG diffusion problem. More...
 
void GetFluxVectorPDESC (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &flux)
 
void GetViscousFluxVectorDeAlias (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &derivatives, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &viscousTensor)
 Return the flux vector for the LDG diffusion problem. More...
 
void SetCommonBC (const std::string &userDefStr, const int n, const NekDouble time, int &cnt, Array< OneD, Array< OneD, NekDouble > > &inarray)
 Set boundary conditions which can be: a) Wall and Symmerty BCs implemented at CompressibleFlowSystem level since they are compressible solver specific; b) Time dependent BCs. More...
 
void WallBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Wall boundary conditions for compressible flow problems. More...
 
void WallViscousBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Wall boundary conditions for viscous compressible flow problems. More...
 
void SymmetryBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Symmetry boundary conditions for compressible flow problems. More...
 
void RiemannInvariantBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Outflow characteristic boundary conditions for compressible flow problems. More...
 
void PressureOutflowNonReflectiveBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Pressure outflow non-reflective boundary conditions for compressible flow problems. More...
 
void PressureOutflowBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Pressure outflow boundary conditions for compressible flow problems. More...
 
void PressureOutflowFileBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Pressure outflow boundary conditions for compressible flow problems. More...
 
void PressureInflowFileBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Pressure inflow boundary conditions for compressible flow problems where either the density and the velocities are assigned from a file or the full state is assigned from a file (depending on the problem type, either subsonic or supersonic). More...
 
void ExtrapOrder0BC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Extrapolation of order 0 for all the variables such that, at the boundaries, a trivial Riemann problem is solved. More...
 
void GetVelocityVector (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &velocity)
 
void GetSoundSpeed (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure, Array< OneD, NekDouble > &soundspeed)
 
void GetMach (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &soundspeed, Array< OneD, NekDouble > &mach)
 
void GetTemperature (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure, Array< OneD, NekDouble > &temperature)
 
void GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure)
 Calculate the pressure field $ p = (\gamma-1)(E-\frac{1}{2}\rho\| \mathbf{v} \|^2) $ assuming an ideal gas law. More...
 
void GetPressure (const Array< OneD, const Array< OneD, NekDouble > > &physfield, const Array< OneD, const Array< OneD, NekDouble > > &velocity, Array< OneD, NekDouble > &pressure)
 
void GetEnthalpy (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &pressure, Array< OneD, NekDouble > &enthalpy)
 
void GetEntropy (const Array< OneD, const Array< OneD, NekDouble > > &physfield, const Array< OneD, const NekDouble > &pressure, const Array< OneD, const NekDouble > &temperature, Array< OneD, NekDouble > &entropy)
 
void GetSmoothArtificialViscosity (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &eps_bar)
 
void GetDynamicViscosity (const Array< OneD, const NekDouble > &temperature, Array< OneD, NekDouble > &mu)
 
void GetStdVelocity (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &stdV)
 
virtual bool v_PostIntegrate (int step)
 
bool CalcSteadyState (bool output)
 
void GetSensor (const Array< OneD, const Array< OneD, NekDouble > > &physarray, Array< OneD, NekDouble > &Sensor, Array< OneD, NekDouble > &SensorKappa)
 
void GetElementDimensions (Array< OneD, Array< OneD, NekDouble > > &outarray, Array< OneD, NekDouble > &hmin)
 
void GetAbsoluteVelocity (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, NekDouble > &Vtot)
 
void GetArtificialDynamicViscosity (const Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &mu_var)
 
void SetVarPOrderElmt (const Array< OneD, const Array< OneD, NekDouble > > &physfield, Array< OneD, NekDouble > &PolyOrder)
 
void GetForcingTerm (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > outarrayForcing)
 
virtual 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...
 
NekDouble GetGasConstant ()
 
NekDouble GetGamma ()
 
const Array< OneD, const Array< OneD, NekDouble > > & GetVecLocs ()
 
const Array< OneD, const Array< OneD, NekDouble > > & GetNormals ()
 
virtual void v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables)
 
- Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
SOLVER_UTILS_EXPORT UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession)
 Initialises UnsteadySystem class members. More...
 
SOLVER_UTILS_EXPORT NekDouble MaxTimeStepEstimator ()
 Get the maximum timestep estimator for cfl control. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoSolve ()
 Solves an unsteady problem. More...
 
virtual SOLVER_UTILS_EXPORT void v_DoInitialise ()
 Sets up initial conditions. More...
 
virtual SOLVER_UTILS_EXPORT void v_AppendOutput1D (Array< OneD, Array< OneD, NekDouble > > &solution1D)
 Print the solution at each solution point in a txt file. More...
 
virtual SOLVER_UTILS_EXPORT void v_NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numflux)
 
virtual SOLVER_UTILS_EXPORT void v_NumericalFlux (Array< OneD, Array< OneD, NekDouble > > &physfield, Array< OneD, Array< OneD, NekDouble > > &numfluxX, Array< OneD, Array< OneD, NekDouble > > &numfluxY)
 
virtual SOLVER_UTILS_EXPORT void v_NumFluxforScalar (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &uflux)
 
virtual SOLVER_UTILS_EXPORT void v_NumFluxforVector (const Array< OneD, Array< OneD, NekDouble > > &ufield, Array< OneD, Array< OneD, Array< OneD, NekDouble > > > &qfield, Array< OneD, Array< OneD, NekDouble > > &qflux)
 
virtual SOLVER_UTILS_EXPORT bool v_PreIntegrate (int step)
 
virtual SOLVER_UTILS_EXPORT bool v_SteadyStateCheck (int step)
 
SOLVER_UTILS_EXPORT void CheckForRestartTime (NekDouble &time)
 
- Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem
SOLVER_UTILS_EXPORT EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession)
 Initialises EquationSystem class members. More...
 
int nocase_cmp (const string &s1, const string &s2)
 
SOLVER_UTILS_EXPORT void SetBoundaryConditions (NekDouble time)
 Evaluates the boundary conditions at the given time. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
 Virtual function for the L_inf error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT NekDouble v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false)
 Virtual function for the L_2 error computation between fields and a given exact solution. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransCoeffToPhys ()
 Virtual function for transformation to physical space. More...
 
virtual SOLVER_UTILS_EXPORT void v_TransPhysToCoeff ()
 Virtual function for transformation to coefficient space. More...
 
SOLVER_UTILS_EXPORT void SetUpBaseFields (SpatialDomains::MeshGraphSharedPtr &mesh)
 
SOLVER_UTILS_EXPORT void ImportFldBase (std::string pInfile, SpatialDomains::MeshGraphSharedPtr pGraph)
 
virtual SOLVER_UTILS_EXPORT void v_Output (void)
 
virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr v_GetPressure (void)
 

Private Member Functions

void SetBoundaryConditions (Array< OneD, Array< OneD, NekDouble > > &physarray, NekDouble time)
 Set boundary conditions which can be: a) Wall and Symmerty BCs implemented at CompressibleFlowSystem level since they are compressible solver specific; b) Isentropic vortex and Ringleb flow BCs implemented at EulerCFE level since they are Euler solver specific; c) Time dependent BCs. More...
 
void EvaluateIsentropicVortex (const Array< OneD, NekDouble > &x, const Array< OneD, NekDouble > &y, const Array< OneD, NekDouble > &z, Array< OneD, Array< OneD, NekDouble > > &u, NekDouble time, const int o=0)
 Isentropic Vortex Test Case. More...
 
void GetExactIsentropicVortex (int field, Array< OneD, NekDouble > &outarray, NekDouble time)
 Compute the exact solution for the isentropic vortex problem. More...
 
void SetInitialIsentropicVortex (NekDouble initialtime)
 Set the initial condition for the isentropic vortex problem. More...
 
void SetBoundaryIsentropicVortex (int bcRegion, NekDouble time, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Set the boundary conditions for the isentropic vortex problem. More...
 
void GetExactRinglebFlow (int field, Array< OneD, NekDouble > &outarray)
 Ringleb Flow Test Case. More...
 
void SetInitialRinglebFlow (void)
 Set the initial condition for the Ringleb flow problem. More...
 
void SetBoundaryRinglebFlow (int bcRegion, NekDouble time, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
 Set the boundary conditions for the Ringleb flow problem. More...
 

Friends

class MemoryManager< EulerCFE >
 

Additional Inherited Members

- Protected Types inherited from Nektar::SolverUtils::EquationSystem
enum  HomogeneousType { eHomogeneous1D, eHomogeneous2D, eHomogeneous3D, eNotHomogeneous }
 Parameter for homogeneous expansions. More...
 
- Protected Attributes inherited from Nektar::CompressibleFlowSystem
SolverUtils::RiemannSolverSharedPtr m_riemannSolver
 
SolverUtils::RiemannSolverSharedPtr m_riemannSolverLDG
 
SolverUtils::AdvectionSharedPtr m_advection
 
SolverUtils::DiffusionSharedPtr m_diffusion
 
Array< OneD, Array< OneD, NekDouble > > m_vecLocs
 
NekDouble m_gamma
 
NekDouble m_pInf
 
NekDouble m_rhoInf
 
NekDouble m_uInf
 
NekDouble m_vInf
 
NekDouble m_wInf
 
NekDouble m_UInf
 
NekDouble m_gasConstant
 
NekDouble m_Twall
 
std::string m_ViscosityType
 
std::string m_shockCaptureType
 
std::string m_EqTypeStr
 
NekDouble m_mu
 
NekDouble m_Skappa
 
NekDouble m_Kappa
 
NekDouble m_mu0
 
NekDouble m_FacL
 
NekDouble m_FacH
 
NekDouble m_eps_max
 
NekDouble m_thermalConductivity
 
NekDouble m_Cp
 
NekDouble m_C1
 
NekDouble m_C2
 
NekDouble m_hFactor
 
NekDouble m_Prandtl
 
NekDouble m_amplitude
 
NekDouble m_omega
 
std::ofstream m_errFile
 
int m_steadyStateSteps
 
NekDouble m_steadyStateTol
 
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
 
StdRegions::StdQuadExpSharedPtr m_OrthoQuadExp
 
StdRegions::StdHexExpSharedPtr m_OrthoHexExp
 
bool m_smoothDiffusion
 
Array< OneD, NekDouble > m_pressureStorage
 
Array< OneD, Array< OneD, NekDouble > > m_fieldStorage
 
Array< OneD, Array< OneD, NekDouble > > m_un
 
- Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem
int m_infosteps
 Number of time steps between outputting status information. More...
 
LibUtilities::TimeIntegrationWrapperSharedPtr m_intScheme
 Wrapper to the time integration scheme. More...
 
LibUtilities::TimeIntegrationSchemeOperators m_ode
 The time integration scheme operators to use. More...
 
LibUtilities::TimeIntegrationSolutionSharedPtr m_intSoln
 
NekDouble m_epsilon
 
bool m_explicitDiffusion
 Indicates if explicit or implicit treatment of diffusion is used. More...
 
bool m_explicitAdvection
 Indicates if explicit or implicit treatment of advection is used. More...
 
bool m_explicitReaction
 Indicates if explicit or implicit treatment of reaction is used. More...
 
bool m_homoInitialFwd
 Flag to determine if simulation should start in homogeneous forward transformed state. More...
 
std::vector< int > m_intVariables
 
std::vector< FilterSharedPtr > m_filters
 
- Protected Attributes inherited from Nektar::SolverUtils::EquationSystem
LibUtilities::CommSharedPtr m_comm
 Communicator. More...
 
LibUtilities::SessionReaderSharedPtr m_session
 The session reader. More...
 
LibUtilities::FieldIOSharedPtr m_fld
 Field input/output. More...
 
map< std::string, Array< OneD, Array< OneD, float > > > m_interpWeights
 Map of the interpolation weights for a specific filename. More...
 
map< std::string, Array< OneD, Array< OneD, unsigned int > > > m_interpInds
 Map of the interpolation indices for a specific filename. More...
 
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
 Array holding all dependent variables. More...
 
Array< OneD, MultiRegions::ExpListSharedPtr > m_base
 Base fields. More...
 
Array< OneD, MultiRegions::ExpListSharedPtr > m_derivedfields
 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...
 
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...
 
int m_steps
 Number of steps to take. More...
 
int m_checksteps
 Number of steps between checkpoints. More...
 
int m_spacedim
 Spatial dimension (>= expansion dim). More...
 
int m_expdim
 Expansion dimension. More...
 
bool m_singleMode
 Flag to determine if single homogeneous mode is used. More...
 
bool m_halfMode
 Flag to determine if half homogeneous mode is used. More...
 
bool m_multipleModes
 Flag to determine if use multiple homogenenous modes are used. More...
 
bool m_useFFT
 Flag to determine if FFT is used for homogeneous transform. More...
 
bool m_homogen_dealiasing
 Flag to determine if dealiasing is used for homogeneous simulations. More...
 
bool m_specHP_dealiasing
 Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More...
 
enum MultiRegions::ProjectionType m_projectionType
 Type of projection; e.g continuous or discontinuous. More...
 
Array< OneD, Array< OneD, NekDouble > > m_traceNormals
 Array holding trace normals for DG simulations in the forwards direction. More...
 
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > m_gradtan
 1 x nvariable x nq More...
 
Array< OneD, Array< OneD, Array< OneD, NekDouble > > > m_tanbasis
 2 x m_spacedim x nq 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...
 
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...
 
int m_NumMode
 Mode to use in case of single mode analysis. More...
 

Detailed Description

Definition at line 58 of file EulerCFE.h.

Constructor & Destructor Documentation

Nektar::EulerCFE::~EulerCFE ( )
virtual

problem type selector

Destructor for EulerCFE class.

Definition at line 95 of file EulerCFE.cpp.

96  {
97  }
Nektar::EulerCFE::EulerCFE ( const LibUtilities::SessionReaderSharedPtr &  pSession)
protected

Definition at line 52 of file EulerCFE.cpp.

54  : CompressibleFlowSystem(pSession)
55  {
56  }
Nektar::CompressibleFlowSystem::CompressibleFlowSystem
CompressibleFlowSystem(const LibUtilities::SessionReaderSharedPtr &pSession)
Definition: CompressibleFlowSystem.cpp:54

Member Function Documentation

static SolverUtils::EquationSystemSharedPtr Nektar::EulerCFE::create ( const LibUtilities::SessionReaderSharedPtr &  pSession)
inlinestatic

Creates an instance of this class.

Definition at line 64 of file EulerCFE.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

66  {
67  SolverUtils::EquationSystemSharedPtr p = MemoryManager<EulerCFE>::AllocateSharedPtr(pSession);
68  p->InitObject();
69  return p;
70  }
Nektar::MemoryManager::AllocateSharedPtr
static boost::shared_ptr< DataType > AllocateSharedPtr()
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:235
Nektar::SolverUtils::EquationSystemSharedPtr
boost::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.
Definition: EquationSystem.h:56
void Nektar::EulerCFE::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 173 of file EulerCFE.cpp.

References ASSERTL0, Nektar::MultiRegions::eDiscontinuous, Nektar::MultiRegions::eGalerkin, Nektar::MultiRegions::eMixed_CG_Discontinuous, Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::m_projectionType, SetBoundaryConditions(), and Vmath::Vcopy().

Referenced by v_InitObject().

177  {
178  int i;
179  int nvariables = inarray.num_elements();
180 
181  switch (m_projectionType)
182  {
183  case MultiRegions::eDiscontinuous:
184  {
185  // Just copy over array
186  int npoints = GetNpoints();
187 
188  for(i = 0; i < nvariables; ++i)
189  {
190  Vmath::Vcopy(npoints, inarray[i], 1, outarray[i], 1);
191  }
192  SetBoundaryConditions(outarray, time);
193  break;
194  }
195  case MultiRegions::eGalerkin:
196  case MultiRegions::eMixed_CG_Discontinuous:
197  {
198  ASSERTL0(false, "No Continuous Galerkin for Euler equations");
199  break;
200  }
201  default:
202  ASSERTL0(false, "Unknown projection scheme");
203  break;
204  }
205  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::SolverUtils::EquationSystem::m_projectionType
enum MultiRegions::ProjectionType m_projectionType
Type of projection; e.g continuous or discontinuous.
Definition: EquationSystem.h:471
Nektar::SolverUtils::EquationSystem::GetNpoints
SOLVER_UTILS_EXPORT int GetNpoints()
Definition: EquationSystem.h:838
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1038
Nektar::EulerCFE::SetBoundaryConditions
void SetBoundaryConditions(Array< OneD, Array< OneD, NekDouble > > &physarray, NekDouble time)
Set boundary conditions which can be: a) Wall and Symmerty BCs implemented at CompressibleFlowSystem ...
Definition: EulerCFE.cpp:218
void Nektar::EulerCFE::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 142 of file EulerCFE.cpp.

References Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::CompressibleFlowSystem::m_advection, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::CompressibleFlowSystem::m_forcing, Nektar::SolverUtils::EquationSystem::m_spacedim, and Vmath::Neg().

Referenced by v_InitObject().

146  {
147  int i;
148  int nvariables = inarray.num_elements();
149  int npoints = GetNpoints();
150 
151  Array<OneD, Array<OneD, NekDouble> > advVel(m_spacedim);
152 
153  m_advection->Advect(nvariables, m_fields, advVel, inarray,
154  outarray, time);
155 
156  for (i = 0; i < nvariables; ++i)
157  {
158  Vmath::Neg(npoints, outarray[i], 1);
159  }
160 
161  // Add sponge layer if defined in the session file
162  std::vector<SolverUtils::ForcingSharedPtr>::const_iterator x;
163  for (x = m_forcing.begin(); x != m_forcing.end(); ++x)
164  {
165  (*x)->Apply(m_fields, inarray, outarray, time);
166  }
167  }
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:449
Vmath::Neg
void Neg(int n, T *x, const int incx)
Negate x = -x.
Definition: Vmath.cpp:382
Nektar::CompressibleFlowSystem::m_advection
SolverUtils::AdvectionSharedPtr m_advection
Definition: CompressibleFlowSystem.h:81
Nektar::SolverUtils::EquationSystem::GetNpoints
SOLVER_UTILS_EXPORT int GetNpoints()
Definition: EquationSystem.h:838
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:423
Nektar::CompressibleFlowSystem::m_forcing
std::vector< SolverUtils::ForcingSharedPtr > m_forcing
Definition: CompressibleFlowSystem.h:122
void Nektar::EulerCFE::EvaluateIsentropicVortex ( const Array< OneD, NekDouble > &  x,
const Array< OneD, NekDouble > &  y,
const Array< OneD, NekDouble > &  z,
Array< OneD, Array< OneD, NekDouble > > &  u,
NekDouble  time,
const int  o = 0 
)
private

Isentropic Vortex Test Case.

Definition at line 288 of file EulerCFE.cpp.

References Nektar::CompressibleFlowSystem::m_gamma, Nektar::SolverUtils::EquationSystem::m_spacedim, and Vmath::Zero().

Referenced by GetExactIsentropicVortex(), SetBoundaryIsentropicVortex(), and SetInitialIsentropicVortex().

295  {
296  int nq = x.num_elements();
297 
298  // Flow parameters
299  const NekDouble x0 = 5.0;
300  const NekDouble y0 = 0.0;
301  const NekDouble beta = 5.0;
302  const NekDouble u0 = 1.0;
303  const NekDouble v0 = 0.5;
304  const NekDouble gamma = m_gamma;
305  NekDouble r, xbar, ybar, tmp;
306  NekDouble fac = 1.0/(16.0*gamma*M_PI*M_PI);
307 
308  // In 3D zero rhow field.
309  if (m_spacedim == 3)
310  {
311  Vmath::Zero(nq, &u[3][o], 1);
312  }
313 
314  // Fill storage
315  for (int i = 0; i < nq; ++i)
316  {
317  xbar = x[i] - u0*time - x0;
318  ybar = y[i] - v0*time - y0;
319  r = sqrt(xbar*xbar + ybar*ybar);
320  tmp = beta*exp(1-r*r);
321  u[0][i+o] = pow(1.0 - (gamma-1.0)*tmp*tmp*fac, 1.0/(gamma-1.0));
322  u[1][i+o] = u[0][i+o]*(u0 - tmp*ybar/(2*M_PI));
323  u[2][i+o] = u[0][i+o]*(v0 + tmp*xbar/(2*M_PI));
324  u[m_spacedim+1][i+o] = pow(u[0][i+o], gamma)/(gamma-1.0) +
325  0.5*(u[1][i+o]*u[1][i+o] + u[2][i+o]*u[2][i+o]) / u[0][i+o];
326  }
327  }
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:449
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:359
void Nektar::EulerCFE::GetExactIsentropicVortex ( int  field,
Array< OneD, NekDouble > &  outarray,
NekDouble  time 
)
private

Compute the exact solution for the isentropic vortex problem.

Definition at line 332 of file EulerCFE.cpp.

References EvaluateIsentropicVortex(), Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, and Vmath::Vcopy().

Referenced by v_EvaluateExactSolution().

336  {
337  int nTotQuadPoints = GetTotPoints();
338  Array<OneD, NekDouble> x(nTotQuadPoints);
339  Array<OneD, NekDouble> y(nTotQuadPoints);
340  Array<OneD, NekDouble> z(nTotQuadPoints);
341  Array<OneD, Array<OneD, NekDouble> > u(m_spacedim+2);
342 
343  m_fields[0]->GetCoords(x, y, z);
344 
345  for (int i = 0; i < m_spacedim + 2; ++i)
346  {
347  u[i] = Array<OneD, NekDouble>(nTotQuadPoints);
348  }
349 
350  EvaluateIsentropicVortex(x, y, z, u, time);
351 
352  Vmath::Vcopy(nTotQuadPoints, u[field], 1, outarray, 1);
353  }
Nektar::EulerCFE::EvaluateIsentropicVortex
void EvaluateIsentropicVortex(const Array< OneD, NekDouble > &x, const Array< OneD, NekDouble > &y, const Array< OneD, NekDouble > &z, Array< OneD, Array< OneD, NekDouble > > &u, NekDouble time, const int o=0)
Isentropic Vortex Test Case.
Definition: EulerCFE.cpp:288
Nektar::SolverUtils::EquationSystem::GetTotPoints
SOLVER_UTILS_EXPORT int GetTotPoints()
Definition: EquationSystem.h:828
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:449
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:423
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1038
void Nektar::EulerCFE::GetExactRinglebFlow ( int  field,
Array< OneD, NekDouble > &  outarray 
)
private

Ringleb Flow Test Case.

Compute the exact solution for the Ringleb flow problem.

Definition at line 438 of file EulerCFE.cpp.

References ASSERTL0, Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, and Nektar::CompressibleFlowSystem::m_gamma.

Referenced by v_EvaluateExactSolution().

441  {
442  int nTotQuadPoints = GetTotPoints();
443 
444  Array<OneD, NekDouble> rho(nTotQuadPoints, 100.0);
445  Array<OneD, NekDouble> rhou(nTotQuadPoints);
446  Array<OneD, NekDouble> rhov(nTotQuadPoints);
447  Array<OneD, NekDouble> E(nTotQuadPoints);
448  Array<OneD, NekDouble> x(nTotQuadPoints);
449  Array<OneD, NekDouble> y(nTotQuadPoints);
450  Array<OneD, NekDouble> z(nTotQuadPoints);
451 
452  m_fields[0]->GetCoords(x, y, z);
453 
454  // Flow parameters
455  NekDouble c, k, phi, r, J, VV, pp, sint, P, ss;
456  NekDouble J11, J12, J21, J22, det;
457  NekDouble Fx, Fy;
458  NekDouble xi, yi;
459  NekDouble dV;
460  NekDouble dtheta;
461  NekDouble par1;
462  NekDouble theta = M_PI / 4.0;
463  NekDouble kExt = 0.7;
464  NekDouble V = kExt * sin(theta);
465  NekDouble toll = 1.0e-8;
466  NekDouble errV = 1.0;
467  NekDouble errTheta = 1.0;
468  NekDouble gamma = m_gamma;
469  NekDouble gamma_1_2 = (gamma - 1.0) / 2.0;
470 
471  for (int i = 0; i < nTotQuadPoints; ++i)
472  {
473  while ((abs(errV) > toll) || (abs(errTheta) > toll))
474  {
475  VV = V * V;
476  sint = sin(theta);
477  c = sqrt(1.0 - gamma_1_2 * VV);
478  k = V / sint;
479  phi = 1.0 / k;
480  pp = phi * phi;
481  J = 1.0 / c + 1.0 / (3.0 * c * c * c) +
482  1.0 / (5.0 * c * c * c * c * c) -
483  0.5 * log((1.0 + c) / (1.0 - c));
484 
485  r = pow(c, 1.0 / gamma_1_2);
486  xi = 1.0 / (2.0 * r) * (1.0 / VV - 2.0 * pp) + J / 2.0;
487  yi = phi / (r * V) * sqrt(1.0 - VV * pp);
488  par1 = 25.0 - 5.0 * VV;
489  ss = sint * sint;
490 
491  Fx = xi - x[i];
492  Fy = yi - y[i];
493 
494  J11 = 39062.5 / pow(par1, 3.5) * (1.0 / VV - 2.0 / VV * ss) *
495  V + 1562.5 / pow(par1, 2.5) * (-2.0 / (VV * V) + 4.0 /
496  (VV * V) * ss) + 12.5 / pow(par1, 1.5) * V + 312.5 /
497  pow(par1, 2.5) * V + 7812.5 / pow(par1, 3.5) * V -
498  0.25 * (-1.0 / pow(par1, 0.5) * V/(1.0 - 0.2 *
499  pow(par1, 0.5)) - (1.0 + 0.2 * pow(par1, 0.5)) /
500  pow((1.0 - 0.2 * pow(par1, 0.5)), 2.0) /
501  pow(par1, 0.5) * V) / (1.0 + 0.2 * pow(par1, 0.5)) *
502  (1.0 - 0.2 * pow(par1, 0.5));
503 
504  J12 = -6250.0 / pow(par1, 2.5) / VV * sint * cos(theta);
505  J21 = -6250.0 / (VV * V) * sint /
506  pow(par1, 2.5) * pow((1.0 - ss), 0.5) +
507  78125.0 / V * sint / pow(par1, 3.5) *
508  pow((1.0 - ss), 0.5);
509 
510  // the matrix is singular when theta = pi/2
511  if(abs(y[i])<toll && abs(cos(theta))<toll)
512  {
513  J22 = -39062.5 / pow(par1, 3.5) / V + 3125 /
514  pow(par1, 2.5) / (VV * V) + 12.5 / pow(par1, 1.5) *
515  V + 312.5 / pow(par1, 2.5) * V + 7812.5 /
516  pow(par1, 3.5) * V - 0.25 * (-1.0 / pow(par1, 0.5) *
517  V / (1.0 - 0.2 * pow(par1, 0.5)) - (1.0 + 0.2 *
518  pow(par1, 0.5)) / pow((1.0 - 0.2 *
519  pow(par1, 0.5)), 2.0) / pow(par1, 0.5) * V) /
520  (1.0 + 0.2 * pow(par1, 0.5)) * (1.0 - 0.2 *
521  pow(par1,0.5));
522 
523  // dV = -dV/dx * Fx
524  dV = -1.0 / J22 * Fx;
525  dtheta = 0.0;
526  theta = M_PI / 2.0;
527  }
528  else
529  {
530  J22 = 3125.0 / VV * cos(theta) / pow(par1, 2.5) *
531  pow((1.0 - ss), 0.5) - 3125.0 / VV * ss /
532  pow(par1, 2.5) / pow((1.0 - ss), 0.5) * cos(theta);
533 
534  det = -1.0 / (J11 * J22 - J12 * J21);
535 
536  // [dV dtheta]' = -[invJ]*[Fx Fy]'
537  dV = det * ( J22 * Fx - J12 * Fy);
538  dtheta = det * (-J21 * Fx + J11 * Fy);
539  }
540 
541  V = V + dV;
542  theta = theta + dtheta;
543 
544  errV = abs(dV);
545  errTheta = abs(dtheta);
546 
547  }
548 
549  c = sqrt(1.0 - gamma_1_2 * VV);
550  r = pow(c, 1.0 / gamma_1_2);
551 
552  rho[i] = r;
553  rhou[i] = rho[i] * V * cos(theta);
554  rhov[i] = rho[i] * V * sin(theta);
555  P = (c * c) * rho[i] / gamma;
556  E[i] = P / (gamma - 1.0) + 0.5 *
557  (rhou[i] * rhou[i] / rho[i] + rhov[i] * rhov[i] / rho[i]);
558 
559  // Resetting the guess value
560  errV = 1.0;
561  errTheta = 1.0;
562  theta = M_PI/4.0;
563  V = kExt*sin(theta);
564  }
565 
566  switch (field)
567  {
568  case 0:
569  outarray = rho;
570  break;
571  case 1:
572  outarray = rhou;
573  break;
574  case 2:
575  outarray = rhov;
576  break;
577  case 3:
578  outarray = E;
579  break;
580  default:
581  ASSERTL0(false, "Error in variable number!");
582  break;
583  }
584  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::SolverUtils::EquationSystem::GetTotPoints
SOLVER_UTILS_EXPORT int GetTotPoints()
Definition: EquationSystem.h:828
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:423
void Nektar::EulerCFE::SetBoundaryConditions ( Array< OneD, Array< OneD, NekDouble > > &  inarray,
NekDouble  time 
)
private

Set boundary conditions which can be: a) Wall and Symmerty BCs implemented at CompressibleFlowSystem level since they are compressible solver specific; b) Isentropic vortex and Ringleb flow BCs implemented at EulerCFE level since they are Euler solver specific; c) Time dependent BCs.

Parameters
inarrayfields array.
timetime.

Definition at line 218 of file EulerCFE.cpp.

References ASSERTL0, Nektar::SolverUtils::EquationSystem::m_fields, SetBoundaryIsentropicVortex(), SetBoundaryRinglebFlow(), and Nektar::CompressibleFlowSystem::SetCommonBC().

Referenced by DoOdeProjection().

221  {
222  std::string varName;
223  int cnt = 0;
224 
225  std::string userDefStr;
226  int nreg = m_fields[0]->GetBndConditions().num_elements();
227  // Loop over Boundary Regions
228  for (int n = 0; n < nreg; ++n)
229  {
230  userDefStr = m_fields[0]->GetBndConditions()[n]->GetUserDefined();
231  if(!userDefStr.empty())
232  {
233  if(boost::iequals(userDefStr,"WallViscous"))
234  {
235  ASSERTL0(false, "WallViscous is a wrong bc for the "
236  "Euler equations");
237  }
238  else if(boost::iequals(userDefStr, "IsentropicVortex"))
239  {
240  // Isentropic Vortex Boundary Condition
241  SetBoundaryIsentropicVortex(n, time, cnt, inarray);
242  }
243  else if (boost::iequals(userDefStr,"RinglebFlow"))
244  {
245  SetBoundaryRinglebFlow(n, time, cnt, inarray);
246  }
247  else
248  {
249  // set up userdefined BC common to all solvers
250  SetCommonBC(userDefStr,n,time, cnt,inarray);
251  }
252  }
253 
254  // no User Defined conditions provided so skip cnt
255  cnt += m_fields[0]->GetBndCondExpansions()[n]->GetExpSize();
256  }
257  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::CompressibleFlowSystem::SetCommonBC
void SetCommonBC(const std::string &userDefStr, const int n, const NekDouble time, int &cnt, Array< OneD, Array< OneD, NekDouble > > &inarray)
Set boundary conditions which can be: a) Wall and Symmerty BCs implemented at CompressibleFlowSystem ...
Definition: CompressibleFlowSystem.cpp:322
Nektar::EulerCFE::SetBoundaryRinglebFlow
void SetBoundaryRinglebFlow(int bcRegion, NekDouble time, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
Set the boundary conditions for the Ringleb flow problem.
Definition: EulerCFE.cpp:833
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:423
Nektar::EulerCFE::SetBoundaryIsentropicVortex
void SetBoundaryIsentropicVortex(int bcRegion, NekDouble time, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
Set the boundary conditions for the isentropic vortex problem.
Definition: EulerCFE.cpp:388
void Nektar::EulerCFE::SetBoundaryIsentropicVortex ( int  bcRegion,
NekDouble  time,
int  cnt,
Array< OneD, Array< OneD, NekDouble > > &  physarray 
)
private

Set the boundary conditions for the isentropic vortex problem.

Definition at line 388 of file EulerCFE.cpp.

References EvaluateIsentropicVortex(), Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, and Vmath::Vcopy().

Referenced by SetBoundaryConditions().

393  {
394  int nvariables = physarray.num_elements();
395  int nTraceNumPoints = GetTraceTotPoints();
396  Array<OneD, Array<OneD, NekDouble> > Fwd(nvariables);
397  const Array<OneD, const int> &bndTraceMap = m_fields[0]->GetTraceBndMap();
398 
399  // Get physical values of the forward trace (from exp to phys)
400  for (int i = 0; i < nvariables; ++i)
401  {
402  Fwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
403  m_fields[i]->ExtractTracePhys(physarray[i], Fwd[i]);
404  }
405 
406  int id2, e_max;
407  e_max = m_fields[0]->GetBndCondExpansions()[bcRegion]->GetExpSize();
408 
409  for(int e = 0; e < e_max; ++e)
410  {
411  int npoints = m_fields[0]->
412  GetBndCondExpansions()[bcRegion]->GetExp(e)->GetTotPoints();
413  int id1 = m_fields[0]->
414  GetBndCondExpansions()[bcRegion]->GetPhys_Offset(e);
415  id2 = m_fields[0]->GetTrace()->GetPhys_Offset(bndTraceMap[cnt++]);
416 
417  Array<OneD,NekDouble> x(npoints, 0.0);
418  Array<OneD,NekDouble> y(npoints, 0.0);
419  Array<OneD,NekDouble> z(npoints, 0.0);
420 
421  m_fields[0]->GetBndCondExpansions()[bcRegion]->
422  GetExp(e)->GetCoords(x, y, z);
423 
424  EvaluateIsentropicVortex(x, y, z, Fwd, time, id2);
425 
426  for (int i = 0; i < nvariables; ++i)
427  {
428  Vmath::Vcopy(npoints, &Fwd[i][id2], 1,
429  &(m_fields[i]->GetBndCondExpansions()[bcRegion]->
430  UpdatePhys())[id1], 1);
431  }
432  }
433  }
Nektar::EulerCFE::EvaluateIsentropicVortex
void EvaluateIsentropicVortex(const Array< OneD, NekDouble > &x, const Array< OneD, NekDouble > &y, const Array< OneD, NekDouble > &z, Array< OneD, Array< OneD, NekDouble > > &u, NekDouble time, const int o=0)
Isentropic Vortex Test Case.
Definition: EulerCFE.cpp:288
Nektar::SolverUtils::EquationSystem::GetTraceTotPoints
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
Definition: EquationSystem.h:803
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:423
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1038
void Nektar::EulerCFE::SetBoundaryRinglebFlow ( int  bcRegion,
NekDouble  time,
int  cnt,
Array< OneD, Array< OneD, NekDouble > > &  physarray 
)
private

Set the boundary conditions for the Ringleb flow problem.

Definition at line 833 of file EulerCFE.cpp.

References Nektar::LibUtilities::eFunctionTypeFile, Nektar::SolverUtils::EquationSystem::eHomogeneous1D, Nektar::SolverUtils::EquationSystem::GetTraceTotPoints(), Nektar::SolverUtils::EquationSystem::m_expdim, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::CompressibleFlowSystem::m_gamma, Nektar::SolverUtils::EquationSystem::m_HomogeneousType, Nektar::SolverUtils::EquationSystem::m_session, and Vmath::Vcopy().

Referenced by SetBoundaryConditions().

838  {
839  int nvariables = physarray.num_elements();
840  int nTraceNumPoints = GetTraceTotPoints();
841  Array<OneD, Array<OneD, NekDouble> > Fwd(nvariables);
842 
843  // For 3DHomogenoeus1D
844  int n_planes = 1;
845  if (m_expdim == 2 && m_HomogeneousType == eHomogeneous1D)
846  {
847  int nPointsTot = m_fields[0]->GetTotPoints();
848  int nPointsTot_plane = m_fields[0]->GetPlane(0)->GetTotPoints();
849  n_planes = nPointsTot/nPointsTot_plane;
850  nTraceNumPoints = nTraceNumPoints * n_planes;
851  }
852 
853  // Get physical values of the forward trace (from exp to phys)
854  for (int i = 0; i < nvariables; ++i)
855  {
856  Fwd[i] = Array<OneD, NekDouble>(nTraceNumPoints);
857  m_fields[i]->ExtractTracePhys(physarray[i], Fwd[i]);
858  }
859 
860  int id2, id2_plane, e_max;
861 
862  e_max = m_fields[0]->GetBndCondExpansions()[bcRegion]->GetExpSize();
863 
864  for(int e = 0; e < e_max; ++e)
865  {
866  int npoints = m_fields[0]->
867  GetBndCondExpansions()[bcRegion]->GetExp(e)->GetTotPoints();
868  int id1 = m_fields[0]->
869  GetBndCondExpansions()[bcRegion]->GetPhys_Offset(e);
870 
871  // For 3DHomogenoeus1D
872  if (m_expdim == 2 && m_HomogeneousType == eHomogeneous1D)
873  {
874  int cnt_plane = cnt/n_planes;
875  int e_plane;
876  int e_max_plane = e_max/n_planes;
877  int nTracePts_plane = GetTraceTotPoints();
878 
879  int planeID = floor((e + 0.5 )/ e_max_plane );
880  e_plane = e - e_max_plane*planeID;
881 
882  id2_plane = m_fields[0]->GetTrace()->GetPhys_Offset(
883  m_fields[0]->GetTraceMap()->
884  GetBndCondCoeffsToGlobalCoeffsMap(
885  cnt_plane + e_plane));
886  id2 = id2_plane + planeID*nTracePts_plane;
887  }
888  else // For general case
889  {
890  id2 = m_fields[0]->
891  GetTrace()->GetPhys_Offset(m_fields[0]->GetTraceMap()->
892  GetBndCondTraceToGlobalTraceMap(cnt++));
893  }
894 
895  Array<OneD,NekDouble> x0(npoints, 0.0);
896  Array<OneD,NekDouble> x1(npoints, 0.0);
897  Array<OneD,NekDouble> x2(npoints, 0.0);
898 
899  m_fields[0]->GetBndCondExpansions()[bcRegion]->
900  GetExp(e)->GetCoords(x0, x1, x2);
901 
902  // Flow parameters
903  NekDouble c, k, phi, r, J, VV, pp, sint, P, ss;
904  NekDouble J11, J12, J21, J22, det;
905  NekDouble Fx, Fy;
906  NekDouble xi, yi;
907  NekDouble dV;
908  NekDouble dtheta;
909  NekDouble par1;
910  NekDouble theta = M_PI / 4.0;
911  NekDouble kExt = 0.7;
912  NekDouble V = kExt * sin(theta);
913  NekDouble toll = 1.0e-8;
914  NekDouble errV = 1.0;
915  NekDouble errTheta = 1.0;
916  NekDouble gamma = m_gamma;
917  NekDouble gamma_1_2 = (gamma - 1.0) / 2.0;
918 
919  // Loop on all the points of that edge
920  for (int j = 0; j < npoints; j++)
921  {
922 
923  while ((abs(errV) > toll) || (abs(errTheta) > toll))
924  {
925  VV = V * V;
926  sint = sin(theta);
927  c = sqrt(1.0 - gamma_1_2 * VV);
928  k = V / sint;
929  phi = 1.0 / k;
930  pp = phi * phi;
931  J = 1.0 / c + 1.0 / (3.0 * c * c * c) +
932  1.0 / (5.0 * c * c * c * c * c) -
933  0.5 * log((1.0 + c) / (1.0 - c));
934 
935  r = pow(c, 1.0 / gamma_1_2);
936  xi = 1.0 / (2.0 * r) * (1.0 / VV - 2.0 * pp) + J / 2.0;
937  yi = phi / (r * V) * sqrt(1.0 - VV * pp);
938  par1 = 25.0 - 5.0 * VV;
939  ss = sint * sint;
940 
941  Fx = xi - x0[j];
942  Fy = yi - x1[j];
943 
944  J11 = 39062.5 / pow(par1, 3.5) *
945  (1.0 / VV - 2.0 / VV * ss) * V + 1562.5 /
946  pow(par1, 2.5) * (-2.0 / (VV * V) + 4.0 /
947  (VV * V) * ss) + 12.5 / pow(par1, 1.5) * V +
948  312.5 / pow(par1, 2.5) * V + 7812.5 /
949  pow(par1, 3.5) * V - 0.25 *
950  (-1.0 / pow(par1, 0.5) * V / (1.0 - 0.2 *
951  pow(par1, 0.5)) - (1.0 + 0.2 * pow(par1, 0.5)) /
952  pow((1.0 - 0.2 * pow(par1, 0.5)), 2.0) /
953  pow(par1, 0.5) * V) / (1.0 + 0.2 * pow(par1, 0.5)) *
954  (1.0 - 0.2 * pow(par1, 0.5));
955 
956  J12 = -6250.0 / pow(par1, 2.5) / VV * sint * cos(theta);
957  J21 = -6250.0 / (VV * V) * sint / pow(par1, 2.5) *
958  pow((1.0 - ss), 0.5) + 78125.0 / V * sint /
959  pow(par1, 3.5) * pow((1.0 - ss), 0.5);
960 
961  // the matrix is singular when theta = pi/2
962  if (abs(x1[j]) < toll && abs(cos(theta)) < toll)
963  {
964  J22 = -39062.5 / pow(par1, 3.5) / V + 3125 /
965  pow(par1, 2.5) / (VV * V) + 12.5 /
966  pow(par1, 1.5) * V + 312.5 / pow(par1, 2.5) *
967  V + 7812.5 / pow(par1, 3.5) * V - 0.25 *
968  (-1.0 / pow(par1, 0.5) * V / (1.0 - 0.2 *
969  pow(par1, 0.5)) - (1.0 + 0.2 * pow(par1, 0.5)) /
970  pow((1.0 - 0.2 * pow(par1, 0.5)), 2.0) /
971  pow(par1, 0.5) * V) / (1.0 + 0.2 *
972  pow(par1, 0.5)) * (1.0 - 0.2 * pow(par1, 0.5));
973 
974  // dV = -dV/dx * Fx
975  dV = -1.0 / J22 * Fx;
976  dtheta = 0.0;
977  theta = M_PI / 2.0;
978  }
979  else
980  {
981  J22 = 3125.0 / VV * cos(theta) / pow(par1, 2.5) *
982  pow((1.0 - ss), 0.5) - 3125.0 / VV * ss /
983  pow(par1, 2.5) / pow((1.0 - ss), 0.5) *
984  cos(theta);
985 
986  det = -1.0 / (J11 * J22 - J12 * J21);
987 
988  // [dV dtheta]' = -[invJ]*[Fx Fy]'
989  dV = det * ( J22 * Fx - J12 * Fy);
990  dtheta = det * (-J21 * Fx + J11 * Fy);
991  }
992 
993  V = V + dV;
994  theta = theta + dtheta;
995 
996  errV = abs(dV);
997  errTheta = abs(dtheta);
998  }
999 
1000  c = sqrt(1.0 - gamma_1_2 * VV);
1001  int kk = id2 + j;
1002  NekDouble timeramp = 200.0;
1003  std::string restartstr = "RESTART";
1004  if (time<timeramp &&
1005  !(m_session->DefinesFunction("InitialConditions") &&
1006  m_session->GetFunctionType("InitialConditions", 0) ==
1007  LibUtilities::eFunctionTypeFile))
1008  {
1009  Fwd[0][kk] = pow(c, 1.0 / gamma_1_2) *
1010  exp(-1.0 + time /timeramp);
1011 
1012  Fwd[1][kk] = Fwd[0][kk] * V * cos(theta) *
1013  exp(-1 + time / timeramp);
1014 
1015  Fwd[2][kk] = Fwd[0][kk] * V * sin(theta) *
1016  exp(-1 + time / timeramp);
1017  }
1018  else
1019  {
1020  Fwd[0][kk] = pow(c, 1.0 / gamma_1_2);
1021  Fwd[1][kk] = Fwd[0][kk] * V * cos(theta);
1022  Fwd[2][kk] = Fwd[0][kk] * V * sin(theta);
1023  }
1024 
1025  P = (c * c) * Fwd[0][kk] / gamma;
1026  Fwd[3][kk] = P / (gamma - 1.0) + 0.5 *
1027  (Fwd[1][kk] * Fwd[1][kk] / Fwd[0][kk] +
1028  Fwd[2][kk] * Fwd[2][kk] / Fwd[0][kk]);
1029 
1030  errV = 1.0;
1031  errTheta = 1.0;
1032  theta = M_PI / 4.0;
1033  V = kExt * sin(theta);
1034  }
1035 
1036  for (int i = 0; i < nvariables; ++i)
1037  {
1038  Vmath::Vcopy(npoints, &Fwd[i][id2], 1,
1039  &(m_fields[i]->GetBndCondExpansions()[bcRegion]->
1040  UpdatePhys())[id1],1);
1041  }
1042  }
1043  }
Nektar::SolverUtils::EquationSystem::m_expdim
int m_expdim
Expansion dimension.
Definition: EquationSystem.h:451
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::SolverUtils::EquationSystem::GetTraceTotPoints
SOLVER_UTILS_EXPORT int GetTraceTotPoints()
Definition: EquationSystem.h:803
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:423
Nektar::SolverUtils::EquationSystem::m_session
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Definition: EquationSystem.h:415
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1038
Nektar::SolverUtils::EquationSystem::m_HomogeneousType
enum HomogeneousType m_HomogeneousType
Definition: EquationSystem.h:497
void Nektar::EulerCFE::SetInitialIsentropicVortex ( NekDouble  initialtime)
private

Set the initial condition for the isentropic vortex problem.

Definition at line 358 of file EulerCFE.cpp.

References EvaluateIsentropicVortex(), Nektar::SolverUtils::EquationSystem::GetTotPoints(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_spacedim, and Vmath::Vcopy().

Referenced by v_SetInitialConditions().

359  {
360  int nTotQuadPoints = GetTotPoints();
361  Array<OneD, NekDouble> x(nTotQuadPoints);
362  Array<OneD, NekDouble> y(nTotQuadPoints);
363  Array<OneD, NekDouble> z(nTotQuadPoints);
364  Array<OneD, Array<OneD, NekDouble> > u(m_spacedim+2);
365 
366  m_fields[0]->GetCoords(x, y, z);
367 
368  for (int i = 0; i < m_spacedim + 2; ++i)
369  {
370  u[i] = Array<OneD, NekDouble>(nTotQuadPoints);
371  }
372 
373  EvaluateIsentropicVortex(x, y, z, u, initialtime);
374 
375  // Forward transform to fill the coefficient space
376  for(int i = 0; i < m_fields.num_elements(); ++i)
377  {
378  Vmath::Vcopy(nTotQuadPoints, u[i], 1, m_fields[i]->UpdatePhys(), 1);
379  m_fields[i]->SetPhysState(true);
380  m_fields[i]->FwdTrans(m_fields[i]->GetPhys(),
381  m_fields[i]->UpdateCoeffs());
382  }
383  }
Nektar::EulerCFE::EvaluateIsentropicVortex
void EvaluateIsentropicVortex(const Array< OneD, NekDouble > &x, const Array< OneD, NekDouble > &y, const Array< OneD, NekDouble > &z, Array< OneD, Array< OneD, NekDouble > > &u, NekDouble time, const int o=0)
Isentropic Vortex Test Case.
Definition: EulerCFE.cpp:288
Nektar::SolverUtils::EquationSystem::GetTotPoints
SOLVER_UTILS_EXPORT int GetTotPoints()
Definition: EquationSystem.h:828
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:449
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:423
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1038
void Nektar::EulerCFE::SetInitialRinglebFlow ( void  )
private

Set the initial condition for the Ringleb flow problem.

Definition at line 589 of file EulerCFE.cpp.

References Nektar::SolverUtils::EquationSystem::m_fields, Nektar::CompressibleFlowSystem::m_gamma, Nektar::SolverUtils::EquationSystem::m_sessionName, and Nektar::SolverUtils::EquationSystem::WriteFld().

590  {
591  // Get number of different boundaries in the input file
592  int nbnd = m_fields[0]->GetBndConditions().num_elements();
593 
594  // Loop on all the edges of the input file
595  for(int bcRegion=0; bcRegion < nbnd; ++bcRegion)
596  {
597 
598  int npoints = m_fields[0]->
599  GetBndCondExpansions()[bcRegion]->GetNpoints();
600 
601  Array<OneD,NekDouble> x0(npoints, 0.0);
602  Array<OneD,NekDouble> x1(npoints, 0.0);
603  Array<OneD,NekDouble> x2(npoints, 0.0);
604 
605  Array<OneD, NekDouble> rho(npoints, 0.0);
606  Array<OneD, NekDouble> rhou(npoints, 0.0);
607  Array<OneD, NekDouble> rhov(npoints, 0.0);
608  Array<OneD, NekDouble> E(npoints, 0.0);
609 
610  m_fields[0]->GetBndCondExpansions()[bcRegion]->
611  GetCoords(x0, x1, x2);
612 
613  // Flow parameters
614  NekDouble c, k, phi, r, J, VV, pp, sint, P, ss;
615  NekDouble J11, J12, J21, J22, det;
616  NekDouble Fx, Fy;
617  NekDouble xi, yi;
618  NekDouble dV;
619  NekDouble dtheta;
620  NekDouble par1;
621  NekDouble theta = M_PI / 4.0;
622  NekDouble kExt = 0.7;
623  NekDouble V = kExt * sin(theta);
624  NekDouble toll = 1.0e-8;
625  NekDouble errV = 1.0;
626  NekDouble errTheta = 1.0;
627  NekDouble gamma = m_gamma;
628  NekDouble gamma_1_2 = (gamma - 1.0) / 2.0;
629 
630  // Loop on all the points of that edge
631  for (int j = 0; j < npoints; j++)
632  {
633  while ((abs(errV) > toll) || (abs(errTheta) > toll))
634  {
635 
636  VV = V * V;
637  sint = sin(theta);
638  c = sqrt(1.0 - gamma_1_2 * VV);
639  k = V / sint;
640  phi = 1.0 / k;
641  pp = phi * phi;
642  J = 1.0 / c + 1.0 / (3.0 * c * c * c) +
643  1.0 / (5.0 * c * c * c * c * c) -
644  0.5 * log((1.0 + c) / (1.0 - c));
645 
646  r = pow(c, 1.0 / gamma_1_2);
647  xi = 1.0 / (2.0 * r) * (1.0 / VV - 2.0 * pp) + J / 2.0;
648  yi = phi / (r * V) * sqrt(1.0 - VV * pp);
649  par1 = 25.0 - 5.0 * VV;
650  ss = sint * sint;
651 
652  Fx = xi - x0[j];
653  Fy = yi - x1[j];
654 
655  J11 = 39062.5 / pow(par1, 3.5) *
656  (1.0 / VV - 2.0 / VV * ss) * V +
657  1562.5 / pow(par1, 2.5) * (-2.0 /
658  (VV * V) + 4.0 / (VV * V) * ss) +
659  12.5 / pow(par1, 1.5) * V +
660  312.5 / pow(par1, 2.5) * V +
661  7812.5 / pow(par1, 3.5) * V -
662  0.25 * (-1.0 / pow(par1, 0.5) * V /
663  (1.0 - 0.2 * pow(par1, 0.5)) - (1.0 + 0.2 *
664  pow(par1, 0.5)) / pow((1.0 - 0.2 *
665  pow(par1, 0.5)), 2.0) /
666  pow(par1, 0.5) * V) /
667  (1.0 + 0.2 * pow(par1, 0.5)) *
668  (1.0 - 0.2 * pow(par1, 0.5));
669 
670  J12 = -6250.0 / pow(par1, 2.5) / VV * sint * cos(theta);
671  J21 = -6250.0 / (VV * V) * sint / pow(par1, 2.5) *
672  pow((1.0 - ss), 0.5) + 78125.0 / V * sint /
673  pow(par1, 3.5) * pow((1.0 - ss), 0.5);
674 
675  // the matrix is singular when theta = pi/2
676  if (abs(x1[j]) < toll && abs(cos(theta)) < toll)
677  {
678 
679  J22 = -39062.5 / pow(par1, 3.5) / V +
680  3125 / pow(par1, 2.5) / (VV * V) + 12.5 /
681  pow(par1, 1.5) * V + 312.5 / pow(par1, 2.5) * V +
682  7812.5 / pow(par1, 3.5) * V -
683  0.25 * (-1.0 / pow(par1, 0.5) * V /
684  (1.0 - 0.2 * pow(par1, 0.5)) -
685  (1.0 + 0.2 * pow(par1, 0.5)) /
686  pow((1.0 - 0.2* pow(par1, 0.5)), 2.0) /
687  pow(par1, 0.5) *V) /
688  (1.0 + 0.2 * pow(par1, 0.5)) *
689  (1.0 - 0.2 * pow(par1, 0.5));
690 
691  // dV = -dV/dx * Fx
692  dV = -1.0 / J22 * Fx;
693  dtheta = 0.0;
694  theta = M_PI / 2.0;
695  }
696  else
697  {
698 
699  J22 = 3125.0 / VV * cos(theta) / pow(par1, 2.5) *
700  pow((1.0 - ss), 0.5) - 3125.0 / VV * ss /
701  pow(par1, 2.5) / pow((1.0 - ss), 0.5) *
702  cos(theta);
703 
704  det = -1.0 / (J11 * J22 - J12 * J21);
705 
706  // [dV dtheta]' = -[invJ]*[Fx Fy]'
707  dV = det * ( J22 * Fx - J12 * Fy);
708  dtheta = det * (-J21 * Fx + J11 * Fy);
709  }
710 
711  V = V + dV;
712  theta = theta + dtheta;
713 
714  errV = abs(dV);
715  errTheta = abs(dtheta);
716 
717  }
718 
719  c = sqrt(1.0 - gamma_1_2 * VV);
720  rho[j] = pow(c, 1.0 / gamma_1_2) * exp(-1.0);
721  rhou[j] = rho[j] * V * cos(theta) * exp(-1.0);
722  rhov[j] = rho[j] * V * sin(theta) * exp(-1.0);
723  P = (c * c) * rho[j] / gamma;
724  E[j] = P / (gamma - 1.0) + 0.5 *
725  (rhou[j] * rhou[j] /
726  rho[j] + rhov[j] * rhov[j] / rho[j]);
727  errV = 1.0;
728  errTheta = 1.0;
729  theta = M_PI / 4.0;
730  V = kExt * sin(theta);
731 
732  }
733 
734  // Fill the physical space
735  m_fields[0]->GetBndCondExpansions()[bcRegion]->SetPhys(rho);
736  m_fields[1]->GetBndCondExpansions()[bcRegion]->SetPhys(rhou);
737  m_fields[2]->GetBndCondExpansions()[bcRegion]->SetPhys(rhov);
738  m_fields[3]->GetBndCondExpansions()[bcRegion]->SetPhys(E);
739 
740  // Forward transform to fill the coefficients space
741  for(int i = 0; i < m_fields.num_elements(); ++i)
742  {
743  m_fields[i]->GetBndCondExpansions()[bcRegion]->
744  FwdTrans_BndConstrained(
745  m_fields[i]->GetBndCondExpansions()[bcRegion]->
746  GetPhys(),
747  m_fields[i]->GetBndCondExpansions()[bcRegion]->
748  UpdateCoeffs());
749  }
750 
751  }
752 
753  // Calculation of the initial internal values as a weighted average
754  // over the distance from the boundaries
755  int nq = m_fields[0]->GetNpoints();
756 
757  Array<OneD,NekDouble> x0(nq);
758  Array<OneD,NekDouble> x1(nq);
759  Array<OneD,NekDouble> x2(nq);
760 
761  // Get the coordinates
762  // (assuming all fields have the same discretisation)
763  m_fields[0]->GetCoords(x0, x1, x2);
764 
765  for(int j = 0; j < nq; j++)
766  {
767  NekDouble Dist = 0.0;
768  NekDouble rho = 0.0;
769  NekDouble rhou = 0.0;
770  NekDouble rhov = 0.0;
771  NekDouble E = 0.0;
772  NekDouble SumDist = 0.0;
773 
774  // Calculation of all the distances
775  // Loop on all the edges of the input file
776  for (int bcRegion = 0; bcRegion < nbnd; ++bcRegion)
777  {
778  // Get quadrature points on the edge
779  int npoints = m_fields[0]->
780  GetBndCondExpansions()[bcRegion]->GetNpoints();
781 
782  Array<OneD,NekDouble> xb0(npoints, 0.0);
783  Array<OneD,NekDouble> xb1(npoints, 0.0);
784  Array<OneD,NekDouble> xb2(npoints, 0.0);
785 
786  m_fields[0]->GetBndCondExpansions()[bcRegion]->
787  GetCoords(xb0, xb1, xb2);
788 
789  for (int k = 0; k < npoints; k++)
790  {
791  Dist = sqrt((xb0[k] - x0[j]) * (xb0[k] - x0[j]) +
792  (xb1[k] - x1[j]) * (xb1[k] - x1[j]));
793 
794  SumDist += Dist;
795  rho += Dist * (m_fields[0]->
796  GetBndCondExpansions()[bcRegion]->GetPhys())[k];
797  rhou += Dist * (m_fields[1]->
798  GetBndCondExpansions()[bcRegion]->GetPhys())[k];
799  rhov += Dist * (m_fields[2]->
800  GetBndCondExpansions()[bcRegion]->GetPhys())[k];
801  E += Dist * (m_fields[3]->
802  GetBndCondExpansions()[bcRegion]->GetPhys())[k];
803  }
804  }
805 
806  rho = rho / SumDist;
807  rhou = rhou / SumDist;
808  rhov = rhov / SumDist;
809  E = E / SumDist;
810 
811  (m_fields[0]->UpdatePhys())[j] = rho;
812  (m_fields[1]->UpdatePhys())[j] = rhou;
813  (m_fields[2]->UpdatePhys())[j] = rhov;
814  (m_fields[3]->UpdatePhys())[j] = E;
815 
816  }
817 
818  for (int i = 0 ; i < m_fields.num_elements(); i++)
819  {
820  m_fields[i]->SetPhysState(true);
821  m_fields[i]->FwdTrans(m_fields[i]->GetPhys(),
822  m_fields[i]->UpdateCoeffs());
823  }
824 
825  // Dump initial conditions to file
826  std::string outname = m_sessionName + "_initialRingleb.chk";
827  WriteFld(outname);
828  }
Nektar::SolverUtils::EquationSystem::m_sessionName
std::string m_sessionName
Name of the session.
Definition: EquationSystem.h:433
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::SolverUtils::EquationSystem::WriteFld
SOLVER_UTILS_EXPORT void WriteFld(const std::string &outname)
Write field data to the given filename.
Definition: EquationSystem.cpp:2004
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:423
void Nektar::EulerCFE::v_EvaluateExactSolution ( unsigned int  field,
Array< OneD, NekDouble > &  outfield,
const NekDouble  time = 0.0 
)
protectedvirtual

Get the exact solutions for isentropic vortex and Ringleb flow problems.

Reimplemented from Nektar::SolverUtils::EquationSystem.

Definition at line 263 of file EulerCFE.cpp.

References Nektar::eIsentropicVortex, Nektar::eRinglebFlow, GetExactIsentropicVortex(), GetExactRinglebFlow(), and m_problemType.

267  {
268  switch(m_problemType)
269  {
270  case eIsentropicVortex:
271  {
272  GetExactIsentropicVortex(field, outfield, time);
273  break;
274  }
275  case eRinglebFlow:
276  {
277  GetExactRinglebFlow(field, outfield);
278  break;
279  }
280  default:
281  {
282  EquationSystem::v_EvaluateExactSolution(field, outfield, time);
283  break;
284  }
285  }
286  }
Nektar::eRinglebFlow
Ringleb Flow.
Definition: EulerCFE.h:47
Nektar::EulerCFE::GetExactIsentropicVortex
void GetExactIsentropicVortex(int field, Array< OneD, NekDouble > &outarray, NekDouble time)
Compute the exact solution for the isentropic vortex problem.
Definition: EulerCFE.cpp:332
Nektar::EulerCFE::GetExactRinglebFlow
void GetExactRinglebFlow(int field, Array< OneD, NekDouble > &outarray)
Ringleb Flow Test Case.
Definition: EulerCFE.cpp:438
Nektar::eIsentropicVortex
Isentropic Vortex.
Definition: EulerCFE.h:46
Nektar::EulerCFE::m_problemType
ProblemType m_problemType
Definition: EulerCFE.h:77
void Nektar::EulerCFE::v_GenerateSummary ( SolverUtils::SummaryList &  s)
protectedvirtual

Print a summary of time stepping parameters.

Print out a summary with some relevant information.

Reimplemented from Nektar::CompressibleFlowSystem.

Definition at line 102 of file EulerCFE.cpp.

References Nektar::SolverUtils::AddSummaryItem(), m_problemType, Nektar::ProblemTypeMap, and Nektar::CompressibleFlowSystem::v_GenerateSummary().

103  {
104  CompressibleFlowSystem::v_GenerateSummary(s);
105  SolverUtils::AddSummaryItem(s, "Problem Type", ProblemTypeMap[m_problemType]);
106  }
Nektar::CompressibleFlowSystem::v_GenerateSummary
virtual void v_GenerateSummary(SolverUtils::SummaryList &s)
Print a summary of time stepping parameters.
Definition: CompressibleFlowSystem.cpp:308
Nektar::SolverUtils::AddSummaryItem
void AddSummaryItem(SummaryList &l, const std::string &name, const std::string &value)
Adds a summary item to the summary info list.
Definition: Misc.cpp:50
Nektar::EulerCFE::m_problemType
ProblemType m_problemType
Definition: EulerCFE.h:77
Nektar::ProblemTypeMap
const char *const ProblemTypeMap[]
Definition: EulerADCFE.h:50
void Nektar::EulerCFE::v_InitObject ( )
protectedvirtual

Initialization object for CompressibleFlowSystem class.

Reimplemented from Nektar::CompressibleFlowSystem.

Definition at line 58 of file EulerCFE.cpp.

References ASSERTL0, Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), DoOdeProjection(), DoOdeRhs(), Nektar::SolverUtils::UnsteadySystem::m_explicitAdvection, Nektar::SolverUtils::UnsteadySystem::m_ode, m_problemType, Nektar::SolverUtils::EquationSystem::m_session, Nektar::ProblemTypeMap, Nektar::SIZE_ProblemType, and Nektar::CompressibleFlowSystem::v_InitObject().

59  {
60  CompressibleFlowSystem::v_InitObject();
61 
62  if(m_session->DefinesSolverInfo("PROBLEMTYPE"))
63  {
64  int i;
65  std::string ProblemTypeStr =
66  m_session->GetSolverInfo("PROBLEMTYPE");
67  for (i = 0; i < (int) SIZE_ProblemType; ++i)
68  {
69  if (boost::iequals(ProblemTypeMap[i], ProblemTypeStr))
70  {
71  m_problemType = (ProblemType)i;
72  break;
73  }
74  }
75  }
76  else
77  {
78  m_problemType = (ProblemType)0;
79  }
80 
81  if (m_explicitAdvection)
82  {
83  m_ode.DefineOdeRhs (&EulerCFE::DoOdeRhs, this);
84  m_ode.DefineProjection (&EulerCFE::DoOdeProjection, this);
85  }
86  else
87  {
88  ASSERTL0(false, "Implicit CFE not set up.");
89  }
90  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::CompressibleFlowSystem::v_InitObject
virtual void v_InitObject()
Initialization object for CompressibleFlowSystem class.
Definition: CompressibleFlowSystem.cpp:63
Nektar::SolverUtils::UnsteadySystem::m_ode
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
Definition: UnsteadySystem.h:67
Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationScheme.h:202
Nektar::EulerCFE::DoOdeProjection
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...
Definition: EulerCFE.cpp:173
Nektar::SolverUtils::UnsteadySystem::m_explicitAdvection
bool m_explicitAdvection
Indicates if explicit or implicit treatment of advection is used.
Definition: UnsteadySystem.h:75
Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationScheme.h:184
Nektar::SIZE_ProblemType
Length of enum list.
Definition: EulerADCFE.h:47
Nektar::EulerCFE::DoOdeRhs
void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Compute the right-hand side.
Definition: EulerCFE.cpp:142
Nektar::EulerCFE::m_problemType
ProblemType m_problemType
Definition: EulerCFE.h:77
Nektar::SolverUtils::EquationSystem::m_session
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Definition: EquationSystem.h:415
Nektar::ProblemType
ProblemType
Definition: EulerADCFE.h:44
Nektar::ProblemTypeMap
const char *const ProblemTypeMap[]
Definition: EulerADCFE.h:50
void Nektar::EulerCFE::v_SetInitialConditions ( NekDouble  initialtime = 0.0,
bool  dumpInitialConditions = true,
const int  domain = 0 
)
protectedvirtual

Set the initial conditions.

Reimplemented from Nektar::CompressibleFlowSystem.

Definition at line 111 of file EulerCFE.cpp.

References Nektar::SolverUtils::EquationSystem::Checkpoint_Output(), Nektar::eIsentropicVortex, Nektar::SolverUtils::EquationSystem::m_checksteps, m_problemType, SetInitialIsentropicVortex(), and Nektar::CompressibleFlowSystem::v_SetInitialConditions().

115  {
116  switch (m_problemType)
117  {
118  case eIsentropicVortex:
119  {
120  SetInitialIsentropicVortex(initialtime);
121  break;
122  }
123  default:
124  {
125  EquationSystem::v_SetInitialConditions(initialtime, false);
126  break;
127  }
128  }
129 
130  CompressibleFlowSystem::v_SetInitialConditions();
131 
132  if (dumpInitialConditions && m_checksteps)
133  {
134  // Dump initial conditions to file
135  Checkpoint_Output(0);
136  }
137  }
Nektar::EulerCFE::SetInitialIsentropicVortex
void SetInitialIsentropicVortex(NekDouble initialtime)
Set the initial condition for the isentropic vortex problem.
Definition: EulerCFE.cpp:358
Nektar::SolverUtils::EquationSystem::Checkpoint_Output
SOLVER_UTILS_EXPORT void Checkpoint_Output(const int n)
Write checkpoint file of m_fields.
Definition: EquationSystem.cpp:1964
Nektar::SolverUtils::EquationSystem::m_checksteps
int m_checksteps
Number of steps between checkpoints.
Definition: EquationSystem.h:447
Nektar::eIsentropicVortex
Isentropic Vortex.
Definition: EulerCFE.h:46
Nektar::EulerCFE::m_problemType
ProblemType m_problemType
Definition: EulerCFE.h:77
Nektar::CompressibleFlowSystem::v_SetInitialConditions
virtual void v_SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)

Friends And Related Function Documentation

friend class MemoryManager< EulerCFE >
friend

Definition at line 61 of file EulerCFE.h.

Member Data Documentation

string Nektar::EulerCFE::className
static
Initial value:
=
SolverUtils::GetEquationSystemFactory().RegisterCreatorFunction(
"EulerCFE", EulerCFE::create,
"Euler equations in conservative variables without "
"artificial diffusion.")

Name of class.

Definition at line 72 of file EulerCFE.h.

ProblemType Nektar::EulerCFE::m_problemType

Definition at line 77 of file EulerCFE.h.

Referenced by v_EvaluateExactSolution(), v_GenerateSummary(), v_InitObject(), and v_SetInitialConditions().

Generated on Tue Dec 8 2015 23:45:34 for Nektar++ by   doxygen 1.8.9.1