EulerFlux.h

Go to the documentation of this file.

 
#ifndef RIZER_EULER_FLUX_H
#define RIZER_EULER_FLUX_H
 
#include <algorithm>
#include <cmath>
 
namespace rizer
{
    namespace numeric
    {

        inline double maxWaveSpeed(double u_left, double c_left, double u_right,
                                   double c_right)
        {
            return std::max(std::abs(u_left) + c_left, std::abs(u_right) + c_right);
        }

        inline double rusanovScalarFlux(double r_face, double phi_left, double phi_right,
                                        double u_left, double u_right, double wave_speed)
        {
            const double average = 0.5 * (u_left * phi_left + u_right * phi_right);
            const double dissipation = 0.5 * wave_speed * (phi_right - phi_left);
            return r_face * (average - dissipation);
        }

        inline double rusanovMomentumFlux(double r_face, double rho_left, double u_left,
                                          double p_left, double rho_right,
                                          double u_right, double p_right,
                                          double wave_speed)
        {
            const double flux_left = rho_left * u_left * u_left + p_left;
            const double flux_right = rho_right * u_right * u_right + p_right;
            const double average = 0.5 * (flux_left + flux_right);
            const double dissipation =
                0.5 * wave_speed * (rho_right * u_right - rho_left * u_left);
            return r_face * (average - dissipation);
        }

        inline double rusanovEnergyFlux(double r_face, double E_left, double p_left,
                                        double u_left, double E_right, double p_right,
                                        double u_right, double wave_speed)
        {
            const double average =
                0.5 * (u_left * (E_left + p_left) + u_right * (E_right + p_right));
            const double dissipation = 0.5 * wave_speed * (E_right - E_left);
            return r_face * (average - dissipation);
        }

        inline double faceVelocityFlux(double r_face, double u_left, double u_right)
        {
            return r_face * 0.5 * (u_left + u_right);
        }

        inline double momentumGeometricSourceIntegral(double p, double dr)
        {
            return p * dr;
        }
 
    } // namespace numeric
} // namespace rizer
 
#endif // RIZER_EULER_FLUX_H