Nektar::LaxFriedrichsSolver Class Reference

#include <LaxFriedrichsSolver.h>

Inheritance diagram for Nektar::LaxFriedrichsSolver:

Collaboration diagram for Nektar::LaxFriedrichsSolver:

Static Public Member Functions
static RiemannSolverSharedPtr	create ()
static RiemannSolverSharedPtr	create ()
static RiemannSolverSharedPtr	create ()

Static Public Attributes
static std::string	solverName

Protected Member Functions
	LaxFriedrichsSolver ()
virtual void	v_PointSolve (NekDouble pL, NekDouble rhoL, NekDouble uL, NekDouble vL, NekDouble wL, NekDouble pR, NekDouble rhoR, NekDouble uR, NekDouble vR, NekDouble wR, NekDouble p0, NekDouble rho0, NekDouble u0, NekDouble v0, NekDouble w0, NekDouble &pF, NekDouble &rhoF, NekDouble &uF, NekDouble &vF, NekDouble &wF)
	Lax-Friedrichs Riemann solver. More...
	LaxFriedrichsSolver ()
virtual 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)
	Lax-Friedrichs Riemann solver. More...
virtual void	v_PointSolveVisc (NekDouble rhoL, NekDouble rhouL, NekDouble rhovL, NekDouble rhowL, NekDouble EL, NekDouble EpsL, NekDouble rhoR, NekDouble rhouR, NekDouble rhovR, NekDouble rhowR, NekDouble ER, NekDouble EpsR, NekDouble &rhof, NekDouble &rhouf, NekDouble &rhovf, NekDouble &rhowf, NekDouble &Ef, NekDouble &Epsf)
	LaxFriedrichsSolver ()
virtual void	v_PointSolve (double hL, double huL, double hvL, double hR, double huR, double hvR, double &hf, double &huf, double &hvf)
	Lax-Friedrichs Riemann solver. More...
Protected Member Functions inherited from Nektar::NonlinearSWESolver
	NonlinearSWESolver ()
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)
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)
Protected Member Functions inherited from Nektar::SolverUtils::RiemannSolver
SOLVER_UTILS_EXPORT	RiemannSolver ()
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...
Protected Member Functions inherited from Nektar::CompressibleSolver
	CompressibleSolver ()
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)
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)
Protected Member Functions inherited from Nektar::APESolver
	APESolver ()
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)
Array< OneD, Array< OneD, NekDouble > >	GetRotBasefield ()

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	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)
std::map< std::string, RSScalarFuncType > &	GetScalars ()
std::map< std::string, RSVecFuncType > &	GetVectors ()
std::map< std::string, RSParamFuncType > &	GetParams ()
Public Attributes inherited from Nektar::SolverUtils::RiemannSolver
int	m_spacedim
Protected Attributes inherited from Nektar::NonlinearSWESolver
bool	m_pointSolve
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...
Protected Attributes inherited from Nektar::CompressibleSolver
bool	m_pointSolve

Detailed Description

Definition at line 48 of file APESolver/RiemannSolvers/LaxFriedrichsSolver.h.

Constructor & Destructor Documentation

Nektar::LaxFriedrichsSolver::LaxFriedrichsSolver ( )

protected

Definition at line 53 of file APESolver/RiemannSolvers/LaxFriedrichsSolver.cpp.

Referenced by create().

                                         :
    APESolver()
{

}

Nektar::LaxFriedrichsSolver::LaxFriedrichsSolver ( )

protected

Nektar::LaxFriedrichsSolver::LaxFriedrichsSolver ( )

protected

Member Function Documentation

static RiemannSolverSharedPtr Nektar::LaxFriedrichsSolver::create ( )

inlinestatic

Definition at line 46 of file CompressibleFlowSolver/RiemannSolvers/LaxFriedrichsSolver.h.

References LaxFriedrichsSolver().

        {
            return RiemannSolverSharedPtr(new LaxFriedrichsSolver());
        }

