Nektar::HLLCSolver Class Reference

#include <HLLCSolver.h>

Inheritance diagram for Nektar::HLLCSolver:

Static Public Member Functions
static RiemannSolverSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession)
static RiemannSolverSharedPtr	create (const LibUtilities::SessionReaderSharedPtr &pSession)

Static Public Attributes
static std::string	solverName

Protected Member Functions
	HLLCSolver (const LibUtilities::SessionReaderSharedPtr &pSession)
void	v_PointSolve (NekDouble rhoL, NekDouble rhouL, NekDouble rhovL, NekDouble rhowL, NekDouble EL, NekDouble rhoR, NekDouble rhouR, NekDouble rhovR, NekDouble rhowR, NekDouble ER, NekDouble &rhof, NekDouble &rhouf, NekDouble &rhovf, NekDouble &rhowf, NekDouble &Ef) override
	HLLC Riemann solver. More...
	HLLCSolver (const LibUtilities::SessionReaderSharedPtr &pSession)
void	v_PointSolve (NekDouble hL, NekDouble huL, NekDouble hvL, NekDouble hR, NekDouble huR, NekDouble hvR, NekDouble &hf, NekDouble &huf, NekDouble &hvf) override
	HLLC Riemann solver for the Nonlinear Shallow Water Equations. More...
Protected Member Functions inherited from Nektar::CompressibleSolver
	CompressibleSolver (const LibUtilities::SessionReaderSharedPtr &pSession)
	Session ctor. More...
	CompressibleSolver ()
	Programmatic ctor. More...
void	v_Solve (const int nDim, const Array< OneD, const Array< OneD, ND > > &Fwd, const Array< OneD, const Array< OneD, ND > > &Bwd, Array< OneD, Array< OneD, ND > > &flux) override
virtual void	v_ArraySolve (const Array< OneD, const Array< OneD, ND > > &Fwd, const Array< OneD, const Array< OneD, ND > > &Bwd, Array< OneD, Array< OneD, ND > > &flux)
virtual void	v_PointSolve (ND rhoL, ND rhouL, ND rhovL, ND rhowL, ND EL, ND rhoR, ND rhouR, ND rhovR, ND rhowR, ND ER, ND &rhof, ND &rhouf, ND &rhovf, ND &rhowf, ND &Ef)
ND	GetRoeSoundSpeed (ND rhoL, ND pL, ND eL, ND HL, ND srL, ND rhoR, ND pR, ND eR, ND HR, ND srR, ND HRoe, ND URoe2, ND srLR)
Protected Member Functions inherited from Nektar::SolverUtils::RiemannSolver
SOLVER_UTILS_EXPORT	RiemannSolver ()
SOLVER_UTILS_EXPORT	RiemannSolver (const LibUtilities::SessionReaderSharedPtr &pSession)
virtual SOLVER_UTILS_EXPORT	~RiemannSolver ()
virtual void	v_Solve (const int nDim, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, Array< OneD, Array< OneD, NekDouble > > &flux)=0
SOLVER_UTILS_EXPORT void	GenerateRotationMatrices (const Array< OneD, const Array< OneD, NekDouble > > &normals)
	Generate rotation matrices for 3D expansions. More...
void	FromToRotation (Array< OneD, const NekDouble > &from, Array< OneD, const NekDouble > &to, NekDouble *mat)
	A function for creating a rotation matrix that rotates a vector from into another vector to. More...
