Riemann Solver Package¶
This package contains all of the Python-based Riemann solvers. Each module solves the Riemann solver for a particular system of hyperbolic equations. The solvers all have a common function signature:
rp_<name>_<dim>d(q_l,q_r,aux_l,aux_r,problem_data)
with <name>
replaced with the appropriate solver name and <dim>
with
the appropriate dimension.
- Input:
q_l - (ndarray(…,num_eqn)) Contains the left states of the Riemann problem
q_r - (ndarray(…,num_eqn)) Contains the right states of the Riemann problem
aux_l - (ndarray(…,num_aux)) Contains the left values of the auxiliary array
aux_r - (ndarray(…,num_aux)) Contains the right values oft he auxiliary array
- problem_data - (dict) Dictionary containing miscellaneous data which is
usually problem dependent.
- Output:
- wave - (ndarray(…,num_eqn,num_waves)) Contains the resulting waves from the cell
edge
s - (ndarray(…,num_waves)) Speeds of each wave
amdq - (ndarray(…,num_eqn)) Left going fluctuation
apdq - (ndarray(…,num_eqn)) Right going fluctuation
Except for problem_data, all of the input and output values are arrays whose elements represent grid values with locations indicated by the following scheme
Indexing works like this: here num_ghost=2 as an example
0 1 2 3 4 mx+num_ghost-2 mx+num_ghost mx+num_ghost+2
| mx+num_ghost-1 | mx+num_ghost+1
| | | | | ... | | | | |
0 1 | 2 3 mx+num_ghost-2 |mx+num_ghost
mx+num_ghost-1 mx+num_ghost+1
The top indices represent the values that are located on the grid
cell boundaries such as waves, s and other Riemann problem values,
the bottom for the cell centered values. In particular the ith grid cell
boundary has the following related information:
i-1 i i+1
| | |
| i-1 | i |
| | |
Again, grid cell boundary quantities are at the top, cell centered
values are in the cell.
Note
The values q_l[i]
, q_r[i]
are the left and right states, respectively, of
the ith
Riemann problem. This convention is different than that used in
the Fortran Riemann solvers, where q_l[i]
, q_r[i]
are the values at the
left and right edges of a cell.
All of the return values (waves, speeds, and fluctuations) are indexed by cell edge
(Riemann problem being solved), with s[i]
referring to the wave speed at interface
$i-1/2$. This follows the same convention used in the Fortran solvers.
See [LeVeque_book_2002] for more details.
List of available Riemann solvers:
Acoustics
¶
Riemann solvers for constant coefficient acoustics.
where
and the coefficient matrix is
The parameters ρ= density and K= bulk modulus are used to calculate the impedence =Z and speed of sound = c.
- Authors:
Kyle T. Mandli (2009-02-03): Initial version
- clawpack.riemann.acoustics_1D_py.acoustics_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
Basic 1d acoustics riemann solver, with interleaved arrays
- problem_data is expected to contain -
zz - (float) Impedence
cc - (float) Speed of sound
See Riemann Solver Package for more details.
- Version:
1.0 (2009-02-03)
Advection
¶
Simple advection Riemann solvers
Basic advection Riemann solvers of the form (1d)
- Authors:
Kyle T. Mandli (2008-2-20): Initial version
- clawpack.riemann.advection_1D_py.advection_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
Basic 1d advection riemann solver
- problem_data should contain -
u - (float) Determines advection speed
See Riemann Solver Package for more details.
- Version:
1.0 (2008-2-20)
Burgers Equation
¶
Riemann solvers for Burgers equation
- Authors:
Kyle T. Mandli (2009-2-4): Initial version
- clawpack.riemann.burgers_1D_py.burgers_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
Riemann solver for Burgers equation in 1d
- problem_data should contain -
efix - (bool) Whether a entropy fix should be used, if not present, false is assumed
See Riemann Solver Package for more details.
- Version:
1.0 (2009-2-4)
Euler Equations
¶
Riemann solvers for the Euler equations
This module contains Riemann solvers for the Euler equations which have the form (in 1d):
where
the flux function is
and ρ is the density, u the velocity, E is the energy and p is the pressure.
Unless otherwise noted, the ideal gas equation of state is used:
- clawpack.riemann.euler_1D_py.euler_exact_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
Exact euler Riemann solver
Warning
This solver has not been implemented.
- clawpack.riemann.euler_1D_py.euler_hll_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
HLL euler solver
W_1 = Q_hat - Q_l s_1 = min(u_l-c_l,u_l+c_l,lambda_roe_1,lambda_roe_2) W_2 = Q_r - Q_hat s_2 = max(u_r-c_r,u_r+c_r,lambda_roe_1,lambda_roe_2) Q_hat = ( f(q_r) - f(q_l) - s_2 * q_r + s_1 * q_l ) / (s_1 - s_2)
- problem_data should contain:
gamma - (float) Ratio of the heat capacities
gamma1 - (float) 1−γ
- Version:
1.0 (2014-03-04)
- clawpack.riemann.euler_1D_py.euler_hllc_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
HLLC Euler solver
W_1 = q_hat_l - q_l s_1 = min(u_l-c_l,u_l+c_l,lambda_roe_1,lambda_roe_2) W_2 = q_hat_r - q_hat_l s_2 = s_m W_3 = q_r - q_hat_r s_3 = max(u_r-c_r,u_r+c_r,lambda_roe_1,lambda_roe_2) s_m = (p_r - p_l + rho_l*u_l*(s_l - u_l) - rho_r*u_r*(s_r - u_r))\ / (rho_l*(s_l-u_l) - rho_r*(s_r - u_r))
left middle state:
q_hat_l[0,:] = rho_l*(s_l - u_l)/(s_l - s_m) q_hat_l[1,:] = rho_l*(s_l - u_l)/(s_l - s_m)*s_m q_hat_l[2,:] = rho_l*(s_l - u_l)/(s_l - s_m)\ *(E_l/rho_l + (s_m - u_l)*(s_m + p_l/(rho_l*(s_l - u_l))))
right middle state:
q_hat_r[0,:] = rho_r*(s_r - u_r)/(s_r - s_m) q_hat_r[1,:] = rho_r*(s_r - u_r)/(s_r - s_m)*s_m q_hat_r[2,:] = rho_r*(s_r - u_r)/(s_r - s_m)\ *(E_r/rho_r + (s_m - u_r)*(s_m + p_r/(rho_r*(s_r - u_r))))
problem_data should contain:
gamma: (float) Ratio of specific heat capacities
gamma1: (float) γ−1
:Version 1.0 (2015-11-18)
- clawpack.riemann.euler_1D_py.euler_roe_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
Roe Euler solver in 1d
- aug_global should contain -
gamma - (float) Ratio of the heat capacities
gamma1 - (float) 1−γ
efix - (bool) Whether to use an entropy fix or not
See Riemann Solver Package for more details.
- Version:
1.0 (2009-6-26)
Shallow Water Equations
¶
Riemann solvers for the shallow water equations.
- The available solvers are:
Roe - Use Roe averages to caluclate the solution to the Riemann problem
HLL - Use a HLL solver
- Exact - Use a newton iteration to calculate the exact solution to the
Riemann problem
where
the flux function is
and h is the water column height, u the velocity and g is the gravitational acceleration.
- clawpack.riemann.shallow_1D_py.shallow_exact_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
Exact shallow water Riemann solver
Warning
This solver has not been implemented.
- clawpack.riemann.shallow_1D_py.shallow_fwave_1d(q_l, q_r, aux_l, aux_r, problem_data)¶
Shallow water Riemann solver using fwaves
Also includes support for bathymetry but be wary if you think you might have dry states as this has not been tested.
- problem_data should contain:
grav - (float) Gravitational constant
dry_tolerance - (float) Set velocities to zero if h is below this tolerance.
sea_level - (float) Datum from which the dry-state is calculated.
- Version:
1.0 (2014-09-05)
- Version:
2.0 (2017-03-07)
- clawpack.riemann.shallow_1D_py.shallow_hll_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
HLL shallow water solver
W_1 = Q_hat - Q_l s_1 = min(u_l-c_l,u_l+c_l,lambda_roe_1,lambda_roe_2) W_2 = Q_r - Q_hat s_2 = max(u_r-c_r,u_r+c_r,lambda_roe_1,lambda_roe_2) Q_hat = ( f(q_r) - f(q_l) - s_2 * q_r + s_1 * q_l ) / (s_1 - s_2)
- problem_data should contain:
g - (float) Gravitational constant
- Version:
1.0 (2009-02-05)
- clawpack.riemann.shallow_1D_py.shallow_roe_1D(q_l, q_r, aux_l, aux_r, problem_data)¶
Roe shallow water solver in 1d:
ubar = (sqrt(u_l) + sqrt(u_r)) / (sqrt(h_l) + sqrt(h_r)) cbar = sqrt( 0.5 * g * (h_l + h_r)) W_1 = | 1 | s_1 = ubar - cbar | ubar - cbar | W_2 = | 1 | s_1 = ubar + cbar | ubar + cbar | a1 = 0.5 * ( - delta_hu + (ubar + cbar) * delta_h ) / cbar a2 = 0.5 * ( delta_hu - (ubar - cbar) * delta_h ) / cbar
- problem_data should contain:
g - (float) Gravitational constant
efix - (bool) Boolean as to whether a entropy fix should be used, if not present, false is assumed
- Version:
1.0 (2009-02-05)