static RiemannSolverSharedPtr Nektar::LaxFriedrichsSolver::create ( )

inlinestatic

Definition at line 46 of file ShallowWaterSolver/RiemannSolvers/LaxFriedrichsSolver.h.

References LaxFriedrichsSolver().

        {
            return RiemannSolverSharedPtr(
                new LaxFriedrichsSolver());
        }

static RiemannSolverSharedPtr Nektar::LaxFriedrichsSolver::create ( )

inlinestatic

Definition at line 51 of file APESolver/RiemannSolvers/LaxFriedrichsSolver.h.

        {
            return RiemannSolverSharedPtr(new LaxFriedrichsSolver());
        }

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

protectedvirtual

Lax-Friedrichs 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 69 of file CompressibleFlowSolver/RiemannSolvers/LaxFriedrichsSolver.cpp.

References Nektar::SolverUtils::RiemannSolver::m_params, and sign.

    {
        static NekDouble gamma = m_params["gamma"]();
        
        // 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;
        
        // Left and right pressures
        NekDouble pL = (gamma - 1.0) *
        (EL - 0.5 * (rhouL*uL + rhovL*vL + rhowL*wL));
        
        NekDouble pR = (gamma - 1.0) *
        (ER - 0.5 * (rhouR*uR + rhovR*vR + rhowR*wR));
        
        // Left and right speeds of sound
        NekDouble cL = sqrt(gamma * pL / rhoL);
        NekDouble cR = sqrt(gamma * pR / rhoR);
        
        // Left and right entalpies
        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;
        
        // Velocity Roe averages
        NekDouble uRoe   = (srL * uL + srR * uR) / srLR;
        NekDouble vRoe   = (srL * vL + srR * vR) / srLR;
        NekDouble wRoe   = (srL * wL + srR * wR) / srLR;
        NekDouble hRoe   = (srL * hL + srR * hR) / srLR;
        NekDouble cRoe   = sqrt((gamma - 1.0)*(hRoe - 0.5 *
                                               (uRoe * uRoe + vRoe * vRoe + wRoe * wRoe)));
        
        // Minimum and maximum wave speeds
        NekDouble S    = std::max(uRoe+cRoe, std::max(uR+cR, -uL+cL));
        NekDouble sign = 1.0;
        
        if(S == -uL+cL)
        {
            sign = -1.0;
        }
        
        // Lax-Friedrichs Riemann rho flux
        rhof  = 0.5 * ((rhouL + rhouR) - sign * S * (rhoR -rhoL));
        
        // Lax-Friedrichs Riemann rhou flux
        rhouf = 0.5 * ((rhoL * uL * uL + pL + rhoR * uR * uR + pR) -
                       sign * S * (rhouR - rhouL));
        
        // Lax-Friedrichs Riemann rhov flux
        rhovf = 0.5 * ((rhoL * uL * vL + rhoR * uR * vR) -
                       sign * S * (rhovR - rhovL));
        
        // Lax-Friedrichs Riemann rhow flux
        rhowf = 0.5 * ((rhoL * uL * wL + rhoR * uR * wR) -
                       sign * S * (rhowR - rhowL));
        
        // Lax-Friedrichs Riemann E flux
        Ef    = 0.5 * ((uL * (EL + pL) + uR * (ER + pR)) -
                       sign * S * (ER - EL));
    }

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

protectedvirtual

Lax-Friedrichs Riemann solver.

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 64 of file ShallowWaterSolver/RiemannSolvers/LaxFriedrichsSolver.cpp.

