#include <EulerADCFE.h>

Inheritance diagram for Nektar::EulerADCFE:

Collaboration diagram for Nektar::EulerADCFE:

Public Member Functions
virtual	~EulerADCFE ()
	problem type selector
Public Member Functions inherited from Nektar::CompressibleFlowSystem
virtual	~CompressibleFlowSystem ()
	Destructor for CompressibleFlowSystem class.
NekDouble	GetStabilityLimit (int n)
	Function to calculate the stability limit for DG/CG.
Array< OneD, NekDouble >	GetStabilityLimitVector (const Array< OneD, int > &ExpOrder)
	Function to calculate the stability limit for DG/CG (a vector of them).
Public Member Functions inherited from Nektar::SolverUtils::UnsteadySystem
virtual SOLVER_UTILS_EXPORT	~UnsteadySystem ()
	Destructor.
SOLVER_UTILS_EXPORT NekDouble	GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray)
	Calculate the larger time-step mantaining the problem stable.
Public Member Functions inherited from Nektar::SolverUtils::EquationSystem
virtual SOLVER_UTILS_EXPORT	~EquationSystem ()
	Destructor.
SOLVER_UTILS_EXPORT void	SetUpTraceNormals (void)
SOLVER_UTILS_EXPORT void	InitObject ()
	Initialises the members of this object.
SOLVER_UTILS_EXPORT void	DoInitialise ()
	Perform any initialisation necessary before solving the problem.
SOLVER_UTILS_EXPORT void	DoSolve ()
	Solve the problem.
SOLVER_UTILS_EXPORT void	TransCoeffToPhys ()
	Transform from coefficient to physical space.
SOLVER_UTILS_EXPORT void	TransPhysToCoeff ()
	Transform from physical to coefficient space.
SOLVER_UTILS_EXPORT void	Output ()
	Perform output operations after solve.
SOLVER_UTILS_EXPORT NekDouble	LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray)
	Linf error computation.
SOLVER_UTILS_EXPORT std::string	GetSessionName ()
	Get Session name.
template<class T >
boost::shared_ptr< T >	as ()
SOLVER_UTILS_EXPORT void	ResetSessionName (std::string newname)
	Reset Session name.
SOLVER_UTILS_EXPORT LibUtilities::SessionReaderSharedPtr	GetSession ()
	Get Session name.
SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr	GetPressure ()
	Get pressure field if available.
SOLVER_UTILS_EXPORT void	PrintSummary (std::ostream &out)
	Print a summary of parameters and solver characteristics.
SOLVER_UTILS_EXPORT void	SetLambda (NekDouble lambda)
	Set parameter m_lambda.
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.
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.
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.
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.
SOLVER_UTILS_EXPORT void	InitialiseBaseFlow (Array< OneD, Array< OneD, NekDouble > > &base)
	Perform initialisation of the base flow.
SOLVER_UTILS_EXPORT void	SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
	Initialise the data in the dependent fields.
SOLVER_UTILS_EXPORT void	EvaluateExactSolution (int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
	Evaluates an exact solution.
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.
SOLVER_UTILS_EXPORT NekDouble	L2Error (unsigned int field, bool Normalised=false)
	Compute the L2 error of the fields.
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].
SOLVER_UTILS_EXPORT void	WeakAdvectionGreensDivergenceForm (const Array< OneD, Array< OneD, NekDouble > > &F, Array< OneD, NekDouble > &outarray)
	Compute the inner product $(\nabla \phi \cdot F)$ .
SOLVER_UTILS_EXPORT void	WeakAdvectionDivergenceForm (const Array< OneD, Array< OneD, NekDouble > > &F, Array< OneD, NekDouble > &outarray)
	Compute the inner product $(\phi, \nabla \cdot F)$ .
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)$ .
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.
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.
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.
SOLVER_UTILS_EXPORT void	Checkpoint_Output (const int n)
	Write checkpoint file of m_fields.
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.
SOLVER_UTILS_EXPORT void	Checkpoint_BaseFlow (const int n)
	Write base flow file of m_fields.
