NewtonianEuler::BoundaryCorrections::Hllc< Dim > Class Template Reference

The HLLC (Harten-Lax-van Leer-Contact) Riemann solver for the NewtonianEuler system. More...

#include <Hllc.hpp>

Classes
struct	LargestIngoingCharSpeed
struct	LargestOutgoingCharSpeed

Public Types
using	options = implementation defined
using	dg_package_field_tags = implementation defined
using	dg_package_data_temporary_tags = implementation defined
using	dg_package_data_primitive_tags = implementation defined
using	dg_package_data_volume_tags = implementation defined
using	dg_boundary_terms_volume_tags = implementation defined
Public Types inherited from NewtonianEuler::BoundaryCorrections::BoundaryCorrection< Dim >
using	creatable_classes = implementation defined

Public Member Functions
	Hllc (const Hllc &)=default
Hllc &	operator= (const Hllc &)=default
	Hllc (Hllc &&)=default
Hllc &	operator= (Hllc &&)=default
void	pup (PUP::er &p) override
std::unique_ptr< BoundaryCorrection< Dim > >	get_clone () const override
double	dg_package_data (gsl::not_null< Scalar< DataVector > * > packaged_mass_density, gsl::not_null< tnsr::I< DataVector, Dim, Frame::Inertial > * > packaged_momentum_density, gsl::not_null< Scalar< DataVector > * > packaged_energy_density, gsl::not_null< Scalar< DataVector > * > packaged_pressure, gsl::not_null< Scalar< DataVector > * > packaged_normal_dot_flux_mass_density, gsl::not_null< tnsr::I< DataVector, Dim, Frame::Inertial > * > packaged_normal_dot_flux_momentum_density, gsl::not_null< Scalar< DataVector > * > packaged_normal_dot_flux_energy_density, gsl::not_null< tnsr::i< DataVector, Dim, Frame::Inertial > * > packaged_interface_unit_normal, gsl::not_null< Scalar< DataVector > * > packaged_normal_dot_velocity, gsl::not_null< Scalar< DataVector > * > packaged_largest_outgoing_char_speed, gsl::not_null< Scalar< DataVector > * > packaged_largest_ingoing_char_speed, const Scalar< DataVector > &mass_density, const tnsr::I< DataVector, Dim, Frame::Inertial > &momentum_density, const Scalar< DataVector > &energy_density, const tnsr::I< DataVector, Dim, Frame::Inertial > &flux_mass_density, const tnsr::IJ< DataVector, Dim, Frame::Inertial > &flux_momentum_density, const tnsr::I< DataVector, Dim, Frame::Inertial > &flux_energy_density, const tnsr::I< DataVector, Dim, Frame::Inertial > &velocity, const Scalar< DataVector > &specific_internal_energy, const tnsr::i< DataVector, Dim, Frame::Inertial > &normal_covector, const std::optional< tnsr::I< DataVector, Dim, Frame::Inertial > > &, const std::optional< Scalar< DataVector > > &normal_dot_mesh_velocity, const EquationsOfState::EquationOfState< false, 2 > &equation_of_state) const
void	dg_boundary_terms (gsl::not_null< Scalar< DataVector > * > boundary_correction_mass_density, gsl::not_null< tnsr::I< DataVector, Dim, Frame::Inertial > * > boundary_correction_momentum_density, gsl::not_null< Scalar< DataVector > * > boundary_correction_energy_density, const Scalar< DataVector > &mass_density_int, const tnsr::I< DataVector, Dim, Frame::Inertial > &momentum_density_int, const Scalar< DataVector > &energy_density_int, const Scalar< DataVector > &pressure_int, const Scalar< DataVector > &normal_dot_flux_mass_density_int, const tnsr::I< DataVector, Dim, Frame::Inertial > &normal_dot_flux_momentum_density_int, const Scalar< DataVector > &normal_dot_flux_energy_density_int, const tnsr::i< DataVector, Dim, Frame::Inertial > &interface_unit_normal_int, const Scalar< DataVector > &normal_dot_velocity_int, const Scalar< DataVector > &largest_outgoing_char_speed_int, const Scalar< DataVector > &largest_ingoing_char_speed_int, const Scalar< DataVector > &mass_density_ext, const tnsr::I< DataVector, Dim, Frame::Inertial > &momentum_density_ext, const Scalar< DataVector > &energy_density_ext, const Scalar< DataVector > &pressure_ext, const Scalar< DataVector > &normal_dot_flux_mass_density_ext, const tnsr::I< DataVector, Dim, Frame::Inertial > &normal_dot_flux_momentum_density_ext, const Scalar< DataVector > &normal_dot_flux_energy_density_ext, const tnsr::i< DataVector, Dim, Frame::Inertial > &interface_unit_normal_ext, const Scalar< DataVector > &normal_dot_velocity_ext, const Scalar< DataVector > &largest_outgoing_char_speed_ext, const Scalar< DataVector > &largest_ingoing_char_speed_ext, dg::Formulation dg_formulation) const
Public Member Functions inherited from NewtonianEuler::BoundaryCorrections::BoundaryCorrection< Dim >
	BoundaryCorrection (const BoundaryCorrection &)=default
