5-moment_base.h

Go to the documentation of this file.

#pragma once
 
// wxm includes
#include "warpxm/warpxm_config.h" // for variable macros
#include "apps/wmapplication.h"   // for pSV
#include "apps/general_functions/geometry.h"
#include "apps/general_functions/functions.h"
 
// std includes
#include <cmath>
 
struct constants_5moment_t
{
    real gas_gamma;
    real mass = 1.;
    real density_min = std::numeric_limits<real>::epsilon();
    real pressure_min = std::numeric_limits<real>::epsilon();
    bool entropy_fix = true;
};
 
namespace wxm
{
namespace apps
{
namespace five_moment
{
 
real getRhoFloored(const real* q,
                   const real rho_min = std::numeric_limits<real>::epsilon());
 
real getPressureFloored(const real* q,
                        const real gas_gamma,
                        const real rho_min = std::numeric_limits<real>::epsilon(),
                        const real press_min = std::numeric_limits<real>::epsilon());
 
real getTemperatureFloored(const real* q,
                           const real gas_gamma,
                           const real A = 1.0,
                           const real rho_min = std::numeric_limits<real>::epsilon(),
                           const real press_min = std::numeric_limits<real>::epsilon());
 
/* /\** */
/*  * @brief Generate pressure for 5-moment fluid */
/*  * @param pC Constants specific to this fluid */
/*  * @param Q Conserved variables for 5-moment fluid */
/*  * @return fluid pressure */
/*  *\/ */
/* real pressure(const constants_5moment_t* pC, const real QC[5]); */
 
void NCtoC(const constants_5moment_t* pC, const real QNC[5], real QC[5]);
 
void CtoNC(const constants_5moment_t* pC,
           const real QC[5],
           real QNC[5],
           const real rho_min = std::numeric_limits<real>::epsilon(),
           const real press_min = std::numeric_limits<real>::epsilon());
 
void NCtoCDifferential(const constants_5moment_t* pC,
                       const real QNC_center[5],
                       const real dQNC[5],
                       const real QC_center[5],
                       real dQC[5]);
 
void rotateVector(const real v[5], const solverVariables_t* pSV, real Rv[5]);
 
void antirotateVector(const real Rv[5], const solverVariables_t* pSV, real v[5]);
 
// -----------------------------------------------------------------------------------
// Flux functions
// -----------------------------------------------------------------------------------
 
void eulerFlux(const constants_5moment_t* pC,
               const real QC[5],
               real flux[5],
               const real rho_min = std::numeric_limits<real>::epsilon(),
               const real press_min = std::numeric_limits<real>::epsilon());
 
void eulerRoeFluxSolver(const constants_5moment_t* pC,
                        const real QC_l[5],
                        const real QC_r[5],
                        real* s,
                        real amdq[5],
                        real apdq[5],
                        const real rho_min = std::numeric_limits<real>::epsilon(),
                        const real press_min = std::numeric_limits<real>::epsilon());
 
void eulerRoeAverages(const constants_5moment_t* pC,
                      const real ql[5],
                      const real qr[5],
                      const real& pl,
                      const real& pr,
                      real& rho,
                      real& u,
                      real& v,
                      real& w,
                      real& enth,
                      real& a,
                      const real rho_min = std::numeric_limits<real>::epsilon());
 
void hartenHymanEntropyFix(const constants_5moment_t* pC,
                           const real ql[5],
                           const real qr[5],
                           const real s[3],
                           const real wave[][3],
                           real amdq[5],
                           real apdq[5],
                           const real rho_min = std::numeric_limits<real>::epsilon(),
                           const real press_min = std::numeric_limits<real>::epsilon());
 
real eulerNumericalFlux_x(const constants_5moment_t* pC,
                          const real QC_l[5],
                          const real QC_r[5],
                          void (*numerical_flux_scheme)(const constants_5moment_t* pC,
                                                        const real QC_l[5],
                                                        const real QC_r[5],
                                                        real* s,
                                                        real amdq[5],
                                                        real apdq[5],
                                                        const real rho_min,
                                                        const real press_min),
                          real flux[5],
                          const real rho_min = std::numeric_limits<real>::epsilon(),
                          const real press_min = std::numeric_limits<real>::epsilon());
 
real eulerNumericalFlux(const constants_5moment_t* pC,
                        const solverVariables_t* pSV,
                        const real QC_l[5],
                        const real QC_r[5],
                        void (*numerical_flux_scheme)(const constants_5moment_t* pC,
                                                      const real QC_l[5],
                                                      const real QC_r[5],
                                                      real* s,
                                                      real amdq[5],
                                                      real apdq[5],
                                                      const real rho_min,
                                                      const real press_min),
                        real numericalFlux[5],
                        const real rho_min = std::numeric_limits<real>::epsilon(),
                        const real press_min = std::numeric_limits<real>::epsilon());
 
void eulerHLLEFluxSolver(const constants_5moment_t* pC,
                         const real QC_l[5],
                         const real QC_r[5],
                         real* s,
                         real amdq[5],
                         real apdq[5],
                         const real rho_min = std::numeric_limits<real>::epsilon(),
                         const real press_min = std::numeric_limits<real>::epsilon());
 
void eulerHLLECFluxSolver(const constants_5moment_t* pC,
                          const real QC_l[5],
                          const real QC_r[5],
                          real* s,
                          real amdq[5],
                          real apdq[5],
                          const real rho_min = std::numeric_limits<real>::epsilon(),
                          const real press_min = std::numeric_limits<real>::epsilon());
 
real eulerRusanovFlux(const constants_5moment_t* pC,
                      const solverVariables_t* pSV,
                      const real QC_l[5],
                      const real QC_r[5],
                      real numericalFlux[5],
                      const real rho_min = std::numeric_limits<real>::epsilon(),
                      const real press_min = std::numeric_limits<real>::epsilon());
 
real eulerInternalFlux(const constants_5moment_t* pC,
                       const solverVariables_t* pSV,
                       const real QC[5],
                       std::vector<std::vector<real>>& internalFlux,
                       const real rho_min = std::numeric_limits<real>::epsilon(),
                       const real press_min = std::numeric_limits<real>::epsilon());
 
void navier_stokes_anisotropic_pressure_tensor(const real viscosity,
                                               const real* q,
                                               const real* grad_rho,
                                               const real* grad_p[3],
                                               real pi[3][3]);
 
void navier_stokes_viscous_flux_tensor(const real* q,
                                       const solverVariables_t* pSV,
                                       const real pi[][3],
                                       const real h[3],
                                       std::vector<std::vector<real>>& flux_tensor);
 
void navier_stokes_internal_flux(
    const constants_5moment_t* pC,
    const solverVariables_t* pSV,
    const real mu,
    const real k,
    const real* q,
    const real u[3],
    const real* grad_u[3],
    const real div_u,
    const real grad_T[3],
    std::vector<std::vector<real>>& internal_flux,
    const real rho_min = std::numeric_limits<real>::epsilon());
 
// dont use this anymore->remove when navier_stokes app updated
real navier_stokes_numerical_flux(
    constants_5moment_t* pC,
    const solverVariables_t* pSV,
    const real viscosity,
    const real thermal_conductivity,
    const real* q_l,
    const real* q_r,
    const real* aux_l,
    const real* aux_r,
    real* numerical_flux,
    const real rho_min = std::numeric_limits<real>::epsilon(),
    const real press_min = std::numeric_limits<real>::epsilon());
 
real interspeciesCollisions(const real nu_ab,
                            const constants_5moment_t* pC_a,
                            const constants_5moment_t* pC_b,
                            const real* q_a,
                            const real* q_b,
                            real* source,
                            const real rho_min = std::numeric_limits<real>::epsilon(),
                            const real press_min = std::numeric_limits<real>::epsilon());
 
 
void calcGradT(const constants_5moment_t* pC,
               const real* q,
               const real* aux,
               const real* grad_u,
               real* grad_T,
               const real rho_min = std::numeric_limits<real>::epsilon(),
               const real press_min = std::numeric_limits<real>::epsilon());
 
real calcDivU(const real* q,
              const real* aux,
              const real rho_min = std::numeric_limits<real>::epsilon());
 
void calcGradU(const real* q,
               const real* aux,
               real* grad_u[3],
               const real rho_min = std::numeric_limits<real>::epsilon());
 
void get_mu_and_k(const constants_5moment_t* pC,
                  const real* q,
                  const bool is_neutral,
                  const real collision_coefficient,
                  const real minimum_frequency,
                  const real diffusivity_min,
                  const real diffusivity_max,
                  const bool is_const_mu,
                  const real const_mu,
                  const bool is_const_k,
                  const real const_k,
                  real& mu,
                  real& k,
                  const real rho_min = std::numeric_limits<real>::epsilon(),
                  const real press_min = std::numeric_limits<real>::epsilon());
 
real positivity_preserving_source_dt(
    const real* q,
    const real* dqdt,
    real lambda,
    const real rho_min = std::numeric_limits<real>::epsilon());
 
// -----------------------------------------------------------------------------------
// Boundary condition functions
// -----------------------------------------------------------------------------------
namespace bc
{
void noslipWallCondition(const constants_5moment_t* pC,
                         const solverVariables_t* pSV,
                         const real* QC,
                         const real vx_w,
                         const real vy_w,
                         const real vz_w,
                         real* QC_w);
 
void noslipWallCondition_gradients(const constants_5moment_t* pC,
                                   const solverVariables_t* pSV,
                                   const real* QC,
                                   real* QC_w);
 
void freeslipWallCondition(const solverVariables_t* pSV, const real* QC, real* QC_w);
 
void freeslipWallCondition_yu(const constants_5moment_t* pC,
                              const solverVariables_t* pSV,
                              const real* QC,
                              // const real vx_w,
                              // const real vy_w,
                              // const real vz_w,
                              real* QC_w);
 
void freeslipWallCondition_gradients_yu(const constants_5moment_t* pC,
                                        const solverVariables_t* pSV,
                                        const real* QC,
                                        real* QC_w);
 
void copyoutBoundaryCondition(const real* QC, real* QC_w);
 
void axisBoundaryCondition(const constants_5moment_t* pC,
                           const solverVariables_t* pSV,
                           const real* QC,
                           real* QC_w);
 
void axisBoundaryCondition_gradients(
    const constants_5moment_t* pC,
    const solverVariables_t* pSV,
    const real* QC,
    real* QC_w,
    const real rho_min = std::numeric_limits<real>::epsilon());
 
void imhd_to_twofluid_bc(const real* QC,
                         const solverVariables_t* pSV,
                         real Aa,
                         real Ab,
                         real Za,
                         real Zb,
                         real ztheta_ba,
                         real skin_depth_norm,
                         real* QC_w);
 
void imhd_to_twofluid_consistent_assumption(const real* QC,
                                            const solverVariables_t* pSV,
                                            real Ai,
                                            real Ae,
                                            real Zi,
                                            real Ze,
                                            real ztheta_ba,
                                            real skin_depth_norm,
                                            real* QC_w);
} // namespace bc
} // namespace five_moment
} // namespace apps
} // namespace wxm
 
// Wrappers of functions outside of namespace for backwards compatibility
// TODO: deprecate usage and replace with functions in namespace
 
real pressure_5moment(const constants_5moment_t* pC, const real QC[5]);