riemann_common.hpp File Reference

Gas and dust conservative/primitive states and axis-transform helpers shared by every gas and dust Riemann solver From original version by Thomas Guillet (T.A.G.nosp@m.uill.nosp@m.et@ex.nosp@m.eter.nosp@m..ac.u.nosp@m.k). More...

#include "shambackends/math.hpp"
#include "shambackends/typeAliasVec.hpp"
#include "shambackends/vec.hpp"
#include <algorithm>
#include <array>
#include <cmath>
#include <concepts>
#include <iostream>
#include <utility>

Include dependency graph for riemann_common.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	shammath::ConsState< VecType >
struct	shammath::PrimState< VecType >
struct	shammath::Fluxes< VecType >
struct	shammath::DustConsState< VecType >
struct	shammath::DustPrimState< VecType >
struct	shammath::DustFluxes< VecType >
struct	shammath::FluidStateAdiabatic< VecType >
	FluidStateSpec implementation for an ideal (adiabatic) gas equation of state. More...
struct	shammath::FluidStateDust< VecType >
	cons_to_prim/prim_to_cons/vn/flux wrapper for a pressureless (dust) fluid. Unlike FluidStateAdiabatic there is no equation of state, so sound_speed() and gamma() are not defined here; this type satisfies DustFluidStateSpec rather than FluidStateSpec. More...

Namespaces
namespace	shammath
	namespace for math utility

Concepts
concept	shammath::FluidStateSpec
	An equation of state paired with the flux/wave-speed operations a Riemann solver needs, so that solvers (see riemann_rusanov.hpp, riemann_hll.hpp) can be written once and instantiated for any fluid state satisfying this interface.
concept	shammath::DustFluidStateSpec
	The flux operations a dust (pressureless) Riemann solver needs, so that solvers (see riemann_dust_hll.hpp, riemann_dust_huang_bai.hpp) can be written once and instantiated for any dust state satisfying this interface. Analogous to FluidStateSpec but without an equation of state, hence no sound_speed().
concept	shammath::details::HasGlobalGamma
	True if T exposes a single, state-independent adiabatic index via gamma().
concept	shammath::details::HasPerStateGamma
	True if T exposes a per-primitive-state adiabatic index via gamma(prim).
concept	shammath::FluidStateAdiabaticSpec
	A FluidStateSpec that also exposes the adiabatic index, for solvers (e.g. HLLC) that need gamma directly rather than only through cons_to_prim/prim_to_cons/flux. Satisfied by a state-independent gamma() (a single constant adiabatic index) or a per-state gamma(prim) (e.g. a spatially/species-varying index); see get_adiabatic_index_lr() for how solvers should read it.

Functions
template<FluidStateAdiabaticSpec FSpec>
constexpr std::pair< typename FSpec::Tscal, typename FSpec::Tscal >	shammath::get_adiabatic_index_lr (const FSpec &fspec, const typename FSpec::Tprim &prim_l, const typename FSpec::Tprim &prim_r)
	Read the left/right adiabatic indices a HLLC-style solver should use for a given L/R pair.
template<class Tvec>
const ConsState< Tvec >	shammath::operator+ (const ConsState< Tvec > &lhs, const ConsState< Tvec > &rhs)
template<class Tvec>
const ConsState< Tvec >	shammath::operator- (const ConsState< Tvec > &lhs, const ConsState< Tvec > &rhs)
template<class Tvec>
const ConsState< Tvec >	shammath::operator* (const typename ConsState< Tvec >::Tscal factor, const ConsState< Tvec > &rhs)
template<class Tvec>
const ConsState< Tvec >	shammath::operator* (const ConsState< Tvec > &lhs, const typename ConsState< Tvec >::Tscal factor)
template<class Tvec>
constexpr shambase::VecComponent< Tvec >	shammath::rhoekin (shambase::VecComponent< Tvec > rho, Tvec v)
template<class Tvec>
constexpr ConsState< Tvec >	shammath::prim_to_cons (const PrimState< Tvec > prim, typename PrimState< Tvec >::Tscal gamma)
template<class Tvec>
constexpr PrimState< Tvec >	shammath::cons_to_prim (const ConsState< Tvec > cons, typename ConsState< Tvec >::Tscal gamma)
template<class Tvec>
constexpr ConsState< Tvec >	shammath::hydro_flux_n (const PrimState< Tvec > prim, Tvec n, typename PrimState< Tvec >::Tscal vn, typename PrimState< Tvec >::Tscal gamma)
	Euler flux across a face of normal n, given a precomputed normal velocity vn = dot(prim.vel, n).