BoundaryCorrection &	operator= (const BoundaryCorrection &)=default
	BoundaryCorrection (BoundaryCorrection &&)=default
BoundaryCorrection &	operator= (BoundaryCorrection &&)=default
virtual std::unique_ptr< BoundaryCorrection< Dim > >	get_clone () const =0

Static Public Attributes
static constexpr Options::String	help

Detailed Description

template<size_t Dim>
class NewtonianEuler::BoundaryCorrections::Hllc< Dim >

The HLLC (Harten-Lax-van Leer-Contact) Riemann solver for the NewtonianEuler system.

Let $U$ be the evolved variable, $F^i$ the flux, $v^i$ the spatial velocity, and $n_i$ be the outward directed unit normal to the interface. Denoting $F:=n_i{F}^i$ and $v:=n_i{v}^i$, the HLLC boundary correction is [196]

$$\begin{array}{r}{G}_{\text{HLLC}}=\left\{\begin{array}{lcl}{F}_{\text{int}}& \text{if}& 0\le {\lambda }_{\text{min}}\\ F_{\text{int}}+{\lambda }_{\text{min}}(U_{\text{*int}}-U_{\text{int}})& \text{if}& {\lambda }_{\text{min}}\le 0\le {\lambda }_{\text{*}}\\ -F_{\text{ext}}+{\lambda }_{\text{max}}(U_{\text{*ext}}-U_{\text{ext}})& \text{if}& {\lambda }_{\text{*}}\le 0\le {\lambda }_{\text{max}}\\ -F_{\text{ext}}& \text{if}& {\lambda }_{\text{max}}\le 0\end{array}\right\}\end{array}$$

where "int" and "ext" stand for interior and exterior.

Intermediate ('star') states are given by

$$\begin{array}{r}{U}_{\text{*int}}=\left(\frac{{\lambda }_{\text{min}}-v_{\text{int}}}{{\lambda }_{\text{min}}-{\lambda }_{\ast }}\right)\left[\begin{array}{c}{\displaystyle {\rho }_{\text{int}}}\\ {\displaystyle {\rho }_{\text{int}}[v_{\text{int}}^x+({\lambda }_{\ast }-v_{\text{int}})n_x^{\text{int}}]}\\ {\displaystyle {\rho }_{\text{int}}[v_{\text{int}}^y+({\lambda }_{\ast }-v_{\text{int}})n_y^{\text{int}}]}\\ {\displaystyle {\rho }_{\text{int}}[v_{\text{int}}^z+({\lambda }_{\ast }-v_{\text{int}})n_z^{\text{int}}]}\\ {\displaystyle E_{\text{int}}+p_{\text{int}}\frac{{\lambda }_{\ast }-v_{\text{int}}}{{\lambda }_{\text{min}}-v_{\text{int}}}+{\rho }_{\text{int}}{\lambda }_{\ast }({\lambda }_{\ast }-v_{\text{int}})}\end{array}\right]\end{array}$$

and

$$\begin{array}{r}{U}_{\text{*ext}}=\left(\frac{{\lambda }_{\text{max}}+v_{\text{ext}}}{{\lambda }_{\text{max}}-{\lambda }_{\ast }}\right)\left[\begin{array}{c}{\displaystyle {\rho }_{\text{ext}}}\\ {\displaystyle {\rho }_{\text{ext}}[-v_{\text{ext}}^x-({\lambda }_{\ast }+v_{\text{ext}})n_x^{\text{ext}}]}\\ {\displaystyle {\rho }_{\text{ext}}[-v_{\text{ext}}^y-({\lambda }_{\ast }+v_{\text{ext}})n_y^{\text{ext}}]}\\ {\displaystyle {\rho }_{\text{ext}}[-v_{\text{ext}}^z-({\lambda }_{\ast }+v_{\text{ext}})n_z^{\text{ext}}]}\\ {\displaystyle E_{\text{ext}}+p_{\text{ext}}\frac{{\lambda }_{\ast }+v_{\text{ext}}}{{\lambda }_{\text{max}}+v_{\text{ext}}}+{\rho }_{\text{ext}}{\lambda }_{\ast }({\lambda }_{\ast }+v_{\text{ext}})}\end{array}\right].\end{array}$$