SOLVER_UTILS_EXPORT void	rotateToNormal (const Array< OneD, const Array< OneD, NekDouble > > &inarray, const Array< OneD, const Array< OneD, NekDouble > > &normals, const Array< OneD, const Array< OneD, NekDouble > > &vecLocs, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Rotate a vector field to trace normal. More...
SOLVER_UTILS_EXPORT void	rotateFromNormal (const Array< OneD, const Array< OneD, NekDouble > > &inarray, const Array< OneD, const Array< OneD, NekDouble > > &normals, const Array< OneD, const Array< OneD, NekDouble > > &vecLocs, Array< OneD, Array< OneD, NekDouble > > &outarray)
	Rotate a vector field from trace normal. More...
SOLVER_UTILS_EXPORT bool	CheckScalars (std::string name)
	Determine whether a scalar has been defined in m_scalars. More...
SOLVER_UTILS_EXPORT bool	CheckVectors (std::string name)
	Determine whether a vector has been defined in m_vectors. More...
SOLVER_UTILS_EXPORT bool	CheckParams (std::string name)
	Determine whether a parameter has been defined in m_params. More...
SOLVER_UTILS_EXPORT bool	CheckAuxScal (std::string name)
	Determine whether a scalar has been defined in m_auxScal. More...
SOLVER_UTILS_EXPORT bool	CheckAuxVec (std::string name)
	Determine whether a vector has been defined in m_auxVec. More...
virtual SOLVER_UTILS_EXPORT void	v_CalcFluxJacobian (const int nDim, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, const Array< OneD, const Array< OneD, NekDouble > > &normals, DNekBlkMatSharedPtr &FJac, DNekBlkMatSharedPtr &BJac)
Protected Member Functions inherited from Nektar::NonlinearSWESolver
	NonlinearSWESolver (const LibUtilities::SessionReaderSharedPtr &pSession)
void	v_Solve (const int nDim, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, Array< OneD, Array< OneD, NekDouble > > &flux) override
virtual void	v_ArraySolve (const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, Array< OneD, Array< OneD, NekDouble > > &flux)
virtual void	v_PointSolve (NekDouble hL, NekDouble huL, NekDouble hvL, NekDouble hR, NekDouble huR, NekDouble hvR, NekDouble &hf, NekDouble &huf, NekDouble &hvf)

Additional Inherited Members
Public Member Functions inherited from Nektar::SolverUtils::RiemannSolver
SOLVER_UTILS_EXPORT void	Solve (const int nDim, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, Array< OneD, Array< OneD, NekDouble > > &flux)
	Perform the Riemann solve given the forwards and backwards spaces. More...
template<typename FuncPointerT , typename ObjectPointerT >
void	SetScalar (std::string name, FuncPointerT func, ObjectPointerT obj)
void	SetScalar (std::string name, RSScalarFuncType fp)
template<typename FuncPointerT , typename ObjectPointerT >
void	SetVector (std::string name, FuncPointerT func, ObjectPointerT obj)
void	SetVector (std::string name, RSVecFuncType fp)
template<typename FuncPointerT , typename ObjectPointerT >
void	SetParam (std::string name, FuncPointerT func, ObjectPointerT obj)
void	SetALEFlag (bool &ALE)
void	SetParam (std::string name, RSParamFuncType fp)
template<typename FuncPointerT , typename ObjectPointerT >
void	SetAuxScal (std::string name, FuncPointerT func, ObjectPointerT obj)
template<typename FuncPointerT , typename ObjectPointerT >
void	SetAuxVec (std::string name, FuncPointerT func, ObjectPointerT obj)
void	SetAuxVec (std::string name, RSVecFuncType fp)
std::map< std::string, RSScalarFuncType > &	GetScalars ()
std::map< std::string, RSVecFuncType > &	GetVectors ()
std::map< std::string, RSParamFuncType > &	GetParams ()
SOLVER_UTILS_EXPORT void	CalcFluxJacobian (const int nDim, const Array< OneD, const Array< OneD, NekDouble > > &Fwd, const Array< OneD, const Array< OneD, NekDouble > > &Bwd, DNekBlkMatSharedPtr &FJac, DNekBlkMatSharedPtr &BJac)
	Calculate the flux jacobian of Fwd and Bwd. More...
Public Attributes inherited from Nektar::SolverUtils::RiemannSolver
int	m_spacedim
Protected Types inherited from Nektar::CompressibleSolver
using	ND = NekDouble
Protected Attributes inherited from Nektar::CompressibleSolver
bool	m_pointSolve
EquationOfStateSharedPtr	m_eos
bool	m_idealGas
Protected Attributes inherited from Nektar::SolverUtils::RiemannSolver
bool	m_requiresRotation
	Indicates whether the Riemann solver requires a rotation to be applied to the velocity fields. More...
std::map< std::string, RSScalarFuncType >	m_scalars
	Map of scalar function types. More...
std::map< std::string, RSVecFuncType >	m_vectors
	Map of vector function types. More...
std::map< std::string, RSParamFuncType >	m_params
	Map of parameter function types. More...
std::map< std::string, RSScalarFuncType >	m_auxScal
	Map of auxiliary scalar function types. More...
std::map< std::string, RSVecFuncType >	m_auxVec
	Map of auxiliary vector function types. More...
Array< OneD, Array< OneD, NekDouble > >	m_rotMat
	Rotation matrices for each trace quadrature point. More...
Array< OneD, Array< OneD, Array< OneD, NekDouble > > >	m_rotStorage
	Rotation storage. More...
bool	m_ALESolver = false
	Flag if using the ALE formulation. More...
Protected Attributes inherited from Nektar::NonlinearSWESolver
bool	m_pointSolve

Detailed Description

Definition at line 42 of file CompressibleFlowSolver/RiemannSolvers/HLLCSolver.h.

Constructor & Destructor Documentation

HLLCSolver() [1/2]

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

protected

Definition at line 43 of file CompressibleFlowSolver/RiemannSolvers/HLLCSolver.cpp.

    : CompressibleSolver(pSession)
{
}

Referenced by create().

HLLCSolver() [2/2]

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

protected

Member Function Documentation

create() [1/2]

static RiemannSolverSharedPtr Nektar::HLLCSolver::create ( const LibUtilities::SessionReaderSharedPtr &  pSession )

inlinestatic

Definition at line 45 of file CompressibleFlowSolver/RiemannSolvers/HLLCSolver.h.

    {
        return RiemannSolverSharedPtr(new HLLCSolver(pSession));
    }

References HLLCSolver().

create() [2/2]

static RiemannSolverSharedPtr Nektar::HLLCSolver::create ( const LibUtilities::SessionReaderSharedPtr &  pSession )

inlinestatic

Definition at line 45 of file ShallowWaterSolver/RiemannSolvers/HLLCSolver.h.

    {
        return RiemannSolverSharedPtr(new HLLCSolver(pSession));
    }

References HLLCSolver().

v_PointSolve() [1/2]

void Nektar::HLLCSolver::v_PointSolve ( NekDouble  hL, NekDouble  huL, NekDouble  hvL, NekDouble  hR, NekDouble  huR, NekDouble  hvR, NekDouble &  hf, NekDouble &  huf, NekDouble &  hvf  )

overrideprotectedvirtual

HLLC Riemann solver for the Nonlinear Shallow Water Equations.

Parameters

hL	Water depth left state.
hR	Water depth right state.
huL	x-momentum component left state.
huR	x-momentum component right state.
hvL	y-momentum component left state.
hvR	y-momentum component right state.
hf	Computed Riemann flux for density.
huf	Computed Riemann flux for x-momentum component
hvf	Computed Riemann flux for y-momentum component

Reimplemented from Nektar::NonlinearSWESolver.

Definition at line 61 of file ShallowWaterSolver/RiemannSolvers/HLLCSolver.cpp.

{
    static NekDouble g = m_params["gravity"]();
 
    // Left and Right velocities
    NekDouble uL = huL / hL;
    NekDouble vL = hvL / hL;
    NekDouble uR = huR / hR;
    NekDouble vR = hvR / hR;
 
    // Left and right wave speeds
    NekDouble cL = sqrt(g * hL);
    NekDouble cR = sqrt(g * hR);
 
    // the two-rarefaction wave assumption
    NekDouble hC, huC, hvC, SL, SR, hstar, ustar, Sstar;
    hstar = 0.5 * (cL + cR) + 0.25 * (uL - uR);
    hstar *= hstar;
    hstar *= (1.0 / g);
    ustar = 0.5 * (uL + uR) + cL - cR;
 
    // Compute SL
    if (hstar > hL)
    {
        SL = uL - cL * sqrt(0.5 * ((hstar * hstar + hstar * hL) / (hL * hL)));
    }
    else
    {
        SL = uL - cL;
    }
 
    // Compute SR
    if (hstar > hR)
    {
        SR = uR + cR * sqrt(0.5 * ((hstar * hstar + hstar * hR) / (hR * hR)));
    }
    else
    {
        SR = uR + cR;
    }
 
    if (fabs(hR * (uR - SR) - hL * (uL - SL)) <= 1.0e-10)
    {
        Sstar = ustar;
    }
    else
    {
        Sstar = (SL * hR * (uR - SR) - SR * hL * (uL - SL)) /
                (hR * (uR - SR) - hL * (uL - SL));
    }
 
    if (SL >= 0)
    {
        hf  = hL * uL;
        huf = uL * uL * hL + 0.5 * g * hL * hL;
        hvf = hL * uL * vL;
    }
    else if (SR <= 0)
    {
        hf  = hR * uR;
        huf = uR * uR * hR + 0.5 * g * hR * hR;
        hvf = hR * uR * vR;
    }
    else if ((SL < 0) && (Sstar >= 0))
    {
        hC  = hL * ((SL - uL) / (SL - Sstar));
        huC = hC * Sstar;
        hvC = hC * vL;
 
        hf  = hL * uL + SL * (hC - hL);
        huf = (uL * uL * hL + 0.5 * g * hL * hL) + SL * (huC - hL * uL);
        hvf = (uL * vL * hL) + SL * (hvC - hL * vL);
    }
    else if ((SR > 0) && (Sstar <= 0))
    {
        hC  = hR * ((SR - uR) / (SR - Sstar));
        huC = hC * Sstar;
        hvC = hC * vR;
 
        hf  = hR * uR + SR * (hC - hR);
        huf = (uR * uR * hR + 0.5 * g * hR * hR) + SR * (huC - hR * uR);
        hvf = (uR * vR * hR) + SR * (hvC - hR * vR);
    }
    else
    {
        NEKERROR(ErrorUtil::efatal,
                 "Error in HLLC solver -- non physical combination of "
                 "SR, SL and Sstar");
    }
}

References NEKERROR, and tinysimd::sqrt().

v_PointSolve() [2/2]

void Nektar::HLLCSolver::v_PointSolve ( NekDouble  rhoL, NekDouble  rhouL, NekDouble  rhovL, NekDouble  rhowL, NekDouble  EL, NekDouble  rhoR, NekDouble  rhouR, NekDouble  rhovR, NekDouble  rhowR, NekDouble  ER, NekDouble &  rhof, NekDouble &  rhouf, NekDouble &  rhovf, NekDouble &  rhowf, NekDouble &  Ef  )

overrideprotectedvirtual

HLLC Riemann solver.

Parameters

rhoL	Density left state.
rhoR	Density right state.
rhouL	x-momentum component left state.
rhouR	x-momentum component right state.
rhovL	y-momentum component left state.
rhovR	y-momentum component right state.
rhowL	z-momentum component left state.
rhowR	z-momentum component right state.
EL	Energy left state.
ER	Energy right state.
rhof	Computed Riemann flux for density.
rhouf	Computed Riemann flux for x-momentum component
rhovf	Computed Riemann flux for y-momentum component
rhowf	Computed Riemann flux for z-momentum component
Ef	Computed Riemann flux for energy.

Reimplemented from Nektar::CompressibleSolver.

Definition at line 67 of file CompressibleFlowSolver/RiemannSolvers/HLLCSolver.cpp.

{
    // Left and Right velocities
    NekDouble uL = rhouL / rhoL;
    NekDouble vL = rhovL / rhoL;
    NekDouble wL = rhowL / rhoL;
    NekDouble uR = rhouR / rhoR;
    NekDouble vR = rhovR / rhoR;
    NekDouble wR = rhowR / rhoR;
 
    // Internal energy (per unit mass)
    NekDouble eL = (EL - 0.5 * (rhouL * uL + rhovL * vL + rhowL * wL)) / rhoL;
    NekDouble eR = (ER - 0.5 * (rhouR * uR + rhovR * vR + rhowR * wR)) / rhoR;
    // Pressure
    NekDouble pL = m_eos->GetPressure(rhoL, eL);
    NekDouble pR = m_eos->GetPressure(rhoR, eR);
    // Speed of sound
    NekDouble cL = m_eos->GetSoundSpeed(rhoL, eL);
    NekDouble cR = m_eos->GetSoundSpeed(rhoR, eR);
 
    // Left and right total enthalpy
    NekDouble HL = (EL + pL) / rhoL;
    NekDouble HR = (ER + pR) / rhoR;
 
    // Square root of rhoL and rhoR.
    NekDouble srL  = sqrt(rhoL);
    NekDouble srR  = sqrt(rhoR);
    NekDouble srLR = srL + srR;
 
    // Roe average state
    NekDouble uRoe  = (srL * uL + srR * uR) / srLR;
    NekDouble vRoe  = (srL * vL + srR * vR) / srLR;
    NekDouble wRoe  = (srL * wL + srR * wR) / srLR;
    NekDouble URoe2 = uRoe * uRoe + vRoe * vRoe + wRoe * wRoe;
    NekDouble HRoe  = (srL * HL + srR * HR) / srLR;
    NekDouble cRoe  = GetRoeSoundSpeed(rhoL, pL, eL, HL, srL, rhoR, pR, eR, HR,
                                       srR, HRoe, URoe2, srLR);
 
    // Maximum wave speeds
    NekDouble SL = std::min(uL - cL, uRoe - cRoe);
    NekDouble SR = std::max(uR + cR, uRoe + cRoe);
 
    // HLLC Riemann fluxes (positive case)
    if (SL >= 0)
    {
        rhof  = rhouL;
        rhouf = rhouL * uL + pL;
        rhovf = rhouL * vL;
        rhowf = rhouL * wL;
        Ef    = uL * (EL + pL);
    }
    // HLLC Riemann fluxes (negative case)
    else if (SR <= 0)
    {
        rhof  = rhouR;
        rhouf = rhouR * uR + pR;
        rhovf = rhouR * vR;
        rhowf = rhouR * wR;
        Ef    = uR * (ER + pR);
    }
    // HLLC Riemann fluxes (general case (SL < 0 | SR > 0)
    else
    {
        NekDouble SM = (pR - pL + rhouL * (SL - uL) - rhouR * (SR - uR)) /
                       (rhoL * (SL - uL) - rhoR * (SR - uR));
        NekDouble rhoML  = rhoL * (SL - uL) / (SL - SM);
        NekDouble rhouML = rhoML * SM;
        NekDouble rhovML = rhoML * vL;
        NekDouble rhowML = rhoML * wL;
        NekDouble EML =
            rhoML * (EL / rhoL + (SM - uL) * (SM + pL / (rhoL * (SL - uL))));
 
        NekDouble rhoMR  = rhoR * (SR - uR) / (SR - SM);
        NekDouble rhouMR = rhoMR * SM;
        NekDouble rhovMR = rhoMR * vR;
        NekDouble rhowMR = rhoMR * wR;
        NekDouble EMR =
            rhoMR * (ER / rhoR + (SM - uR) * (SM + pR / (rhoR * (SR - uR))));
 
        if (SL < 0.0 && SM >= 0.0)
        {
            rhof  = rhouL + SL * (rhoML - rhoL);
            rhouf = rhouL * uL + pL + SL * (rhouML - rhouL);
            rhovf = rhouL * vL + SL * (rhovML - rhovL);
            rhowf = rhouL * wL + SL * (rhowML - rhowL);
            Ef    = uL * (EL + pL) + SL * (EML - EL);
        }
        else if (SM < 0.0 && SR > 0.0)
        {
            rhof  = rhouR + SR * (rhoMR - rhoR);
            rhouf = rhouR * uR + pR + SR * (rhouMR - rhouR);
            rhovf = rhouR * vR + SR * (rhovMR - rhovR);
            rhowf = rhouR * wR + SR * (rhowMR - rhowR);
            Ef    = uR * (ER + pR) + SR * (EMR - ER);
        }
    }
}

References Nektar::CompressibleSolver::GetRoeSoundSpeed(), Nektar::CompressibleSolver::m_eos, and tinysimd::sqrt().

Member Data Documentation

solverName

static std::string Nektar::HLLCSolver::solverName

static

Initial value:

=
    SolverUtils::GetRiemannSolverFactory().RegisterCreatorFunction(
        "HLLC", HLLCSolver::create, "HLLC Riemann solver")

Definition at line 51 of file CompressibleFlowSolver/RiemannSolvers/HLLCSolver.h.