template<class Tvec>
constexpr ConsState< Tvec >	shammath::hydro_flux_n (const PrimState< Tvec > prim, Tvec n, typename PrimState< Tvec >::Tscal gamma)
	Euler flux across a face of normal n.
template<class Tvec>
constexpr shambase::VecComponent< Tvec >	shammath::sound_speed (PrimState< Tvec > prim, shambase::VecComponent< Tvec > gamma)
template<class Tcons>
constexpr Tcons	shammath::y_to_x (const Tcons c)
template<class Tcons>
constexpr Tcons	shammath::x_to_y (const Tcons c)
template<class Tcons>
constexpr Tcons	shammath::z_to_x (const Tcons c)
template<class Tcons>
constexpr Tcons	shammath::x_to_z (const Tcons c)
template<class Tcons>
constexpr Tcons	shammath::invert_axis (const Tcons c)
template<class Tprim>
constexpr Tprim	shammath::prim_y_to_x (const Tprim p)
template<class Tprim>
constexpr Tprim	shammath::prim_z_to_x (const Tprim p)
template<class Tprim>
constexpr Tprim	shammath::prim_invert_axis (const Tprim p)
template<class Tvec>
const DustConsState< Tvec >	shammath::operator+ (const DustConsState< Tvec > &lhs, const DustConsState< Tvec > &rhs)
template<class Tvec>
const DustConsState< Tvec >	shammath::operator- (const DustConsState< Tvec > &lhs, const DustConsState< Tvec > &rhs)
template<class Tvec>
const DustConsState< Tvec >	shammath::operator* (const DustConsState< Tvec > &lhs, const typename DustConsState< Tvec >::Tscal factor)
template<class Tvec>
const DustConsState< Tvec >	shammath::operator* (const typename DustConsState< Tvec >::Tscal factor, const DustConsState< Tvec > &rhs)
template<class Tvec>
constexpr DustConsState< Tvec >	shammath::d_prim_to_cons (const DustPrimState< Tvec > d_prim)
template<class Tvec>
constexpr DustPrimState< Tvec >	shammath::d_cons_to_prim (const DustConsState< Tvec > d_cons)
template<class Tvec>
constexpr DustConsState< Tvec >	shammath::d_hydro_flux_n (const DustPrimState< Tvec > d_prim, Tvec n, typename DustPrimState< Tvec >::Tscal vn)
	Pressureless (dust) flux across a face of normal n, given a precomputed normal velocity vn = dot(d_prim.vel, n).
template<class Tvec>
constexpr DustConsState< Tvec >	shammath::d_hydro_flux_n (const DustPrimState< Tvec > d_prim, Tvec n)
	Pressureless (dust) flux across a face of normal n.
template<class Tcons>
constexpr Tcons	shammath::d_x_to_y (const Tcons c)
template<class Tcons>
constexpr Tcons	shammath::d_y_to_x (const Tcons c)
template<class Tcons>
constexpr Tcons	shammath::d_x_to_z (const Tcons c)
template<class Tcons>
constexpr Tcons	shammath::d_z_to_x (const Tcons c)
template<class Tcons>
constexpr Tcons	shammath::d_invert_axis (const Tcons c)
template<class Tprim>
constexpr Tprim	shammath::d_prim_y_to_x (const Tprim p)
template<class Tprim>
constexpr Tprim	shammath::d_prim_z_to_x (const Tprim p)
template<class Tprim>
constexpr Tprim	shammath::d_prim_invert_axis (const Tprim p)

Detailed Description

Gas and dust conservative/primitive states and axis-transform helpers shared by every gas and dust Riemann solver From original version by Thomas Guillet (T.A.G.nosp@m.uill.nosp@m.et@ex.nosp@m.eter.nosp@m..ac.u.nosp@m.k).

Author

Léodasce Sewanou (leoda.nosp@m.sce..nosp@m.sewan.nosp@m.ou@e.nosp@m.ns-ly.nosp@m.on.f.nosp@m.r) –no git blame–

Thomas Guillet (T.A.G.nosp@m.uill.nosp@m.et@ex.nosp@m.eter.nosp@m..ac.u.nosp@m.k) –no git blame–

Timothée David–Cléris (tim.s.nosp@m.hamr.nosp@m.ock@p.nosp@m.roto.nosp@m.n.me)

Definition in file riemann_common.hpp.