# 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.

$q_t + A q_x = 0$

where

$\begin{split}q(x,t) = \left [ \begin{array}{c} p(x,t) \\ u(x,t) \end{array} \right ]\end{split}$

and the coefficient matrix is

$\begin{split}A = \left [\begin{matrix} 0 & K\\ 1/\rho & 0 \end{matrix} \right ]\end{split}$

The parameters $$\rho =$$ 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)

$q_t + A q_x = 0.$
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

$u_t + \left ( \frac{1}{2} u^2 \right)_x = 0$
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):

$q_t + f(q)_x = 0$

where

$\begin{split}q(x,t) = \left [ \begin{array}{c} \rho \\ \rho u \\ E \end{array} \right ],\end{split}$

the flux function is

$\begin{split}f(q) = \left [ \begin{array}{c} \rho u \\ \rho u^2 + p \\ u(E+p) \end{array}\right ].\end{split}$

and $$\rho$$ 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:

$E = (\gamma - 1) \left (E - \frac{1}{2}\rho u^2 \right)$
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 - \gamma$$

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) $$\gamma - 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 - \gamma$$

• 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

$q_t + f(q)_x = 0$

where

$\begin{split}q(x,t) = \left [ \begin{array}{c} h \\ h u \end{array} \right ],\end{split}$

the flux function is

$\begin{split}f(q) = \left [ \begin{array}{c} h u \\ hu^2 + 1/2 g h^2 \end{array}\right ].\end{split}$

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)