SOLVER_UTILS_EXPORT void	WriteFld (const std::string &outname)
	Write field data to the given filename.
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.
SOLVER_UTILS_EXPORT void	ImportFld (const std::string &infile, Array< OneD, MultiRegions::ExpListSharedPtr > &pFields)
	Input field data from the given file.
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.
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.
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.
SOLVER_UTILS_EXPORT void	ScanForHistoryPoints ()
	Builds map of which element holds each history point.
SOLVER_UTILS_EXPORT void	WriteHistoryData (std::ostream &out)
	Probe each history point and write to file.
SOLVER_UTILS_EXPORT void	SessionSummary (SummaryList &vSummary)
	Write out a session summary.
SOLVER_UTILS_EXPORT Array < OneD, MultiRegions::ExpListSharedPtr > &	UpdateFields ()
SOLVER_UTILS_EXPORT LibUtilities::FieldMetaDataMap &	UpdateFieldMetaDataMap ()
	Get hold of FieldInfoMap so it can be updated.
SOLVER_UTILS_EXPORT NekDouble	GetFinalTime ()
	Return final time.
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.

Static Public Member Functions
static SolverUtils::EquationSystemSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession)
	Creates an instance of this class.

Public Attributes
ProblemType	m_problemType

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

Protected Member Functions
	EulerADCFE (const LibUtilities::SessionReaderSharedPtr &pSession)
virtual void	v_InitObject ()
	Initialization object for CompressibleFlowSystem class.
virtual void	v_GenerateSummary (SolverUtils::SummaryList &s)
	Print a summary of time stepping parameters.
void	DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
void	DoOdeProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
virtual void	v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
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.
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.
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.
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.
void	WallBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
	Wall boundary conditions for compressible flow problems.
void	WallViscousBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
	Wall boundary conditions for viscous compressible flow problems.
void	SymmetryBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
	Symmetry boundary conditions for compressible flow problems.
void	RiemannInvariantBC (int bcRegion, int cnt, Array< OneD, Array< OneD, NekDouble > > &physarray)
	Outflow characteristic boundary conditions for compressible flow problems.
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.
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.
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)
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.
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.
SOLVER_UTILS_EXPORT NekDouble	MaxTimeStepEstimator ()
	Get the maximum timestep estimator for cfl control.
virtual SOLVER_UTILS_EXPORT void	v_DoSolve ()
	Solves an unsteady problem.
virtual SOLVER_UTILS_EXPORT void	v_DoInitialise ()
	Sets up initial conditions.
virtual SOLVER_UTILS_EXPORT void	v_AppendOutput1D (Array< OneD, Array< OneD, NekDouble > > &solution1D)
	Print the solution at each solution point in a txt file.
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_PostIntegrate (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.
int	nocase_cmp (const string &s1, const string &s2)
SOLVER_UTILS_EXPORT void	SetBoundaryConditions (NekDouble time)
	Evaluates the boundary conditions at the given time.
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.
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.
virtual SOLVER_UTILS_EXPORT void	v_TransCoeffToPhys ()
	Virtual function for transformation to physical space.
virtual SOLVER_UTILS_EXPORT void	v_TransPhysToCoeff ()
	Virtual function for transformation to coefficient space.
virtual SOLVER_UTILS_EXPORT void	v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time)
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)

Friends
class	MemoryManager< EulerADCFE >

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_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
StdRegions::StdQuadExpSharedPtr	m_OrthoQuadExp
StdRegions::StdHexExpSharedPtr	m_OrthoHexExp
bool	m_smoothDiffusion

Detailed Description

Definition at line 59 of file EulerADCFE.h.

Constructor & Destructor Documentation

Nektar::EulerADCFE::~EulerADCFE ( )

virtual

problem type selector

Definition at line 100 of file EulerADCFE.cpp.

    {
        
    }

Nektar::EulerADCFE::EulerADCFE ( const LibUtilities::SessionReaderSharedPtr & pSession )

protected

Definition at line 48 of file EulerADCFE.cpp.

    : CompressibleFlowSystem(pSession)
    {
    }

Member Function Documentation

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

inlinestatic

Creates an instance of this class.

Reimplemented from Nektar::CompressibleFlowSystem.

