# Pyclaw Limiters¶

Note

Need to provide short explanation of limiters here.

pyclaw.limiters.tvd.limit(num_eqn, wave, s, limiter, dtdx)

Apply a limiter to the waves

Function that limits the given waves using the methods contained in limiter. This is the vectorized version of the function acting on a row of waves at a time.

Input
• wave - (ndarray(:,num_eqn,num_waves)) The waves at each interface

• s - (ndarray(:,num_waves)) Speeds for each wave

• limiter - (int list) Array of type int determining which

limiter to use

• dtdx - (ndarray(:)) $$\Delta t / \Delta x$$ ratio, used for CFL

dependent limiters

Output
• (ndarray(:,num_eqn,num_waves)) - Returns the limited waves

Version

1.1 (2009-07-05)

## pyclaw.limiters.tvd¶

Library of limiter functions to be applied to waves

This module contains all of the standard limiters found in clawpack. To use any of the limiters, use the function limit to limit the appropriate waves. Refer to each limiter and the function limit’s doc strings.

This is a list of the provided limiters and their corresponding method number, note that some of the limiters actually correspond to a more general function which can be controlled more directly. Refer to the limiter function and its corresponding documentation for details.

### CFL Independent Limiters¶

1. minmod - minmod_limiter()

2. superbee - superbee_limiter()

3. van leer - $$(r + |r|) / (1 + |r|)$$

4. Beam-warming - $$r$$

5. Frommm - $$1/2 (1 + r)$$

6. Albada 2 - $$(r^2 + r) / (1 + r^2)$$

7. Albada 3 - $$1/2 (1+r) (1 - (|1-r|^3) / (1+|r|^3))$$

8. van Leer with Klein sharpening, k=2 - van_leer_klein_sharpening_limiter()

### CFL Dependent Limiters¶

1. Roe’s linear third order scheme - $$1 + (r-1) (1 + cfl) / 3$$

2. Arora-Roe (= limited version of the linear third order scheme) - arora_roe()

3. Theta Limiter, theta=0.95 (safety on nonlinear waves) - theta_limiter()

4. Theta Limiter, theta=0.75 - theta_limiter()

5. Theta Limiter, theta=0.5 - theta_limiter()

6. CFL-Superbee (Roe’s Ultrabee) - cfl_superbee()

7. CFL-Superbee (Roe’s Ultrabee) with theta=0.95 (nonlinear waves) - cfl_superbee_theta()

8. beta=2/3 limiter - beta_limiter()

9. beta=2/3 limiter with theta=0.95 (nonlinear waves) - beta_limiter()

10. Hyperbee - hyperbee_limiter()

11. SuperPower - superpower_limiter()

12. Cada-Torrilhon modified - cada_torrilhon_limiter()

13. Cada-Torrilhon modified, version for nonlinear waves - cada_torrilhon_limiter_nonlinear()

14. upper bound limiter (1st order) - upper_bound_limiter()

All limiters have the same function call signature:
Input
• r - (ndarray(:))

• cfl - (ndarray(:)) Local CFL number

Output
• (ndarray(:)) -

Newer limiters are based on work done by Friedemann Kemm [kemm_2009], paper in review.

Authors

Kyle Mandli and Randy LeVeque (2008-08-21) Initial version

Kyle Mandli (2009-07-05) Added CFL depdendent limiters

pyclaw.limiters.tvd.arora_roe(r, cfl)

Arora-Roe limiter, limited version of the linear third order scheme

pyclaw.limiters.tvd.beta_limiter(r, cfl, theta=0.95, beta=0.6666666666666666)

Modification of CFL Superbee limiter with theta and beta parameters

• theta

• beta

pyclaw.limiters.tvd.cada_torrilhon_limiter(r, cfl, epsilon=0.001)

• epsilon =

pyclaw.limiters.tvd.cada_torrilhon_limiter_nonlinear(r, cfl)

Cada-Torrilhon modified, version for nonlinear waves

pyclaw.limiters.tvd.cfl_superbee(r, cfl)

CFL-Superbee (Roe’s Ultrabee) without theta parameter

pyclaw.limiters.tvd.cfl_superbee_theta(r, cfl, theta=0.95)

CFL-Superbee (Roe’s Ultrabee) with theta parameter

pyclaw.limiters.tvd.hyperbee_limiter(r, cfl)

Hyperbee

pyclaw.limiters.tvd.mc_limiter(r, cfl)

MC vectorized limiter

pyclaw.limiters.tvd.minmod_limiter(r, cfl)

Minmod vectorized limiter

pyclaw.limiters.tvd.superbee_limiter(r, cfl)

Superbee vectorized limiter

pyclaw.limiters.tvd.superpower_limiter(r, cfl, caut=1.0)

SuperPower limiter

• caut = Limiter parameter

pyclaw.limiters.tvd.theta_limiter(r, cfl, theta=0.95)

Theta limiter

pyclaw.limiters.tvd.upper_bound_limiter(r, cfl, theta=1.0)
pyclaw.limiters.tvd.van_leer_klein_sharpening_limiter(r, cfl)