References Nektar::SolverUtils::RiemannSolver::m_params, and sign.

    {        
        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);
        
          // Square root of hL and hR.
        NekDouble srL  = sqrt(hL);
        NekDouble srR  = sqrt(hR);
        NekDouble srLR = srL + srR;
        
        // Velocity Roe averages
        NekDouble uRoe   = (srL * uL + srR * uR) / srLR;
    NekDouble cRoe   = sqrt(0.5 * (cL * cL + cR * cR));
        
        // Minimum and maximum wave speeds
        NekDouble S    = std::max(uRoe+cRoe, std::max(uR+cR, -(uL-cL)));
        NekDouble sign = 1.0;
        
        if(S == -(uL-cL))
        {
            sign = -1.0;
        }
        
        // Lax-Friedrichs Riemann h flux
        hf  = 0.5 * ((huL + huR) - sign * S * (hR -hL));
        
        // Lax-Friedrichs Riemann hu flux
        huf = 0.5 * ((hL * uL * uL + 0.5 * g * hL * hL  + 
              hR * uR * uR + 0.5 * g * hR * hR) - 
                       sign * S * (huR - huL));
        
        // Lax-Friedrichs Riemann hv flux
        hvf = 0.5 * ((hL * uL * vL + hR * uR * vR) - 
                        sign * S * (hvR - hvL));
        
    }

void Nektar::LaxFriedrichsSolver::v_PointSolve ( NekDouble  pL, NekDouble  rhoL, NekDouble  uL, NekDouble  vL, NekDouble  wL, NekDouble  pR, NekDouble  rhoR, NekDouble  uR, NekDouble  vR, NekDouble  wR, NekDouble  p0, NekDouble  rho0, NekDouble  u0, NekDouble  v0, NekDouble  w0, NekDouble &  pF, NekDouble &  rhoF, NekDouble &  uF, NekDouble &  vF, NekDouble &  wF  )

protectedvirtual

Lax-Friedrichs Riemann solver.

Parameters

pL	Perturbation pressure left state
rhoL	Perturbation density left state
pR	Perturbation pressure right state
rhoR	Perturbation density right state
uL	x perturbation velocity component left state
uR	x perturbation velocity component right state
vL	y perturbation velocity component left state
vR	y perturbation velocity component right state
wL	z perturbation velocity component left state
wR	z perturbation velocity component right state
p0	Base pressure
rho0	Base density
u0	Base x velocity component
v0	Base y velocity component
w0	Base z velocity component
pF	Computed Riemann flux for perturbation pressure
rhoF	Computed Riemann flux for perturbation density
uF	Computed Riemann flux for x perturbation velocity component
vF	Computed Riemann flux for y perturbation velocity component
wF	Computed Riemann flux for z perturbation velocity component

Reimplemented from Nektar::APESolver.

Definition at line 83 of file APESolver/RiemannSolvers/LaxFriedrichsSolver.cpp.

References ASSERTL1, Nektar::SolverUtils::RiemannSolver::CheckParams(), and Nektar::SolverUtils::RiemannSolver::m_params.

{
    ASSERTL1(CheckParams("Gamma"), "Gamma not defined.");
    const NekDouble &gamma = m_params["Gamma"]();

    // Speed of sound
    NekDouble c = sqrt(gamma * p0 / rho0);

    // max absolute eigenvalue of the jacobian of F_n1
    NekDouble a_1_max = std::max(std::abs(u0 - c), std::abs(u0 + c));

    NekDouble pFL = rho0*uL + u0*pL/(c*c);
    NekDouble uFL = pL/rho0 + u0*uL + v0*vL + w0*wL;
    NekDouble vFL = 0;
    NekDouble wFL = 0;

    NekDouble pFR = rho0*uR + u0*pR/(c*c);
    NekDouble uFR = pR/rho0 + u0*uR + v0*vR + w0*wR;
    NekDouble vFR = 0;
    NekDouble wFR = 0;

    // assemble the face-normal fluxes
    pF = 0.5*(pFL + pFR - a_1_max*(pR/(c*c) - pL/(c*c)));
    uF = 0.5*(uFL + uFR - a_1_max*(uR - uL));
    vF = 0.5*(vFL + vFR - a_1_max*(vR - vL));
    wF = 0.5*(wFL + wFR - a_1_max*(wR - wL));
}