Definition at line 65 of file EulerADCFE.h.

        {
            SolverUtils::EquationSystemSharedPtr p = MemoryManager<
                EulerADCFE>::AllocateSharedPtr(pSession);
            p->InitObject();
            return p;
        }

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

protected

Definition at line 227 of file EulerADCFE.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().

    {
        int i;
        int nvariables = inarray.num_elements();
        
        switch(m_projectionType)
        {
            case MultiRegions::eDiscontinuous:
            {
                // Just copy over array
                int npoints = GetNpoints();
                
                for(i = 0; i < nvariables; ++i)
                {
                    Vmath::Vcopy(npoints, inarray[i], 1, outarray[i], 1);
                }
                SetBoundaryConditions(outarray, time);
                break;
            }
            case MultiRegions::eGalerkin:
            case MultiRegions::eMixed_CG_Discontinuous:
            {
                ASSERTL0(false, "No Continuous Galerkin for Euler equations");
                break;
            }
            default:
                ASSERTL0(false, "Unknown projection scheme");
                break;
        }
    }

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

protected

Definition at line 126 of file EulerADCFE.cpp.

References Nektar::CompressibleFlowSystem::GetAbsoluteVelocity(), Nektar::CompressibleFlowSystem::GetForcingTerm(), Nektar::SolverUtils::EquationSystem::GetNpoints(), Nektar::SolverUtils::EquationSystem::GetNumExpModesPerExp(), Nektar::SolverUtils::EquationSystem::GetPressure(), Nektar::CompressibleFlowSystem::GetSoundSpeed(), Nektar::CompressibleFlowSystem::m_advection, Nektar::CompressibleFlowSystem::m_C2, Nektar::CompressibleFlowSystem::m_diffusion, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::CompressibleFlowSystem::m_shockCaptureType, Nektar::SolverUtils::EquationSystem::m_time, Vmath::Neg(), Vmath::Smul(), Vmath::Vadd(), and Vmath::Vmax().

Referenced by v_InitObject().

    {
        int i;
        int nvariables = inarray.num_elements();
        int npoints    = GetNpoints();
        
        Array<OneD, Array<OneD, NekDouble> > advVel;
        Array<OneD, Array<OneD, NekDouble> > outarrayAdv(nvariables);
        Array<OneD, Array<OneD, NekDouble> > outarrayDiff(nvariables);
        for (i = 0; i < nvariables; ++i)
        {
            outarrayAdv[i] = Array<OneD, NekDouble>(npoints, 0.0);
            outarrayDiff[i] = Array<OneD, NekDouble>(npoints, 0.0);
        }
        
        m_advection->Advect(nvariables, m_fields, advVel, inarray,
                                        outarrayAdv, m_time);
        
        for (i = 0; i < nvariables; ++i)
        {
            Vmath::Neg(npoints, outarrayAdv[i], 1);
        }
        
        m_diffusion->Diffuse(nvariables, m_fields, inarray, outarrayDiff);
        
        if (m_shockCaptureType == "NonSmooth")
        {
            for (i = 0; i < nvariables; ++i)
            {
                Vmath::Vadd(npoints,
                            outarrayAdv[i], 1,
                            outarrayDiff[i], 1,
                            outarray[i], 1);
            }
        }
        if(m_shockCaptureType == "Smooth")
        {
            const Array<OneD, int> ExpOrder = GetNumExpModesPerExp();
            
            NekDouble pOrder = Vmath::Vmax(ExpOrder.num_elements(), ExpOrder, 1);
            
            Array <OneD, NekDouble > a_vel  (npoints, 0.0);
            Array <OneD, NekDouble > u_abs  (npoints, 0.0);
            Array <OneD, NekDouble > pres   (npoints, 0.0);
            Array <OneD, NekDouble > wave_sp(npoints, 0.0);
            
            GetPressure(inarray, pres);
            GetSoundSpeed(inarray, pres, a_vel);
            GetAbsoluteVelocity(inarray, u_abs);
            
            Vmath::Vadd(npoints, a_vel, 1, u_abs, 1, wave_sp, 1);
            
            NekDouble max_wave_sp = Vmath::Vmax(npoints, wave_sp, 1);
            
            Vmath::Smul(npoints,
                        m_C2,
                        outarrayDiff[nvariables-1], 1,
                        outarrayDiff[nvariables-1], 1);
            
            Vmath::Smul(npoints,
                        max_wave_sp,
                        outarrayDiff[nvariables-1], 1,
                        outarrayDiff[nvariables-1], 1);
            
            Vmath::Smul(npoints,
                        pOrder,
                        outarrayDiff[nvariables-1], 1,
                        outarrayDiff[nvariables-1], 1);
            
            for (i = 0; i < nvariables; ++i)
            {
                Vmath::Vadd(npoints,
                            outarrayAdv[i], 1,
                            outarrayDiff[i], 1,
                            outarray[i], 1);
            }
            
            Array<OneD, Array<OneD, NekDouble> > outarrayForcing(nvariables);
            
            for (i = 0; i < nvariables; ++i)
            {
                outarrayForcing[i] = Array<OneD, NekDouble>(npoints, 0.0);
            }
            
            GetForcingTerm(inarray, outarrayForcing);
            
            for (i = 0; i < nvariables; ++i)
            {
                // Add Forcing Term
                Vmath::Vadd(npoints,
                            outarray[i], 1,
                            outarrayForcing[i], 1,
                            outarray[i], 1);
            }
        }
    }

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

