Riemann Solver Package¶
This package contains all of the Pythonbased 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_ghost2 mx+num_ghost mx+num_ghost+2
 mx+num_ghost1  mx+num_ghost+1
     ...     
0 1  2 3 mx+num_ghost2 mx+num_ghost
mx+num_ghost1 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:
i1 i i+1
  
 i1  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
$i1/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 \(\rho =\) density and \(K =\) bulk modulus are used to calculate the impedence \(= Z\) and speed of sound = c.
 Authors
Kyle T. Mandli (20090203): 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 (20090203)
Advection
¶
Simple advection Riemann solvers
Basic advection Riemann solvers of the form (1d)
 Authors
Kyle T. Mandli (2008220): 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 (2008220)
Burgers Equation
¶
Riemann solvers for Burgers equation
 Authors
Kyle T. Mandli (200924): 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 (200924)
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 \(\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:

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_lc_l,u_l+c_l,lambda_roe_1,lambda_roe_2) W_2 = Q_r  Q_hat s_2 = max(u_rc_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 (20140304)

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_lc_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_rc_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_lu_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 (20151118)

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 (2009626)
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 drystate is calculated.
 Version
1.0 (20140905)
 Version
2.0 (20170307)

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_lc_l,u_l+c_l,lambda_roe_1,lambda_roe_2) W_2 = Q_r  Q_hat s_2 = max(u_rc_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 (20090205)

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 (20090205)