void Nektar::LaxFriedrichsSolver::v_PointSolveVisc ( NekDouble  rhoL, NekDouble  rhouL, NekDouble  rhovL, NekDouble  rhowL, NekDouble  EL, NekDouble  EpsL, NekDouble  rhoR, NekDouble  rhouR, NekDouble  rhovR, NekDouble  rhowR, NekDouble  ER, NekDouble  EpsR, NekDouble &  rhof, NekDouble &  rhouf, NekDouble &  rhovf, NekDouble &  rhowf, NekDouble &  Ef, NekDouble &  Epsf  )

protectedvirtual

Reimplemented from Nektar::CompressibleSolver.

Definition at line 141 of file CompressibleFlowSolver/RiemannSolvers/LaxFriedrichsSolver.cpp.

References Nektar::SolverUtils::RiemannSolver::m_params, and sign.

    {
        static NekDouble gamma = m_params["gamma"]();
        
        // 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;
        
        // Left and right pressures
        NekDouble pL = (gamma - 1.0) *
        (EL - 0.5 * (rhouL*uL + rhovL*vL + rhowL*wL));
        
        NekDouble pR = (gamma - 1.0) *
        (ER - 0.5 * (rhouR*uR + rhovR*vR + rhowR*wR));
        
        // Left and right speeds of sound
        NekDouble cL = sqrt(gamma * pL / rhoL);
        NekDouble cR = sqrt(gamma * pR / rhoR);
        
        // Left and right entalpies
        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;
        
        // Velocity Roe averages
        NekDouble uRoe   = (srL * uL + srR * uR) / srLR;
        NekDouble vRoe   = (srL * vL + srR * vR) / srLR;
        NekDouble wRoe   = (srL * wL + srR * wR) / srLR;
        NekDouble hRoe   = (srL * hL + srR * hR) / srLR;
        NekDouble cRoe   = sqrt((gamma - 1.0)*(hRoe - 0.5 *
                            (uRoe * uRoe + vRoe * vRoe + wRoe * wRoe)));
        
        // Minimum and maximum wave speeds
        NekDouble S    = std::max(uRoe+cRoe, std::max(uR+cR, -uL+cL));
        NekDouble sign = 1.0;
        
        if(S == -uL+cL)
        {
            sign = -1.0;
        }
        
        // Lax-Friedrichs Riemann rho flux
        rhof  = 0.5 * ((rhouL + rhouR) - sign * S * (rhoR -rhoL));
        
        // Lax-Friedrichs Riemann rhou flux
        rhouf = 0.5 * ((rhoL * uL * uL + pL + rhoR * uR * uR + pR) -
                       sign * S * (rhouR - rhouL));
        
        // Lax-Friedrichs Riemann rhov flux
        rhovf = 0.5 * ((rhoL * uL * vL + rhoR * uR * vR) -
                       sign * S * (rhovR - rhovL));
        
        // Lax-Friedrichs Riemann rhow flux
        rhowf = 0.5 * ((rhoL * uL * wL + rhoR * uR * wR) -
                       sign * S * (rhowR - rhowL));
        
        // Lax-Friedrichs Riemann E flux
        Ef    = 0.5 * ((uL * (EL + pL) + uR * (ER + pR)) -
                       sign * S * (ER - EL));
        
        Epsf  = 0.5 * ((EpsL + EpsR) -
                       sign * S * (EpsR - EpsL));
    }

Member Data Documentation

static std::string Nektar::LaxFriedrichsSolver::solverName

static

Initial value:

=
    SolverUtils::GetRiemannSolverFactory().
    RegisterCreatorFunction("LaxFriedrichs", LaxFriedrichsSolver::create,
                            "Lax-Friedrichs Solver")

Definition at line 56 of file APESolver/RiemannSolvers/LaxFriedrichsSolver.h.