def setup(nx=100,
kernel_language='Python',
use_petsc=False,
solver_type='classic',
weno_order=5,
time_integrator='SSP104',
outdir='./_output'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language == 'Fortran':
riemann_solver = riemann.advection_1D
elif kernel_language == 'Python':
riemann_solver = riemann.advection_1D_py.advection_1D
if solver_type == 'classic':
solver = pyclaw.ClawSolver1D(riemann_solver)
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(riemann_solver)
solver.weno_order = weno_order
solver.time_integrator = time_integrator
else:
raise Exception('Unrecognized value of solver_type.')
solver.kernel_language = kernel_language
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
x = pyclaw.Dimension(0.0, 1.0, nx, name='x')
domain = pyclaw.Domain(x)
state = pyclaw.State(domain, solver.num_eqn)
state.problem_data['u'] = 1. # Advection velocity
# Initial data
xc = state.grid.x.centers
beta = 100
gamma = 0
x0 = 0.75
state.q[0, :] = np.exp(-beta * (xc - x0)**2) * np.cos(gamma * (xc - x0))
claw = pyclaw.Controller()
claw.keep_copy = True
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
if outdir is not None:
claw.outdir = outdir
else:
claw.output_format = None
claw.tfinal = 1.0
claw.setplot = setplot
return claw
def setup(use_petsc=0,
kernel_language='Fortran',
outdir='./_output',
solver_type='classic'):
"""
Example python script for solving the 1d Burgers equation.
"""
import numpy as np
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
#===========================================================================
# Setup solver and solver parameters
#===========================================================================
if solver_type == 'sharpclaw':
if kernel_language == 'Python':
solver = pyclaw.SharpClawSolver1D(riemann.burgers_1D_py.burgers_1D)
elif kernel_language == 'Fortran':
solver = pyclaw.SharpClawSolver1D(riemann.burgers_1D)
else:
if kernel_language == 'Python':
solver = pyclaw.ClawSolver1D(riemann.burgers_1D_py.burgers_1D)
elif kernel_language == 'Fortran':
solver = pyclaw.ClawSolver1D(riemann.burgers_1D)
solver.limiters = pyclaw.limiters.tvd.vanleer
solver.kernel_language = kernel_language
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
#===========================================================================
# Initialize domain and then initialize the solution associated to the domain
#===========================================================================
x = pyclaw.Dimension('x', 0.0, 1.0, 500)
domain = pyclaw.Domain(x)
num_eqn = 1
state = pyclaw.State(domain, num_eqn)
grid = state.grid
xc = grid.x.centers
state.q[0, :] = np.sin(np.pi * 2 * xc) + 0.50
state.problem_data['efix'] = True
#===========================================================================
# Setup controller and controller parameters. Then solve the problem
#===========================================================================
claw = pyclaw.Controller()
claw.tfinal = 0.5
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
return claw
def setup(use_petsc=False, outdir='./_output', solver_type='classic'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'classic':
solver = pyclaw.ClawSolver2D(riemann.advection_2D)
solver.dimensional_split = 1
solver.limiters = pyclaw.limiters.tvd.vanleer
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver2D(riemann.advection_2D)
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
solver.bc_lower[1] = pyclaw.BC.periodic
solver.bc_upper[1] = pyclaw.BC.periodic
solver.cfl_max = 1.0
solver.cfl_desired = 0.9
# Domain:
mx = 50
my = 50
x = pyclaw.Dimension(0.0, 1.0, mx, name='x')
y = pyclaw.Dimension(0.0, 1.0, my, name='y')
domain = pyclaw.Domain([x, y])
num_eqn = 1
state = pyclaw.State(domain, num_eqn)
state.problem_data['u'] = 0.5 # Advection velocity
state.problem_data['v'] = 1.0
qinit(state)
claw = pyclaw.Controller()
claw.tfinal = 2.0
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=False, outdir='./_output', solver_type='classic'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'classic':
solver = pyclaw.ClawSolver2D(riemann.shallow_roe_with_efix_2D)
solver.limiters = pyclaw.limiters.tvd.MC
solver.dimensional_split = 1
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver2D(riemann.shallow_roe_with_efix_2D)
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.wall
solver.bc_lower[1] = pyclaw.BC.extrap
solver.bc_upper[1] = pyclaw.BC.wall
# Domain:
xlower = -2.5
xupper = 2.5
mx = 150
ylower = -2.5
yupper = 2.5
my = 150
x = pyclaw.Dimension('x', xlower, xupper, mx)
y = pyclaw.Dimension('y', ylower, yupper, my)
domain = pyclaw.Domain([x, y])
state = pyclaw.State(domain, solver.num_eqn)
# Gravitational constant
state.problem_data['grav'] = 1.0
qinit(state)
claw = pyclaw.Controller()
claw.tfinal = 2.5
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.num_output_times = 10
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=False, outdir='./_output', solver_type='classic'):
"""
Example python script for solving the 2d KPP equations.
"""
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver2D(riemann.kpp_2D)
else:
solver = pyclaw.ClawSolver2D(riemann.kpp_2D)
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
solver.bc_lower[1] = pyclaw.BC.extrap
solver.bc_upper[1] = pyclaw.BC.extrap
# Initialize domain
mx = 200
my = 200
x = pyclaw.Dimension('x', -2.0, 2.0, mx)
y = pyclaw.Dimension('y', -2.0, 2.0, my)
domain = pyclaw.Domain([x, y])
state = pyclaw.State(domain, solver.num_eqn)
qinit(state)
solver.dimensional_split = 1
solver.cfl_max = 1.0
solver.cfl_desired = 0.9
solver.limiters = pyclaw.limiters.tvd.minmod
claw = pyclaw.Controller()
claw.tfinal = 1.0
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.num_output_times = 10
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=False,
solver_type='classic',
kernel_language='Python',
outdir='./_output'):
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'classic':
if kernel_language == 'Fortran':
solver = pyclaw.ClawSolver1D(riemann.advection_color_1D)
elif kernel_language == 'Python':
solver = pyclaw.ClawSolver1D(
riemann.vc_advection_1D_py.vc_advection_1D)
elif solver_type == 'sharpclaw':
if kernel_language == 'Fortran':
solver = pyclaw.SharpClawSolver1D(riemann.advection_color_1D)
elif kernel_language == 'Python':
solver = pyclaw.SharpClawSolver1D(
riemann.vc_advection_1D_py.vc_advection_1D)
solver.weno_order = weno_order
else:
raise Exception('Unrecognized value of solver_type.')
solver.kernel_language = kernel_language
solver.limiters = pyclaw.limiters.tvd.MC
solver.bc_lower[0] = 2
solver.bc_upper[0] = 2
solver.aux_bc_lower[0] = 2
solver.aux_bc_upper[0] = 2
xlower = 0.0
xupper = 1.0
mx = 100
x = pyclaw.Dimension(xlower, xupper, mx, name='x')
domain = pyclaw.Domain(x)
num_aux = 1
num_eqn = 1
state = pyclaw.State(domain, num_eqn, num_aux)
qinit(state)
auxinit(state)
claw = pyclaw.Controller()
claw.outdir = outdir
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.tfinal = 1.0
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=False,
iplot=False,
htmlplot=False,
outdir='./_output',
solver_type='sharpclaw',
kernel_language='Fortran'):
"""
Solve the Euler equations of compressible fluid dynamics.
This example involves a shock wave impacting a sinusoidal density field.
"""
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(riemann.euler_with_efix_1D)
solver.time_integrator = 'RK'
solver.a, solver.b, solver.c = a, b, c
solver.cfl_desired = 0.6
solver.cfl_max = 0.7
else:
solver = pyclaw.ClawSolver1D(riemann.euler_with_efix_1D)
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
# Initialize domain
mx = 400
x = pyclaw.Dimension('x', -5.0, 5.0, mx)
domain = pyclaw.Domain([x])
state = pyclaw.State(domain, solver.num_eqn)
state.problem_data['gamma'] = gamma
state.problem_data['gamma1'] = gamma1
xc = state.grid.x.centers
epsilon = 0.2
state.q[0, :] = (xc < -4.) * 3.857143 + (xc >= -4.) * (
1 + epsilon * np.sin(5 * xc))
velocity = (xc < -4.) * 2.629369
state.q[1, :] = velocity * state.q[0, :]
pressure = (xc < -4.) * 10.33333 + (xc >= -4.) * 1.
state.q[2, :] = pressure / gamma1 + 0.5 * state.q[0, :] * velocity**2
claw = pyclaw.Controller()
claw.tfinal = 1.8
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.num_output_times = 10
claw.outdir = outdir
claw.setplot = setplot
return claw
def setup(use_petsc=False, outdir='./_output', solver_type='classic'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver2D(riemann.kpp_2D)
else:
solver = pyclaw.ClawSolver2D(riemann.kpp_2D)
solver.dimensional_split = 1
solver.cfl_max = 1.0
solver.cfl_desired = 0.9
solver.limiters = pyclaw.limiters.tvd.minmod
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
solver.bc_lower[1] = pyclaw.BC.extrap
solver.bc_upper[1] = pyclaw.BC.extrap
# Initialize domain
mx = 200
my = 200
x = pyclaw.Dimension(-2.0, 2.0, mx, name='x')
y = pyclaw.Dimension(-2.0, 2.0, my, name='y')
domain = pyclaw.Domain([x, y])
state = pyclaw.State(domain, solver.num_eqn)
# Initial data
X, Y = state.grid.p_centers
r = np.sqrt(X**2 + Y**2)
state.q[0, :, :] = 0.25 * np.pi + 3.25 * np.pi * (r <= 1.0)
claw = pyclaw.Controller()
claw.tfinal = 1.0
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(kernel_language='Fortran',
solver_type='classic',
use_petsc=False,
outdir='./_output'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language == 'Fortran':
solver = pyclaw.ClawSolver1D(riemann.shallow_bathymetry_fwave_1D)
elif kernel_language == 'Python':
solver = pyclaw.ClawSolver1D(riemann.shallow_1D_py.shallow_fwave_1d)
solver.kernel_language = 'Python'
solver.limiters = pyclaw.limiters.tvd.vanleer
solver.fwave = True
solver.num_waves = 2
solver.num_eqn = 2
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
solver.aux_bc_lower[0] = pyclaw.BC.extrap
solver.aux_bc_upper[0] = pyclaw.BC.extrap
xlower = -1.0
xupper = 1.0
x = pyclaw.Dimension(xlower, xupper, 500, name='x')
domain = pyclaw.Domain(x)
state = pyclaw.State(domain, 2, 1)
# Gravitational constant
state.problem_data['grav'] = 9.8
state.problem_data['dry_tolerance'] = 1e-3
state.problem_data['sea_level'] = 0.0
xc = state.grid.x.centers
state.aux[0, :] = 0.8 * numpy.exp(-xc**2 / 0.2**2) - 1.0
state.q[0, :] = 0.1 * numpy.exp(-(xc + 0.4)**2 / 0.2**2) - state.aux[0, :]
state.q[1, :] = 0.0
claw = pyclaw.Controller()
claw.keep_copy = True
claw.tfinal = 1.0
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.setplot = setplot
claw.write_aux_init = True
if outdir is not None:
claw.outdir = outdir
else:
claw.output_format = None
return claw
def setup(use_petsc=0, outdir='./_output', solver_type='classic'):
"""
Example python script for solving 1d traffic model:
$$ q_t + umax( q(1-q) )_x = 0.$$
"""
import numpy as np
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
#===========================================================================
# Setup solver and solver parameters
#===========================================================================
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(riemann.traffic_1D)
else:
solver = pyclaw.ClawSolver1D(riemann.traffic_1D)
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
#===========================================================================
# Initialize domain and then initialize the solution associated to the domain
#===========================================================================
x = pyclaw.Dimension('x', -1.0, 1.0, 500)
domain = pyclaw.Domain(x)
num_eqn = 1
state = pyclaw.State(domain, num_eqn)
grid = state.grid
xc = grid.x.centers
state.q[0, :] = 0.75 * (xc < 0) + 0.1 * (xc > 0.)
state.problem_data['efix'] = True
state.problem_data['umax'] = 1.
#===========================================================================
# Setup controller and controller parameters. Then solve the problem
#===========================================================================
claw = pyclaw.Controller()
claw.tfinal = 2.0
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=False, outdir='./_output', solver_type='classic'):
"""
Solve the Euler equations of compressible fluid dynamics.
This example involves a pair of interacting shock waves.
The conserved quantities are density, momentum density, and total energy density.
"""
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(riemann.euler_with_efix_1D)
else:
solver = pyclaw.ClawSolver1D(riemann.euler_with_efix_1D)
solver.bc_lower[0] = pyclaw.BC.wall
solver.bc_upper[0] = pyclaw.BC.wall
# Initialize domain
mx = 500
x = pyclaw.Dimension('x', 0.0, 1.0, mx)
domain = pyclaw.Domain([x])
num_eqn = 3
state = pyclaw.State(domain, num_eqn)
state.problem_data['gamma'] = gamma
state.problem_data['gamma1'] = gamma1
state.q[0, :] = 1.
state.q[1, :] = 0.
x = state.grid.x.centers
state.q[2, :] = ((x < 0.1) * 1.e3 + (0.1 <= x) * (x < 0.9) * 1.e-2 +
(0.9 <= x) * 1.e2) / gamma1
solver.limiters = 4
claw = pyclaw.Controller()
claw.tfinal = 0.038
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.num_output_times = 10
claw.outdir = outdir
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=0,
kernel_language='Python',
outdir='./_output',
solver_type='classic'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language == 'Python':
riemann_solver = adsolver
elif kernel_language == 'Fortran':
riemann_solver = riemann.burgers_1D
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(riemann_solver)
else:
solver = pyclaw.ClawSolver1D(riemann_solver)
solver.limiters = pyclaw.limiters.tvd.vanleer
solver.kernel_language = kernel_language
solver.bc_lower[0] = pyclaw.BC.periodic
#solver.user_bc_lower=custom_bc_one
solver.bc_upper[0] = pyclaw.BC.periodic
#solver.user_bc_upper=custom_bc_two
solver.num_waves = 1
solver.num_eqn = 1
x = pyclaw.Dimension(0.0, 1.0, 500, name='x')
domain = pyclaw.Domain(x)
num_eqn = 1
state = pyclaw.State(domain, num_eqn)
xc = state.grid.x.centers
state.q[0, :] = np.sin(np.pi * 2 * xc) + 0.50
state.problem_data['efix'] = True
state.problem_data['a'] = 1.0
claw = pyclaw.Controller()
claw.tfinal = 2.0
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.setplot = setplot
claw.keep_copy = True
return claw
def vc_advection(use_petsc=False,solver_type='classic',kernel_language='Python',iplot=False,htmlplot=False,outdir='./_output'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type=='sharpclaw':
solver = pyclaw.SharpClawSolver1D()
else:
solver = pyclaw.ClawSolver1D()
from clawpack import riemann
solver.num_waves = riemann.rp_vc_advection.num_waves
solver.kernel_language = kernel_language
if solver.kernel_language=='Python':
solver.rp = riemann.rp_vc_advection.rp_vc_advection_1d
elif solver.kernel_language=='Fortran':
raise NotImplementedError('The 1D variable coefficient advection Riemann solver has not yet been ported.')
solver.limiters = pyclaw.limiters.tvd.MC
solver.bc_lower[0] = 2
solver.bc_upper[0] = 2
solver.aux_bc_lower[0] = 2
solver.aux_bc_upper[0] = 2
xlower=0.0; xupper=1.0; mx=100
x = pyclaw.Dimension('x',xlower,xupper,mx)
domain = pyclaw.Domain(x)
num_aux=1
num_eqn = 1
state = pyclaw.State(domain,num_eqn,num_aux)
qinit(state)
auxinit(state)
claw = pyclaw.Controller()
claw.outdir = outdir
claw.solution = pyclaw.Solution(state,domain)
claw.solver = solver
claw.tfinal = 1.0
status = claw.run()
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
def setup(use_petsc=0,
kernel_language='Fortran',
outdir='./_output',
solver_type='classic'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language == 'Python':
riemann_solver = riemann.burgers_1D_py.burgers_1D
elif kernel_language == 'Fortran':
riemann_solver = riemann.burgers_1D
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(riemann_solver)
else:
solver = pyclaw.ClawSolver1D(riemann_solver)
solver.limiters = pyclaw.limiters.tvd.vanleer
solver.kernel_language = kernel_language
solver.bc_lower[0] = pyclaw.BC.custom
solver.user_bc_lower = custom_bc
solver.bc_upper[0] = pyclaw.BC.custom
solver.user_bc_upper = custom_bc
x = pyclaw.Dimension(-100.0, 100.0, steps, name='x')
domain = pyclaw.Domain(x)
num_eqn = 1
state = pyclaw.State(domain, num_eqn)
xc = state.grid.x.centers
state.q[0, :] = np.exp(-xc**2)
state.problem_data['efix'] = True
claw = pyclaw.Controller()
claw.tfinal = 10.0
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=0, outdir='./_output', solver_type='classic', weno_order=5, N=1000):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
riemann_solver = riemann.cubic_1D
if solver_type=='sharpclaw':
solver = pyclaw.SharpClawSolver1D(riemann_solver)
solver.weno_order = weno_order
else:
solver = pyclaw.ClawSolver1D(riemann_solver)
solver.limiters = pyclaw.limiters.tvd.vanleer
solver.cfl_max = 1.0
solver.cfl_desired = 0.5
solver.kernel_language = 'Fortran'
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
x = pyclaw.Dimension(-1.0, 3.0, N, name='x')
domain = pyclaw.Domain(x)
num_eqn = 1
state = pyclaw.State(domain, num_eqn)
xc = state.grid.x.centers
qL = 4.0
qR = -2.0
state.q[0,:] = (xc < -0.5) * qL + (xc >= -0.5) * qR
claw = pyclaw.Controller()
claw.tfinal = 0.2
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=0,outdir='./_output',solver_type='classic'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type=='sharpclaw':
solver = pyclaw.SharpClawSolver1D(riemann.traffic_1D)
else:
solver = pyclaw.ClawSolver1D(riemann.traffic_1D)
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
x = pyclaw.Dimension('x',-1.0,1.0,500)
domain = pyclaw.Domain(x)
num_eqn = 1
state = pyclaw.State(domain,num_eqn)
grid = state.grid
xc=grid.p_centers[0]
state.q[0,:] = 0.75*(xc<0) + 0.1*(xc>0.)
state.problem_data['efix']=True
state.problem_data['umax']=1.
claw = pyclaw.Controller()
claw.tfinal =2.0
claw.solution = pyclaw.Solution(state,domain)
claw.solver = solver
claw.outdir = outdir
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=False,outdir='./_output',solver_type='classic'):
#===========================================================================
# Import libraries
#===========================================================================
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
#===========================================================================
# Setup solver and solver parameters
#===========================================================================
if solver_type == 'classic':
solver = pyclaw.ClawSolver2D(riemann.shallow_roe_with_efix_2D)
solver.limiters = pyclaw.limiters.tvd.MC
solver.dimensional_split=1
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver2D(riemann.shallow_roe_with_efix_2D)
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.wall
solver.bc_lower[1] = pyclaw.BC.extrap
solver.bc_upper[1] = pyclaw.BC.wall
#===========================================================================
# Initialize domain and state, then initialize the solution associated to the
# state and finally initialize aux array
#===========================================================================
# Domain:
xlower = -2.5
xupper = 2.5
mx = 150
ylower = -2.5
yupper = 2.5
my = 150
x = pyclaw.Dimension('x',xlower,xupper,mx)
y = pyclaw.Dimension('y',ylower,yupper,my)
domain = pyclaw.Domain([x,y])
state = pyclaw.State(domain,solver.num_eqn)
grav = 1.0 # Parameter (global auxiliary variable)
state.problem_data['grav'] = grav
# Initial solution
# ================
# Riemann states of the dam break problem
damRadius = 0.5
hl = 2.
ul = 0.
vl = 0.
hr = 1.
ur = 0.
vr = 0.
qinit(state,hl,ul,vl,hr,ur,vr,damRadius) # This function is defined above
#===========================================================================
# Set up controller and controller parameters
#===========================================================================
claw = pyclaw.Controller()
claw.tfinal = 2.5
claw.solution = pyclaw.Solution(state,domain)
claw.solver = solver
claw.outdir = outdir
claw.num_output_times = 10
return claw
def oscillatory_wind(num_cells, eigen_method, **kargs):
r"""docstring for oscillatory_wind"""
# Construct output and plot directory paths
prefix = 'ml_e%s_n%s' % (eigen_method, num_cells)
name = 'multilayer/oscillatory_wind'
outdir, plotdir, log_path = runclaw.create_output_paths(
name, prefix, **kargs)
# Redirect loggers
# This is not working for all cases, see comments in runclaw.py
for logger_name in [
'pyclaw.io', 'pyclaw.solution', 'plot', 'pyclaw.solver', 'f2py',
'data'
]:
runclaw.replace_stream_handlers(logger_name,
log_path,
log_file_append=False)
# Load in appropriate PyClaw version
if kargs.get('use_petsc', False):
import clawpack.petclaw as pyclaw
else:
import clawpack.pyclaw as pyclaw
# =================
# = Create Solver =
# =================
if kargs.get('solver_type', 'classic') == 'classic':
solver = pyclaw.ClawSolver1D(riemann_solver=layered_shallow_water_1D)
else:
raise NotImplementedError(
'Classic is currently the only supported solver.')
# Solver method parameters
solver.cfl_desired = 0.9
solver.cfl_max = 1.0
solver.max_steps = 5000
solver.fwave = True
solver.kernel_language = 'Fortran'
solver.limiters = 3
solver.source_split = 1
# Boundary conditions
# Here we implement our own wall boundary conditions for the multi-layer
# equations
solver.bc_lower[0] = 0
solver.bc_upper[0] = 0
solver.user_bc_lower = ml.bc.wall_qbc_lower
solver.user_bc_upper = ml.bc.wall_qbc_upper
solver.aux_bc_lower[0] = 1
solver.aux_bc_upper[0] = 1
# Set the before step functioning including the wind forcing
wind_func = lambda state: ml.aux.set_oscillatory_wind(
state, A=5.0, N=2.0, omega=2.0, t_length=10.0)
solver.before_step = lambda solver, solution: ml.step.before_step(
solver, solution, wind_func=wind_func, raise_on_richardson=True)
# Use simple friction source term
solver.step_source = ml.step.friction_source
# ============================
# = Create Initial Condition =
# ============================
num_layers = 2
x = pyclaw.Dimension(0.0, 1.0, num_cells)
domain = pyclaw.Domain([x])
state = pyclaw.State(domain, 2 * num_layers, 3 + num_layers)
state.aux[ml.aux.kappa_index, :] = 0.0
# Set physics data
state.problem_data['g'] = 9.8
state.problem_data['manning'] = 0.0
state.problem_data['rho_air'] = 1.15
state.problem_data['rho'] = [1025.0, 1045.0]
state.problem_data['r'] = \
state.problem_data['rho'][0] / state.problem_data['rho'][1]
state.problem_data['one_minus_r'] = 1.0 - state.problem_data['r']
state.problem_data['num_layers'] = num_layers
# Set method parameters, this ensures it gets to the Fortran routines
state.problem_data['eigen_method'] = eigen_method
state.problem_data['dry_tolerance'] = 1e-3
state.problem_data['inundation_method'] = 2
state.problem_data['entropy_fix'] = False
solution = pyclaw.Solution(state, domain)
solution.t = 0.0
# Set aux arrays including bathymetry, wind field and linearized depths
ml.aux.set_jump_bathymetry(solution.state, 0.5, [-1.0, -1.0])
wind_func(solution.state)
ml.aux.set_h_hat(solution.state, 0.5, [0.0, -0.25], [0.0, -0.25])
# Set sea at rest initial condition
ml.qinit.set_quiescent_init_condition(solution.state)
# ================================
# = Create simulation controller =
# ================================
controller = pyclaw.Controller()
controller.solution = solution
controller.solver = solver
# Output parameters
controller.output_style = 1
controller.tfinal = 10.0
controller.num_output_times = 160
controller.write_aux_init = True
controller.outdir = outdir
controller.keep_copy = True
controller.write_aux_always = True
# ==================
# = Run Simulation =
# ==================
try:
state = controller.run()
except ml.step.RichardsonExceededError as e:
print e
# print "Writing out last solution available to frame %s." % str(len(controller.frames))
# e.solution.write(len(controller.frames),path=controller.outdir,write_aux=True)
# ============
# = Plotting =
# ============
plot_kargs = {
'xlower': solution.state.grid.x.lower,
'xupper': solution.state.grid.x.upper,
'rho': solution.state.problem_data['rho'],
'dry_tolerance': solution.state.problem_data['dry_tolerance']
}
plot(setplot="./setplot_oscillatory.py",
outdir=outdir,
plotdir=plotdir,
htmlplot=kargs.get('htmlplot', False),
iplot=kargs.get('iplot', False),
file_format=controller.output_format,
**plot_kargs)
def setup(use_petsc=False,
kernel_language='Fortran',
solver_type='classic',
outdir='./_output',
ptwise=False,
weno_order=5,
time_integrator='SSP104',
disable_output=False,
output_style=1):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language == 'Fortran':
if ptwise:
riemann_solver = riemann.acoustics_1D_ptwise
else:
riemann_solver = riemann.acoustics_1D
elif kernel_language == 'Python':
riemann_solver = riemann.acoustics_1D_py.acoustics_1D
if solver_type == 'classic':
solver = pyclaw.ClawSolver1D(riemann_solver)
solver.limiters = pyclaw.limiters.tvd.MC
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(riemann_solver)
solver.weno_order = weno_order
solver.time_integrator = time_integrator
if time_integrator == 'SSPLMMk3':
solver.lmm_steps = 4
else:
raise Exception('Unrecognized value of solver_type.')
solver.kernel_language = kernel_language
x = pyclaw.Dimension(0.0, 1.0, 100, name='x')
domain = pyclaw.Domain(x)
num_eqn = 2
state = pyclaw.State(domain, num_eqn)
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
rho = 1.0 # Material density
bulk = 1.0 # Material bulk modulus
state.problem_data['rho'] = rho
state.problem_data['bulk'] = bulk
state.problem_data['zz'] = sqrt(rho * bulk) # Impedance
state.problem_data['cc'] = sqrt(bulk / rho) # Sound speed
xc = domain.grid.x.centers
beta = 100
gamma = 0
x0 = 0.75
state.q[0, :] = exp(-beta * (xc - x0)**2) * cos(gamma * (xc - x0))
state.q[1, :] = 0.0
solver.dt_initial = domain.grid.delta[0] / state.problem_data['cc'] * 0.1
claw = pyclaw.Controller()
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.output_style = output_style
if output_style == 1:
claw.tfinal = 1.0
claw.num_output_times = 10
elif output_style == 3:
claw.nstep = 1
claw.num_output_times = 1
claw.keep_copy = True
if disable_output:
claw.output_format = None
claw.setplot = setplot
return claw
def dry_state(num_cells, eigen_method, entropy_fix, **kargs):
r"""Run and plot a multi-layer dry state problem"""
# Construct output and plot directory paths
name = 'multilayer/dry_state'
prefix = 'ml_e%s_m%s_fix' % (eigen_method, num_cells)
if entropy_fix:
prefix = "".join((prefix, "T"))
else:
prefix = "".join((prefix, "F"))
outdir, plotdir, log_path = runclaw.create_output_paths(
name, prefix, **kargs)
# Redirect loggers
# This is not working for all cases, see comments in runclaw.py
for logger_name in [
'pyclaw.io', 'pyclaw.solution', 'plot', 'pyclaw.solver', 'f2py',
'data'
]:
runclaw.replace_stream_handlers(logger_name,
log_path,
log_file_append=False)
# Load in appropriate PyClaw version
if kargs.get('use_petsc', False):
import clawpack.petclaw as pyclaw
else:
import clawpack.pyclaw as pyclaw
# =================
# = Create Solver =
# =================
if kargs.get('solver_type', 'classic') == 'classic':
solver = pyclaw.ClawSolver1D(riemann_solver=layered_shallow_water_1D)
else:
raise NotImplementedError(
'Classic is currently the only supported solver.')
# Solver method parameters
solver.cfl_desired = 0.9
solver.cfl_max = 1.0
solver.max_steps = 5000
solver.fwave = True
solver.kernel_language = 'Fortran'
solver.limiters = 3
solver.source_split = 1
# Boundary conditions
solver.bc_lower[0] = 1
solver.bc_upper[0] = 1
solver.aux_bc_lower[0] = 1
solver.aux_bc_upper[0] = 1
# Set the before step function
solver.before_step = lambda solver, solution: ml.step.before_step(
solver, solution)
# Use simple friction source term
solver.step_source = ml.step.friction_source
# ============================
# = Create Initial Condition =
# ============================
num_layers = 2
x = pyclaw.Dimension(0.0, 1.0, num_cells)
domain = pyclaw.Domain([x])
state = pyclaw.State(domain, 2 * num_layers, 3 + num_layers)
state.aux[ml.aux.kappa_index, :] = 0.0
# Set physics data
state.problem_data['g'] = 9.8
state.problem_data['manning'] = 0.0
state.problem_data['rho_air'] = 1.15e-3
state.problem_data['rho'] = [0.95, 1.0]
state.problem_data['r'] = \
state.problem_data['rho'][0] / state.problem_data['rho'][1]
state.problem_data['one_minus_r'] = 1.0 - state.problem_data['r']
state.problem_data['num_layers'] = num_layers
# Set method parameters, this ensures it gets to the Fortran routines
state.problem_data['eigen_method'] = eigen_method
state.problem_data['dry_tolerance'] = 1e-3
state.problem_data['inundation_method'] = 2
state.problem_data['entropy_fix'] = entropy_fix
solution = pyclaw.Solution(state, domain)
solution.t = 0.0
# Set aux arrays including bathymetry, wind field and linearized depths
ml.aux.set_jump_bathymetry(solution.state, 0.5, [-1.0, -1.0])
ml.aux.set_no_wind(solution.state)
ml.aux.set_h_hat(solution.state, 0.5, [0.0, -0.5], [0.0, -1.0])
# Set sea at rest initial condition
q_left = [
0.5 * state.problem_data['rho'][0], 0.0,
0.5 * state.problem_data['rho'][1], 0.0
]
q_right = [1.0 * state.problem_data['rho'][0], 0.0, 0.0, 0.0]
ml.qinit.set_riemann_init_condition(solution.state, 0.5, q_left, q_right)
# ================================
# = Create simulation controller =
# ================================
controller = pyclaw.Controller()
controller.solution = solution
controller.solver = solver
# Output parameters
controller.output_style = 3
controller.nstepout = 1
controller.num_output_times = 100
controller.write_aux_init = True
controller.outdir = outdir
controller.write_aux = True
# ==================
# = Run Simulation =
# ==================
state = controller.run()
# ============
# = Plotting =
# ============
plot_kargs = {
'rho': solution.state.problem_data['rho'],
'dry_tolerance': solution.state.problem_data['dry_tolerance']
}
plot.plot(setplot="./setplot_drystate.py",
outdir=outdir,
plotdir=plotdir,
htmlplot=kargs.get('htmlplot', False),
iplot=kargs.get('iplot', False),
file_format=controller.output_format,
**plot_kargs)
def setup(use_petsc=False,
iplot=False,
htmlplot=False,
outdir='./_output',
solver_type='sharpclaw',
kernel_language='Fortran',
use_char_decomp=False,
tfluct_solver=True):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language == 'Python':
rs = riemann.euler_1D_py.euler_roe_1D
elif kernel_language == 'Fortran':
rs = riemann.euler_with_efix_1D
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(rs)
solver.time_integrator = 'RK'
solver.a, solver.b, solver.c = a, b, c
solver.cfl_desired = 0.6
solver.cfl_max = 0.7
if use_char_decomp:
try:
import sharpclaw1 # Import custom Fortran code
solver.fmod = sharpclaw1
solver.tfluct_solver = tfluct_solver # Use total fluctuation solver for efficiency
if solver.tfluct_solver:
try:
import euler_tfluct
solver.tfluct = euler_tfluct
except ImportError:
import logging
logger = logging.getLogger()
logger.error(
'Unable to load tfluct solver, did you run make?')
print 'Unable to load tfluct solver, did you run make?'
raise
except ImportError:
import logging
logger = logging.getLogger()
logger.error(
'Unable to load sharpclaw1 solver, did you run make?')
print 'Unable to load sharpclaw1 solver, did you run make?'
pass
solver.lim_type = 2 # WENO reconstruction
solver.char_decomp = 2 # characteristic-wise reconstruction
else:
solver = pyclaw.ClawSolver1D(rs)
solver.kernel_language = kernel_language
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
mx = 400
x = pyclaw.Dimension(-5.0, 5.0, mx, name='x')
domain = pyclaw.Domain([x])
state = pyclaw.State(domain, num_eqn)
state.problem_data['gamma'] = gamma
if kernel_language == 'Python':
state.problem_data['efix'] = False
xc = state.grid.p_centers[0]
epsilon = 0.2
velocity = (xc < -4.) * 2.629369
pressure = (xc < -4.) * 10.33333 + (xc >= -4.) * 1.
state.q[density, :] = (xc < -4.) * 3.857143 + (xc >= -4.) * (
1 + epsilon * np.sin(5 * xc))
state.q[momentum, :] = velocity * state.q[density, :]
state.q[energy, :] = pressure / (
gamma - 1.) + 0.5 * state.q[density, :] * velocity**2
claw = pyclaw.Controller()
claw.tfinal = 1.8
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.num_output_times = 10
claw.outdir = outdir
claw.setplot = setplot
claw.keep_copy = True
return claw
def em1D(mx=1024,
num_frames=5,
cfl=1.0,
outdir='./_output',
before_step=True,
debug=False,
chi3=0.0,
chi2=0.0,
nl=False,
psi=True,
em=True,
homogeneous=True):
import clawpack.petclaw as pyclaw
import petsc4py.PETSc as MPI
if not homogeneous:
if nl:
material.chi3_e = chi3
material.chi2_e = chi2
if em:
material.chi3_m = chi3
material.chi2_m = chi2
if MPI.COMM_WORLD.rank == 0:
material._outdir = outdir
source._outdir = outdir
material._dump_to_latex()
source._dump_to_latex()
num_eqn = 2
num_waves = 2
num_aux = 4
# grid pre calculations and domain setup
dx, dt, tf = grid_basic(x_lower, x_upper, mx, cfl)
x = pyclaw.Dimension('x', x_lower, x_upper, mx)
domain = pyclaw.Domain([x])
# Solver settings
solver = pyclaw.SharpClawSolver1D()
solver.num_waves = num_waves
solver.num_eqn = num_eqn
solver.weno_order = 5
solver.dt_variable = True
solver.dt_initial = dt / 2.0
solver.dt_max = dt
solver.max_steps = int(2 * tf / dt)
# Set the source
if not psi:
print 'using dq_src'
solver.dq_src = dq_source
# Import Riemann and Tfluct solvers
if homogeneous:
import maxwell_1d_rp
else:
import maxwell_1d_nl_rp as maxwell_1d_rp
solver.tfluct_solver = False
solver.fwave = True
solver.rp = maxwell_1d_rp
if solver.tfluct_solver:
if homogeneous:
import maxwell_1d_tfluct
else:
import maxwell_1d_nl_tfluct as maxwell_1d_tfluct
solver.tfluct = maxwell_1d_tfluct
solver.cfl_max = cfl + 0.05
solver.cfl_desired = cfl
# boundary conditions
solver.bc_lower[0] = pyclaw.BC.wall
solver.bc_upper[0] = pyclaw.BC.wall
solver.aux_bc_lower[0] = pyclaw.BC.wall
solver.aux_bc_upper[0] = pyclaw.BC.wall
solver.reflect_index = [0]
# before step configure
if before_step:
solver.call_before_step_each_stage = True
solver.before_step = material.update_aux
# state setup
state = pyclaw.State(domain, num_eqn, num_aux)
state.problem_data['chi2_e'] = material.chi2_e
state.problem_data['chi3_e'] = material.chi3_e
state.problem_data['chi2_m'] = material.chi2_m
state.problem_data['chi3_m'] = material.chi3_m
state.problem_data['eo'] = material.eo
state.problem_data['mo'] = material.mo
state.problem_data['co'] = material.co
state.problem_data['zo'] = material.zo
state.problem_data['dx'] = state.grid.x.delta
state.problem_data['nl'] = nl
state.problem_data['psi'] = psi
source._dx = state.grid.x.delta
material._dx = state.grid.x.delta
# array initialization
source.init(state)
material.init(state)
state.q = state.q * state.aux[0:2, :]
# controller
claw = pyclaw.Controller()
claw.tfinal = tf
claw.num_output_times = num_frames
claw.solver = solver
claw.solution = pyclaw.Solution(state, domain)
claw.outdir = outdir
claw.write_aux_always = True
return claw
def internal_lapping(num_cells, eigen_method, **kargs):
r"""docstring for oscillatory_wind"""
# Construct output and plot directory paths
prefix = 'ml_e%s_n%s' % (eigen_method, num_cells)
name = 'lapping'
outdir, plotdir, log_path = runclaw.create_output_paths(
name, prefix, **kargs)
# Redirect loggers
# This is not working for all cases, see comments in runclaw.py
for logger_name in ['io', 'solution', 'plot', 'evolve', 'f2py', 'data']:
runclaw.replace_stream_handlers(logger_name,
log_path,
log_file_append=False)
# Load in appropriate PyClaw version
if kargs.get('use_petsc', False):
import clawpack.petclaw as pyclaw
else:
import clawpack.pyclaw as pyclaw
# =================
# = Create Solver =
# =================
if kargs.get('solver_type', 'classic') == 'classic':
solver = pyclaw.ClawSolver1D()
else:
raise NotImplementedError(
'Classic is currently the only supported solver.')
# Solver method parameters
solver.cfl_desired = 0.9
solver.cfl_max = 1.0
solver.max_steps = 5000
solver.fwave = True
solver.kernel_language = 'Fortran'
solver.num_waves = 4
solver.limiters = 3
solver.source_split = 1
# Boundary conditions
solver.bc_lower[0] = 1
solver.bc_upper[0] = 1
solver.aux_bc_lower[0] = 1
solver.aux_bc_upper[0] = 1
# Set the Riemann solver
solver.rp = riemann.rp1_layered_shallow_water
# Set the before step functioning including the wind forcing
solver.before_step = lambda solver, solution: ml.step.before_step(
solver, solution)
# Use simple friction source term
solver.step_source = ml.step.friction_source
# ============================
# = Create Initial Condition =
# ============================
num_layers = 2
x = pyclaw.Dimension('x', 0.0, 1.0, num_cells)
domain = pyclaw.Domain([x])
state = pyclaw.State(domain, 2 * num_layers, 3 + num_layers)
state.aux[ml.aux.kappa_index, :] = 0.0
# Set physics data
state.problem_data['g'] = 9.8
state.problem_data['manning'] = 0.022
state.problem_data['rho_air'] = 1.15e-3
state.problem_data['rho'] = [0.95, 1.0]
state.problem_data[
'r'] = state.problem_data['rho'][0] / state.problem_data['rho'][1]
state.problem_data['one_minus_r'] = 1.0 - state.problem_data['r']
state.problem_data['num_layers'] = num_layers
# Set method parameters, this ensures it gets to the Fortran routines
state.problem_data['eigen_method'] = eigen_method
state.problem_data['dry_tolerance'] = 1e-3
state.problem_data['inundation_method'] = 2
state.problem_data['entropy_fix'] = False
solution = pyclaw.Solution(state, domain)
solution.t = 0.0
# Set aux arrays including bathymetry, wind field and linearized depths
ml.aux.set_sloped_shelf_bathymetry(solution.state, 0.4, 0.6, -1.0, -0.2)
ml.aux.set_no_wind(solution.state)
ml.aux.set_h_hat(solution.state, 0.5, [0.0, -0.6], [0.0, -0.6])
# Set initial condition
ml.qinit.set_gaussian_init_condition(solution.state,
0.2,
0.2,
0.01,
internal_layer=True)
# ================================
# = Create simulation controller =
# ================================
controller = pyclaw.Controller()
controller.solution = solution
controller.solver = solver
# Output parameters
controller.output_style = 1
controller.tfinal = 2.0
controller.num_output_times = 50
controller.write_aux_init = True
controller.outdir = outdir
controller.write_aux = True
# ==================
# = Run Simulation =
# ==================
state = controller.run()
# ============
# = Plotting =
# ============
plot_kargs = {
'rho': solution.state.problem_data['rho'],
'dry_tolerance': solution.state.problem_data['dry_tolerance']
}
plot(setplot_path="./setplot_lapping.py",
outdir=outdir,
plotdir=plotdir,
htmlplot=kargs.get('htmlplot', False),
iplot=kargs.get('iplot', False),
file_format=controller.output_format,
**plot_kargs)
def setup(use_petsc=0,kernel_language='Fortran',solver_type='classic',outdir='./_output'):
"""
Stegoton problem.
Nonlinear elasticity in periodic medium.
See LeVeque & Yong (2003).
$$\\epsilon_t - u_x = 0$$
$$\\rho(x) u_t - \\sigma(\\epsilon,x)_x = 0$$
"""
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language=='Python':
rs = riemann.nonlinear_elasticity_1D_py.nonlinear_elasticity_1D
elif kernel_language=='Fortran':
rs = riemann.nonlinear_elasticity_fwave_1D
if solver_type=='sharpclaw':
solver = pyclaw.SharpClawSolver1D(rs)
solver.char_decomp=0
else:
solver = pyclaw.ClawSolver1D(rs)
solver.kernel_language = kernel_language
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
#Use the same BCs for the aux array
solver.aux_bc_lower = solver.bc_lower
solver.aux_bc_upper = solver.bc_upper
xlower=0.0; xupper=600.0
cellsperlayer=6; mx=int(round(xupper-xlower))*cellsperlayer
x = pyclaw.Dimension('x',xlower,xupper,mx)
domain = pyclaw.Domain(x)
state = pyclaw.State(domain,solver.num_eqn)
#Set global parameters
alpha = 0.5
KA = 1.0
KB = 4.0
rhoA = 1.0
rhoB = 4.0
state.problem_data = {}
state.problem_data['t1'] = 10.0
state.problem_data['tw1'] = 10.0
state.problem_data['a1'] = 0.0
state.problem_data['alpha'] = alpha
state.problem_data['KA'] = KA
state.problem_data['KB'] = KB
state.problem_data['rhoA'] = rhoA
state.problem_data['rhoB'] = rhoB
state.problem_data['trtime'] = 250.0
state.problem_data['trdone'] = False
#Initialize q and aux
xc=state.grid.x.centers
state.aux=setaux(xc,rhoB,KB,rhoA,KA,alpha,xlower=xlower,xupper=xupper)
qinit(state,ic=2,a2=1.0,xupper=xupper)
tfinal=500.; num_output_times = 10;
solver.max_steps = 5000000
solver.fwave = True
solver.before_step = b4step
solver.user_bc_lower=moving_wall_bc
solver.user_bc_upper=zero_bc
claw = pyclaw.Controller()
claw.keep_copy = False
claw.output_style = 1
claw.num_output_times = num_output_times
claw.tfinal = tfinal
claw.solution = pyclaw.Solution(state,domain)
claw.solver = solver
return claw
def setup(use_petsc=False,
outdir='./_output',
solver_type='classic',
mx=30,
my=30,
mz=30,
disable_output=False,
problem='heterogeneous',
**kwargs):
"""
Example python script for solving the 3d acoustics equations.
"""
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'classic':
solver = pyclaw.ClawSolver3D(riemann.vc_acoustics_3D)
solver.limiters = pyclaw.limiters.tvd.MC
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver3D(riemann.vc_acoustics_3D)
else:
raise Exception('Unrecognized solver_type.')
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
solver.bc_lower[1] = pyclaw.BC.periodic
solver.bc_upper[1] = pyclaw.BC.periodic
solver.bc_lower[2] = pyclaw.BC.periodic
solver.bc_upper[2] = pyclaw.BC.periodic
solver.aux_bc_lower[0] = pyclaw.BC.periodic
solver.aux_bc_upper[0] = pyclaw.BC.periodic
solver.aux_bc_lower[1] = pyclaw.BC.periodic
solver.aux_bc_upper[1] = pyclaw.BC.periodic
solver.aux_bc_lower[2] = pyclaw.BC.periodic
solver.aux_bc_upper[2] = pyclaw.BC.periodic
zl = 1.0 # Impedance in left half
cl = 1.0 # Sound speed in left half
if problem == 'homogeneous':
if solver_type == 'classic':
solver.dimensional_split = True
else:
solver.lim_type = 1
solver.limiters = [4]
mx = mx
my = my
mz = mz # Grid resolution
zr = 1.0 # Impedance in right half
cr = 1.0 # Sound speed in right half
if problem == 'heterogeneous':
if solver_type == 'classic':
solver.dimensional_split = False
solver.bc_lower[0] = pyclaw.BC.wall
solver.bc_lower[1] = pyclaw.BC.wall
solver.bc_lower[2] = pyclaw.BC.wall
solver.aux_bc_lower[0] = pyclaw.BC.wall
solver.aux_bc_lower[1] = pyclaw.BC.wall
solver.aux_bc_lower[2] = pyclaw.BC.wall
mx = mx
my = my
mz = mz # Grid resolution
zr = 2.0 # Impedance in right half
cr = 2.0 # Sound speed in right half
solver.limiters = pyclaw.limiters.tvd.MC
# Initialize domain
x = pyclaw.Dimension('x', -1.0, 1.0, mx)
y = pyclaw.Dimension('y', -1.0, 1.0, my)
z = pyclaw.Dimension('z', -1.0, 1.0, mz)
domain = pyclaw.Domain([x, y, z])
num_eqn = 4
num_aux = 2 # density, sound speed
state = pyclaw.State(domain, num_eqn, num_aux)
X, Y, Z = state.grid.p_centers
state.aux[0, :, :, :] = zl * (X < 0.) + zr * (X >= 0.) # Impedance
state.aux[1, :, :, :] = cl * (X < 0.) + cr * (X >= 0.) # Sound speed
# Set initial density
x0 = -0.5
y0 = 0.
z0 = 0.
if problem == 'homogeneous':
r = np.sqrt((X - x0)**2)
width = 0.2
state.q[0, :, :, :] = (np.abs(r) <= width) * (1. + np.cos(np.pi *
(r) / width))
elif problem == 'heterogeneous':
r = np.sqrt((X - x0)**2 + (Y - y0)**2 + (Z - z0)**2)
width = 0.1
state.q[0, :, :, :] = (np.abs(r - 0.3) <= width) * (
1. + np.cos(np.pi * (r - 0.3) / width))
else:
raise Exception('Unrecognized problem name')
# Set initial velocities to zero
state.q[1, :, :, :] = 0.
state.q[2, :, :, :] = 0.
state.q[3, :, :, :] = 0.
claw = pyclaw.Controller()
claw.keep_copy = True
if disable_output:
claw.output_format = None
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.tfinal = 2.0
return claw
def euler3d(kernel_language='Fortran',solver_type='classic',\
use_petsc=False,outdir='./_output',\
output_format='hdf5',file_prefix='equil',disable_output=False,\
mx=mxyz[0],my=mxyz[1],mz=mxyz[2],\
tfinal=64.0,num_output_times=1):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'classic':
solver = pyclaw.ClawSolver3D()
solver.dimensional_split = True
solver.limiters = pyclaw.limiters.tvd.minmod
solver.num_ghost = 2
solver.order = 2
solver.fwave = True
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver3D()
else:
raise Exception('Unrecognized solver_type.')
import logging
solver.logger.setLevel(logging.DEBUG)
import euler_3d_gmap
solver.rp = euler_3d_gmap
solver.num_eqn = 5
solver.num_waves = 3
solver.cfl_max = 0.6
solver.cfl_desired = 0.5
solver.dt_initial = 1.e-0
solver.max_steps = 10000
# Initialize Domain
x = pyclaw.Dimension(0.0, 1.0, mx, name='x')
y = pyclaw.Dimension(0.0, 1.0, my, name='y')
z = pyclaw.Dimension(0.0, 1.0, mz, name='z')
domain = pyclaw.Domain([x, y, z])
num_aux = 15
state = pyclaw.State(domain, solver.num_eqn, num_aux)
state.problem_data['gamma'] = gamma
state.problem_data['g_r'] = gR
state.problem_data['gravity'] = gravityTerm
state.problem_data['gravityflux'] = gravityEflux
# Grids
mbc = solver.num_ghost
grid = state.grid
# Computational Grid Sizes
dxc = domain.grid.delta[0]
dyc = domain.grid.delta[1]
dzc = domain.grid.delta[2]
pmx, pmy, pmz = grid.num_cells[0], grid.num_cells[1], grid.num_cells[2]
# Computational Grid Centers and Edges
centers = grid.c_centers # centers (Comp.)
centersBC = grid.c_centers_with_ghost(mbc) # centers w Ghost (Comp.)
edgesBC = grid.c_edges_with_ghost(mbc) # edges w Ghost (Comp.)
# Grid Centers Without Boundary Cells (1D Slice) - Comp. and Phys.
xcc = grid.x.centers # x centers (Comp.)
ycc = grid.y.centers # y centers (Comp.)
zcc = grid.z.centers # z centers (Comp.)
xcp, ycp, zcp = mg.mapc2pwrapper(xcc, ycc, zcc, pmz, xyzMin, xyzMax,
mapType)
# Grid Centers Without Boundary Cells (3D Arrays)
Xcc, Ycc, Zcc = centers[0][:][:][:], centers[1][:][:][:], centers[
2][:][:][:]
Xcp, Ycp, Zcp = mg.mapc2pwrapper(Xcc, Ycc, Zcc, pmz, xyzMin, xyzMax,
mapType)
Xcp = np.reshape(Xcp, [pmx, pmy, pmz], order='F') # x centers (Phys.)
Ycp = np.reshape(Ycp, [pmx, pmy, pmz], order='F') # y centers (Phys.)
Zcp = np.reshape(Zcp, [pmx, pmy, pmz], order='F') # z centers (Phys.)
# Grid Edges With Boundary Cells (1D Slice along z)- Comp. and Phys.
xecZ = edgesBC[0][0][0][:] # x edges along z (Comp.)
yecZ = edgesBC[1][0][0][:] # y edges along z (Comp.)
zecZ = edgesBC[2][0][0][:] # z edges along z (Comp.)
xepZ, yepZ, zepZ = mg.mapc2pwrapper(xecZ, yecZ, zecZ, pmz, xyzMin, xyzMax,
mapType)
# Grid Centers With Boundary Cells (1D Slice along z) - Comp. and Phys.
global zcpZ
xccZ = centersBC[0][0][0][:] # x centers along z (Comp.)
yccZ = centersBC[1][0][0][:] # y centers along z (Comp.)
zccZ = centersBC[2][0][0][:] # z centers along z (Comp.)
xcpZ, ycpZ, zcpZ = mg.mapc2pwrapper(xccZ, yccZ, zccZ, pmz, xyzMin, xyzMax,
mapType)
if np.sqrt(xepZ[0]**2 + yepZ[0]**2 + zepZ[0]**2) <= 0:
print "WARNING: z may go below Earth's surface", " zepZ: ", zepZ[0:10]
# Create vectors for 1D pressure and density column with boundary cells
mz0 = pmz + 2 * mbc
global p0, rho0, Mavg
p0 = np.zeros([mz0], dtype='float', order='F')
rho0 = np.zeros([mz0], dtype='float', order='F')
Mavg = np.zeros([mz0], dtype='float', order='F')
# Set the equilibrium pressure such that dp/dz = -rho*gR
p0, rho0, Mavg = setEquilibriumAtmosphere(p0, rho0, Mavg)
# Modify the equilibrium such that dp/dz = -rho*gR is held numerically
p0 = modifyEquilibriumAtmosphere(zepZ, p0, rho0)
# Set the auxiliary variables
xlower, ylower, zlower = edgesBC[0][0][0][0], edgesBC[1][0][0][0], edgesBC[
2][0][0][0]
dxc, dyc, dzc = domain.grid.delta[0], domain.grid.delta[
1], domain.grid.delta[2]
global auxtmp
auxtmp = np.zeros([num_aux, pmx + 2 * mbc, pmy + 2 * mbc, pmz + 2 * mbc],
dtype='float',
order='F')
auxtmp = mg.setauxiliaryvariables(num_aux, mbc, pmx, pmy, pmz, xlower,
ylower, zlower, dxc, dyc, dzc, xyzMin,
xyzMax, mapType)
state.aux[:, :, :, :] = auxtmp[:, mbc:-mbc, mbc:-mbc, mbc:-mbc]
# Set Index for Capcaity Function in state.aux (Python 0-based)
state.index_capa = 12
# Set the state variables (Initial Conditions)
# Initialize p,T,velSqrd
p = np.zeros([pmx, pmy, pmz], dtype='float', order='F')
T = np.zeros([pmx, pmy, pmz], dtype='float', order='F')
velSqrd = np.zeros([pmx, pmy, pmz], dtype='float', order='F')
# Density
for i in range(pmx):
for j in range(pmy):
# NEEDS TO BE FIXED WHEN MPI SLICES NORMAL TO Z
state.q[0, i, j, :] = rho0[mbc:pmz + mbc]
# Momentum
state.q[1, :, :, :] = 0. # x-momentum (rho*u)
state.q[2, :, :, :] = 0. # y-momentum (rho*v)
state.q[3, :, :, :] = 0. # z-momentum (rho*w)
# Velocity Squared (u**2+v**2+w**2)
velSqrd[:, :, :] = (state.q[1, :, :, :]**2 + state.q[2, :, :, :]**2 +
state.q[3, :, :, :]**2) / state.q[0, :, :, :]**2
# Energy
for i in range(pmx):
for j in range(pmy):
# NEEDS TO BE FIXED WHEN MPI SLICES NORMAL TO Z
p[i, j, :] = p0[mbc:pmz + mbc]
state.q[4, :, :, :] = p / gamma1 + 0.5 * state.q[
0, :, :, :] * velSqrd + state.q[0, :, :, :] * (
gR) * Zcp[:, :, :] * gFlux
# Add Temperature Perturbation
T = p / state.q[0, :, :, :]
L = np.sqrt((Xcp - xSphere)**2 + (Ycp - ySphere)**2 + (Zcp - zSphere)**2)
for i in range(pmx):
for j in range(pmy):
for k in range(pmz):
if L[i, j, k] <= rSphere:
mu = Mavg[k + mbc] / nAvogadro
T[i, j, k] += TSphere * (kBoltzmann /
mu) * (1.0 - L[i, j, k] / rSphere)
p[i, j, k] = T[i, j, k] * state.q[0, i, j, k]
state.q[4, :, :, :] = p / gamma1 + 0.5 * state.q[
0, :, :, :] * velSqrd + state.q[0, :, :, :] * (
gR) * Zcp[:, :, :] * gFlux # energy (e)
# Setup Boundary Conditions
# X - Boundary Conditions
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
# Y - Boundary Conditions
solver.bc_lower[1] = pyclaw.BC.extrap
solver.bc_upper[1] = pyclaw.BC.extrap
# Z - Boundary Conditions
solver.bc_lower[2] = pyclaw.BC.custom
solver.bc_upper[2] = pyclaw.BC.custom
solver.user_bc_lower = customBCLowerZ
solver.user_bc_upper = customBCUpperZ
# Aux - Boundary Conditions
solver.aux_bc_lower[0] = pyclaw.BC.extrap
solver.aux_bc_upper[0] = pyclaw.BC.extrap
solver.aux_bc_lower[1] = pyclaw.BC.extrap
solver.aux_bc_upper[1] = pyclaw.BC.extrap
solver.aux_bc_lower[2] = pyclaw.BC.custom
solver.aux_bc_upper[2] = pyclaw.BC.custom
solver.user_aux_bc_lower = customAuxBCLowerZ
solver.user_aux_bc_upper = customAuxBCUpperZ
# Solver Parameters
claw = pyclaw.Controller()
claw.verbosity = 4
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.output_format = output_format
claw.output_file_prefix = file_prefix
claw.keep_copy = False
if disable_output:
claw.output_format = None
claw.tfinal = tfinal
claw.num_output_times = num_output_times
claw.outdir = outdir
#state.mp = 1
#claw.compute_p = outputDensity
return claw
def setup(use_petsc=False,
kernel_language='Fortran',
outdir='./_output',
solver_type='classic'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language == 'Python':
rs = riemann.shallow_1D_py.shallow_1D
elif kernel_language == 'Fortran':
rs = riemann.shallow_roe_with_efix_1D
if solver_type == 'classic':
solver = pyclaw.ClawSolver1D(rs)
solver.limiters = pyclaw.limiters.tvd.vanleer
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(rs)
solver.kernel_language = kernel_language
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
xlower = -5.0
xupper = 5.0
mx = 500
x = pyclaw.Dimension(xlower, xupper, mx, name='x')
domain = pyclaw.Domain(x)
state = pyclaw.State(domain, num_eqn)
# Gravitational constant
state.problem_data['grav'] = 1.0
xc = state.grid.x.centers
IC = 'dam-break'
x0 = 0.
if IC == 'dam-break':
hl = 3.
ul = 0.
hr = 1.
ur = 0.
state.q[depth, :] = hl * (xc <= x0) + hr * (xc > x0)
state.q[momentum, :] = hl * ul * (xc <= x0) + hr * ur * (xc > x0)
elif IC == '2-shock':
hl = 1.
ul = 1.
hr = 1.
ur = -1.
state.q[depth, :] = hl * (xc <= x0) + hr * (xc > x0)
state.q[momentum, :] = hl * ul * (xc <= x0) + hr * ur * (xc > x0)
elif IC == 'perturbation':
eps = 0.1
state.q[depth, :] = 1.0 + eps * np.exp(-(xc - x0)**2 / 0.5)
state.q[momentum, :] = 0.
claw = pyclaw.Controller()
claw.keep_copy = True
claw.tfinal = 2.0
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.setplot = setplot
return claw
def setup(kernel_language='Fortran',
use_petsc=False,
outdir='./_output',
solver_type='classic',
disable_output=False,
cells_per_layer=30,
tfinal=18.):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
# material parameters
KA = 1.
rhoA = 1.
KB = 4.
rhoB = 4.
stress_rel = 2
# Domain
x_lower = 0.25
x_upper = 20.25
y_lower = 0.25
y_upper = 20.25
# cells per layer
mx = int((x_upper - x_lower) * cells_per_layer)
my = int((y_upper - y_lower) * cells_per_layer)
# Initial condition parameters
initial_amplitude = 10.
x0 = 0.25 # Center of initial perturbation
y0 = 0.25 # Center of initial perturbation
varx = 0.5
vary = 0.5 # Width of initial perturbation
num_output_times = 10
if solver_type == 'classic':
solver = pyclaw.ClawSolver2D(riemann.psystem_2D)
solver.dimensional_split = False
solver.cfl_max = 0.9
solver.cfl_desired = 0.8
solver.limiters = pyclaw.limiters.tvd.superbee
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver2D(riemann.psystem_2D)
if kernel_language != 'Fortran':
raise Exception('Unrecognized value of kernel_language for 2D psystem')
# Boundary conditions
solver.bc_lower[0] = pyclaw.BC.wall
solver.bc_upper[0] = pyclaw.BC.extrap
solver.bc_lower[1] = pyclaw.BC.wall
solver.bc_upper[1] = pyclaw.BC.extrap
solver.aux_bc_lower[0] = pyclaw.BC.wall
solver.aux_bc_upper[0] = pyclaw.BC.extrap
solver.aux_bc_lower[1] = pyclaw.BC.wall
solver.aux_bc_upper[1] = pyclaw.BC.extrap
solver.fwave = True
solver.before_step = b4step
#controller
claw = pyclaw.Controller()
claw.tfinal = tfinal
claw.solver = solver
claw.outdir = outdir
# restart options
restart_from_frame = None
if restart_from_frame is None:
x = pyclaw.Dimension(x_lower, x_upper, mx, name='x')
y = pyclaw.Dimension(y_lower, y_upper, my, name='y')
domain = pyclaw.Domain([x, y])
num_eqn = 3
num_aux = 4
state = pyclaw.State(domain, num_eqn, num_aux)
state.mF = 1
state.mp = 1
grid = state.grid
state.aux = setaux(grid.x.centers, grid.y.centers, KA, KB, rhoA, rhoB,
stress_rel)
#Initial condition
qinit(state, initial_amplitude, x0, y0, varx, vary)
claw.solution = pyclaw.Solution(state, domain)
claw.num_output_times = num_output_times
else:
claw.solution = pyclaw.Solution(restart_from_frame,
format='petsc',
read_aux=False)
claw.solution.state.mp = 1
grid = claw.solution.domain.grid
claw.solution.state.aux = setaux(grid.x.centers, grid.y.centers)
claw.num_output_times = num_output_times - restart_from_frame
claw.start_frame = restart_from_frame
#claw.p_function = p_function
if disable_output:
claw.output_format = None
claw.compute_F = total_energy
claw.compute_p = compute_stress
claw.write_aux_init = False
grid.add_gauges([[0.25, 0.25], [17.85, 1.25], [3.25, 18.75],
[11.75, 11.75]])
solver.compute_gauge_values = gauge_stress
state.keep_gauges = True
claw.setplot = setplot
claw.keep_copy = True
return claw
def setup(use_petsc=False,
kernel_language='Fortran',
outdir='./_output',
solver_type='sharpclaw',
riemann_solver='roe',
disable_output=False):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language == 'Python':
if riemann_solver.lower() == 'roe':
raise Exception('Python Roe solver not implemented.')
elif riemann_solver.lower() == 'hlle':
rs = riemann.shallow_1D_py.shallow_hll_1D
elif kernel_language == 'Fortran':
if riemann_solver.lower() == 'roe':
rs = riemann.shallow_roe_with_efix_1D
elif riemann_solver.lower() == 'hlle':
rs = riemann.shallow_hlle_1D
if solver_type == 'classic':
solver = pyclaw.ClawSolver1D(rs)
# solver.limiters = pyclaw.limiters.tvd.vanleer
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(rs)
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'sharpclaw':
solver.dq_src = dq_swe
# solver.dq_src = fortran_src_wrapper # use fortran subroutine
# solver.call_before_step_each_stage = False # default is False
solver.weno_order = 5
solver.lim_type = 2 # weno resonstruction
solver.cfl_max = 0.21
solver.cfl_desired = 0.20
else:
# solver = pyclaw.ClawSolver2D(riemann.euler_5wave_2D)
solver.step_source = step_swe
solver.source_split = 1 # Godunov splitting
# solver.limiters = [11, 11] # 11 for A-R limiter
solver.limiters = [4, 4] # 4 for MC limiter
solver.cfl_max = 0.36
solver.cfl_desired = 0.35
# to remove maximum time step restriction using a sufficiently large number
solver.max_steps = 1000000000
solver.kernel_language = kernel_language
solver.user_bc_lower = incoming_sin
solver.bc_lower[0] = pyclaw.BC.custom
solver.bc_upper[0] = pyclaw.BC.extrap
solver.before_step = b4step
x = pyclaw.Dimension(xlower, xupper, mx, name='x')
domain = pyclaw.Domain(x)
# num_aux = 1
state = pyclaw.State(domain, num_eqn)
# Auxiliary array
solver.aux_bc_lower[0] = pyclaw.BC.periodic
solver.aux_bc_upper[0] = pyclaw.BC.periodic
# Gravitational constant
state.problem_data['grav'] = 9.81
state.problem_data['dry_tolerance'] = 1e-5
state.problem_data['sea_level'] = 0.0
# xc = state.grid.x.centers
# I.C.: normal flow
state.q[depth, :] = normal_depth
state.q[momentum, :] = normal_velocity * normal_depth
# X = state.grid.x.centers
# state.p_centers does not work, dont know why
# state.aux[0,:] = channel_slope*(1.0 + dist_amp * np.sin(2.0 * np.pi * X/wave_length))
# state.aux[0,:] = bathymetry(X)
claw = pyclaw.Controller()
claw.keep_copy = True
if disable_output:
claw.output_format = None
claw.output_style = 1
claw.tfinal = sim_time
claw.num_output_times = int(
sim_time / output_interval) # conversion between two output styles
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.setplot = setplot
return claw
def shockbubble(use_petsc=False, outdir='./_output', solver_type='classic'):
"""
Solve the Euler equations of compressible fluid dynamics.
This example involves a bubble of dense gas that is impacted by a shock.
"""
from clawpack import riemann
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver2D(riemann.euler_5wave_2D)
solver.dq_src = dq_Euler_radial
solver.weno_order = 5
solver.lim_type = 2
else:
solver = pyclaw.ClawSolver2D(riemann.euler_5wave_2D)
solver.dimensional_split = 0
solver.transverse_waves = 2
solver.limiters = [4, 4, 4, 4, 2]
solver.step_source = step_Euler_radial
solver.bc_lower[0] = pyclaw.BC.custom
solver.bc_upper[0] = pyclaw.BC.extrap
solver.bc_lower[1] = pyclaw.BC.wall
solver.bc_upper[1] = pyclaw.BC.extrap
#Aux variable in ghost cells doesn't matter
solver.aux_bc_lower[0] = pyclaw.BC.extrap
solver.aux_bc_upper[0] = pyclaw.BC.extrap
solver.aux_bc_lower[1] = pyclaw.BC.extrap
solver.aux_bc_upper[1] = pyclaw.BC.extrap
# Initialize domain
mx = 160
my = 40
x = pyclaw.Dimension('x', 0.0, 2.0, mx)
y = pyclaw.Dimension('y', 0.0, 0.5, my)
domain = pyclaw.Domain([x, y])
num_eqn = 5
num_aux = 1
state = pyclaw.State(domain, num_eqn, num_aux)
state.problem_data['gamma'] = gamma
state.problem_data['gamma1'] = gamma1
qinit(state)
auxinit(state)
solver.user_bc_lower = shockbc
claw = pyclaw.Controller()
claw.tfinal = 0.75
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.num_output_times = 10
claw.outdir = outdir
return claw
