imhd.h

Go to the documentation of this file.

#pragma once
 
#include <cmath>
 
#include "warpxm/warpxm_config.h"
#include "apps/general_functions/geometry.h"
 
 
real max_wave_speed(const real gas_gamma,
                    const real* q,
                    const real rho_min = std::numeric_limits<real>::epsilon(),
                    const real press_min = std::numeric_limits<real>::epsilon());
 
real max_wave_speed_magnitude(
    const real gas_gamma,
    const real* q,
    const real rho_min = std::numeric_limits<real>::epsilon(),
    const real press_min = std::numeric_limits<real>::epsilon());
 
real min_wave_speed(real gas_gamma,
                    const real* q,
                    const real rho_min = std::numeric_limits<real>::epsilon(),
                    const real press_min = std::numeric_limits<real>::epsilon());
 
real calc_fast_magnetosonic(real gas_gamma,
                            const real* q,
                            const real rho_min = std::numeric_limits<real>::epsilon(),
                            const real press_min = std::numeric_limits<real>::epsilon());
 
real calc_slow_magnetosonic(real gas_gamma,
                            const real* q,
                            const real rho_min = std::numeric_limits<real>::epsilon(),
                            const real press_min = std::numeric_limits<real>::epsilon());
 
void calc_magnetosonic_speeds(
    const real gas_gamma,
    const real* q,
    real* c,
    const real rho_min = std::numeric_limits<real>::epsilon(),
    const real press_min = std::numeric_limits<real>::epsilon());
 
real rusanov_flux(const real gas_gamma,
                  const real* ql,
                  const real* qr,
                  const real* F_L,
                  const real* F_R,
                  real* F_num,
                  const real rho_min = std::numeric_limits<real>::epsilon(),
                  const real press_min = std::numeric_limits<real>::epsilon());
 
real hll_flux(const real gas_gamma,
              const real* ql,
              const real* qr,
              const real* F_L,
              const real* F_R,
              real* F_num,
              const real rho_min = std::numeric_limits<real>::epsilon(),
              const real press_min = std::numeric_limits<real>::epsilon());
 
real hlld_flux(const real gas_gamma,
               const real* ql,
               const real* qr,
               const real* F_L,
               const real* F_R,
               real* F_num,
               const real rho_min = std::numeric_limits<real>::epsilon(),
               const real press_min = std::numeric_limits<real>::epsilon());
 
real get_avg(real a, real b);
 
real get_delta_lambda_k(const real lambda_k_R, const real lambda_k_L);
 
real get_lambda_k_star(const real lambda_k_roe,
                       const real lambda_k_R,
                       const real lambda_k_L);
 
real roe_flux(const real gas_gamma,
              const real* ql,
              const real* qr,
              const real* F_L,
              const real* F_R,
              real* F_num,
              const real rho_min = std::numeric_limits<real>::epsilon(),
              const real press_min = std::numeric_limits<real>::epsilon());
 
void imhd_numerical_flux_local_frame(
    const real gas_gamma,
    const real* q,
    real* f,
    const real rho_min = std::numeric_limits<real>::epsilon(),
    const real press_min = std::numeric_limits<real>::epsilon());
 
real imhd_numerical_flux(const real gas_gamma,
                         const real* q_l,
                         const real* q_r,
                         const real* aux_l,
                         const real* aux_r,
                         const solverVariables_t* pFV,
                         const std::string& flux_type,
                         real* numericalFlux,
                         const real rho_min = std::numeric_limits<real>::epsilon(),
                         const real press_min = std::numeric_limits<real>::epsilon());
 
void imhd_internal_flux(const real gas_gamma,
                        const solverVariables_t* pSV,
                        const real* q,
                        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 CtoNC_MHD(const real gas_gamma,
               const real QC[8],
               real QNC[8],
               const real rho_min = std::numeric_limits<real>::epsilon(),
               const real press_min = std::numeric_limits<real>::epsilon());
 
void NCtoC_MHD(const real gas_gamma,
               const real QNC[8],
               real QC[8],
               const real rho_min = std::numeric_limits<real>::epsilon());
 
void dqdw_MHD(const real gas_gamma,
              const real Q[8],
              real dqdw[][8],
              const real rho_min = std::numeric_limits<real>::epsilon(),
              const real press_min = std::numeric_limits<real>::epsilon());
 
void dwdq_MHD(const real gas_gamma,
              const real Q[8],
              real dwdq[][8],
              const real rho_min = std::numeric_limits<real>::epsilon(),
              const real press_min = std::numeric_limits<real>::epsilon());
 
void conducting_wall_noslip(const real gas_gamma,
                            const solverVariables_t* pFV,
                            const real* QC,
                            const real vx_w,
                            const real vy_w,
                            const real vz_w,
                            real* QC_w,
                            const real rho_min = std::numeric_limits<real>::epsilon(),
                            const real press_min = std::numeric_limits<real>::epsilon());
 
void conducting_wall_noslip_old(
    const real gas_gamma,
    const solverVariables_t* pFV,
    const real* QC,
    const real vx_w,
    const real vy_w,
    const real vz_w,
    real* QC_w,
    const real rho_min = std::numeric_limits<real>::epsilon(),
    const real press_min = std::numeric_limits<real>::epsilon());
 
void conducting_wall_noslip_gradients(
    const real gas_gamma,
    const solverVariables_t* pFV,
    const real* QC,
    real* QC_w,
    const real rho_min = std::numeric_limits<real>::epsilon(),
    const real press_min = std::numeric_limits<real>::epsilon());
 
void conducting_wall_freeslip(
    const real gas_gamma,
    const solverVariables_t* pFV,
    const real* QC,
    real* QC_w,
    const real rho_min = std::numeric_limits<real>::epsilon(),
    const real press_min = std::numeric_limits<real>::epsilon());
 
void conducting_wall_freeslip_gradients(
    const real gas_gamma,
    const solverVariables_t* pFV,
    const real* QC,
    const real* aux_in,
    const real* aux_out,
    real* QC_w,
    const real rho_min = std::numeric_limits<real>::epsilon(),
    const real press_min = std::numeric_limits<real>::epsilon());
 
void twofluid_to_imhd(const real* QC,
                      const solverVariables_t* pSV,
                      real oc_sd,
                      real* QC_w);
 
void copyout(const real* QC, real* QC_w);
 
void copyout_gradients(const real* grad_QC, real* grad_QC_w);
 
void freeslipWallCondition_imhd(
    const real gas_gamma,
    const solverVariables_t* pFV,
    const real* QC,
    real* QC_w,
    const real rho_min = std::numeric_limits<real>::epsilon(),
    const real press_min = std::numeric_limits<real>::epsilon());
 
void applyLdgPenaltyEta(const solverVariables_t* pFV,
                        const real* q_l,
                        const real* q_r,
                        real* numericalFlux);