private

Definition at line 261 of file EulerADCFE.cpp.

References ASSERTL0, Nektar::SpatialDomains::eExtrapOrder0, Nektar::SpatialDomains::eRiemannInvariant, Nektar::SpatialDomains::eSymmetry, Nektar::SpatialDomains::eTimeDependent, Nektar::SpatialDomains::eWall, Nektar::SpatialDomains::eWallViscous, Nektar::CompressibleFlowSystem::ExtrapOrder0BC(), Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_session, Nektar::CompressibleFlowSystem::RiemannInvariantBC(), Nektar::CompressibleFlowSystem::SymmetryBC(), and Nektar::CompressibleFlowSystem::WallBC().

Referenced by DoOdeProjection().

    {    
        std::string varName;
        int nvariables = m_fields.num_elements();
        int cnt        = 0;
        
        // loop over Boundary Regions
        for (int n = 0; n < m_fields[0]->GetBndConditions().num_elements(); ++n)
        {
            // Wall Boundary Condition
            if (m_fields[0]->GetBndConditions()[n]->GetUserDefined() ==
                SpatialDomains::eWall)
            {
                WallBC(n, cnt, inarray);
            }
            
            // Wall Boundary Condition
            if (m_fields[0]->GetBndConditions()[n]->GetUserDefined() ==
                SpatialDomains::eWallViscous)
            {
                ASSERTL0(false, "WallViscous is a wrong bc for the "
                "Euler equations");
            }
            
            // Symmetric Boundary Condition
            if (m_fields[0]->GetBndConditions()[n]->GetUserDefined() == 
                SpatialDomains::eSymmetry)
            {
                SymmetryBC(n, cnt, inarray);
            }
            
            // Riemann invariant characteristic Boundary Condition (CBC)
            if (m_fields[0]->GetBndConditions()[n]->GetUserDefined() == 
                SpatialDomains::eRiemannInvariant)
            {
                RiemannInvariantBC(n, cnt, inarray);
            }
            
            // Extrapolation of the data at the boundaries
            if (m_fields[0]->GetBndConditions()[n]->GetUserDefined() == 
                SpatialDomains::eExtrapOrder0)
            {
                ExtrapOrder0BC(n, cnt, inarray);
            }
            
            // Time Dependent Boundary Condition (specified in meshfile)
            if (m_fields[0]->GetBndConditions()[n]->GetUserDefined() 
                == SpatialDomains::eTimeDependent)
            {
                for (int i = 0; i < nvariables; ++i)
                {
                    varName = m_session->GetVariable(i);
                    m_fields[i]->EvaluateBoundaryConditions(time, varName);
                }
            }
            
            cnt += m_fields[0]->GetBndCondExpansions()[n]->GetExpSize();
        }
    }