The contact wave speed ${\lambda }_{\ast }$ is [197]

$$\begin{array}{r}{\lambda }_{\ast }=\frac{p_{\text{ext}}-p_{\text{int}}+{\rho }_{\text{int}}{v}_{\text{int}}({\lambda }_{\text{min}}-v_{\text{int}})+{\rho }_{\text{ext}}{v}_{\text{ext}}({\lambda }_{\text{max}}+v_{\text{ext}})}{{\rho }_{\text{int}}({\lambda }_{\text{min}}-v_{\text{int}})-{\rho }_{\text{ext}}({\lambda }_{\text{max}}+v_{\text{ext}})}.\end{array}$$

${\lambda }_{\text{min}}$ and ${\lambda }_{\text{max}}$ are estimated by [45]

$$\begin{array}{rl}{\lambda }_{\text{min}}& =\text{min}({\lambda }_{\text{int}}^{-},-{\lambda }_{\text{ext}}^{+})\\ {\lambda }_{\text{max}}& =\text{max}({\lambda }_{\text{int}}^{+},-{\lambda }_{\text{ext}}^{-})\end{array}$$

where ${\lambda }^{+}$ ( ${\lambda }^{-}$) is the largest characteristic speed in the outgoing (ingoing) direction for each domain.

Note the minus signs in front of ${\lambda }_{\text{ext}}^{\pm }$, which is because an outgoing speed w.r.t. the neighboring element is an ingoing speed w.r.t. the local element, and vice versa. Similarly, the $F_{\text{ext}}$ term in $G_{\text{HLLC}}$ and the $v_{\text{ext}}$ term in $U_{\text{*ext}}$ have a positive sign because the outward directed normal of the neighboring element has the opposite sign, i.e. $n_i^{\text{ext}}=-n_i^{\text{int}}$.

For the NewtonianEuler system, ${\lambda }^{\pm }$ are given as

$$\begin{array}{r}{\lambda }^{\pm }=v\pm c_s\end{array}$$

where $c_s$ is the sound speed.

Note

• In the strong form the dg_boundary_terms function returns $G-F_{\text{int}}$

• In the implementation, we use

  $$\begin{array}{r}{G}_{\text{HLLC}}=\left\{\begin{array}{lcl}{F}_{\text{int}}+{\lambda }_{\text{min}}(U_{\text{*int}}-U_{\text{int}})& \text{if}& 0\le {\lambda }_{\text{*}}\\ -F_{\text{ext}}+{\lambda }_{\text{max}}(U_{\text{*ext}}-U_{\text{ext}})& \text{if}& {\lambda }_{\text{*}}\le 0\end{array}\right\},\end{array}$$

  with

  $$\begin{array}{rl}{\lambda }_{\text{min}}& =\text{min}({\lambda }_{\text{int}}^{-},-{\lambda }_{\text{ext}}^{+},0)\\ {\lambda }_{\text{max}}& =\text{max}({\lambda }_{\text{int}}^{+},-{\lambda }_{\text{ext}}^{-},0).\end{array}$$

  Provided that ${\lambda }_{\ast }$ falls in the correct range i.e

  $$\begin{array}{r}\text{min}({\lambda }_{\text{int}}^{-},-{\lambda }_{\text{ext}}^{+})<{\lambda }_{\ast }<\text{max}({\lambda }_{\text{int}}^{+},-{\lambda }_{\text{ext}}^{-}),\end{array}$$

  this prescription recovers the original HLLC boundary correction for all four cases. For either ${\lambda }_{\text{min}}=0$ or ${\lambda }_{\text{max}}=0$ (i.e. all characteristics move in the same direction), boundary correction reduces to pure upwinding.

• Some references use $S$ instead of $\lambda$ for the signal/characteristic speeds.

Member Function Documentation

get_clone()

template<size_t Dim>

std::unique_ptr< BoundaryCorrection< Dim > > NewtonianEuler::BoundaryCorrections::Hllc< Dim >::get_clone ( ) const

overridevirtual

Implements NewtonianEuler::BoundaryCorrections::BoundaryCorrection< Dim >.

Member Data Documentation

help

template<size_t Dim>

constexpr Options::String NewtonianEuler::BoundaryCorrections::Hllc< Dim >::help

staticconstexpr

Initial value:

= {
      "Computes the HLLC boundary correction term for the "
      "Newtonian Euler/hydrodynamics system."}

---

The documentation for this class was generated from the following file:

• src/Evolution/Systems/NewtonianEuler/BoundaryCorrections/Hllc.hpp