void Nektar::EulerADCFE::v_GenerateSummary ( SolverUtils::SummaryList & s )

protectedvirtual

Print a summary of time stepping parameters.

Reimplemented from Nektar::CompressibleFlowSystem.

Definition at line 105 of file EulerADCFE.cpp.

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

    {
        CompressibleFlowSystem::v_GenerateSummary(s);
        SolverUtils::AddSummaryItem(
            s, "Problem Type", ProblemTypeMap[m_problemType]);
    }

void Nektar::EulerADCFE::v_InitObject ( )

protectedvirtual

Initialization object for CompressibleFlowSystem class.

Reimplemented from Nektar::CompressibleFlowSystem.

Definition at line 54 of file EulerADCFE.cpp.

References ASSERTL0, Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), DoOdeProjection(), DoOdeRhs(), Nektar::CompressibleFlowSystem::GetArtificialDynamicViscosity(), Nektar::CompressibleFlowSystem::m_diffusion, Nektar::SolverUtils::UnsteadySystem::m_explicitAdvection, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::UnsteadySystem::m_ode, m_problemType, Nektar::SolverUtils::EquationSystem::m_session, Nektar::CompressibleFlowSystem::m_shockCaptureType, Nektar::CompressibleFlowSystem::m_smoothDiffusion, Nektar::SolverUtils::EquationSystem::m_spacedim, Nektar::ProblemTypeMap, and Nektar::SIZE_ProblemType.

    {
        CompressibleFlowSystem::v_InitObject();
        
        if (m_shockCaptureType == "Smooth")
        {
            ASSERTL0(m_fields.num_elements() == m_spacedim + 3,
                     "Not enough variables for smooth shock capturing; "
                     "make sure you have added eps to variable list.");
            m_smoothDiffusion = true;
        }
        
        m_diffusion->SetArtificialDiffusionVector(
            &EulerADCFE::GetArtificialDynamicViscosity, this);
        
        if(m_session->DefinesSolverInfo("PROBLEMTYPE"))
        {
            std::string ProblemTypeStr = m_session->GetSolverInfo("PROBLEMTYPE");
            int i;
            for(i = 0; i < (int) SIZE_ProblemType; ++i)
            {
                if(boost::iequals(ProblemTypeMap[i], ProblemTypeStr))
                {
                    m_problemType = (ProblemType)i;
                    break;
                }
            }
        }
        else
        {
            m_problemType = (ProblemType)0;
        }
        
        if (m_explicitAdvection)
        {
            m_ode.DefineOdeRhs    (&EulerADCFE::
            DoOdeRhs, this);
            m_ode.DefineProjection(&EulerADCFE::
            DoOdeProjection, this);
        }
        else
        {
            ASSERTL0(false, "Implicit CFE not set up.");
        }
    }

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

protectedvirtual

Set the physical fields based on a restart file, or a function describing the initial condition given in the session.

Parameters

initialtime	Time at which to evaluate the function.
dumpInitialConditions	Write the initial condition to file?

Reimplemented from Nektar::CompressibleFlowSystem.

Definition at line 112 of file EulerADCFE.cpp.

References Nektar::SolverUtils::EquationSystem::Checkpoint_Output().

    {
        EquationSystem::v_SetInitialConditions(initialtime, false);
        
        if(dumpInitialConditions)
        {
            // Dump initial conditions to file
            Checkpoint_Output(0);
        }
    }

Friends And Related Function Documentation

friend class MemoryManager< EulerADCFE >

friend

Definition at line 62 of file EulerADCFE.h.

Member Data Documentation

string Nektar::EulerADCFE::className

static

Initial value:

    SolverUtils::GetEquationSystemFactory().RegisterCreatorFunction(
        "EulerADCFE", EulerADCFE::create,
        "Euler equations in conservative variables with "
        "artificial diffusion.")

Name of class.

Definition at line 74 of file EulerADCFE.h.

ProblemType Nektar::EulerADCFE::m_problemType

Definition at line 79 of file EulerADCFE.h.

Referenced by v_GenerateSummary(), and v_InitObject().

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Private Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation