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.vc_advection_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.vc_advection_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] = pyclaw.BC.custom
solver.user_bc_lower = custom_bc
solver.bc_upper[0] = pyclaw.BC.custom
solver.user_bc_upper = custom_bc
solver.aux_bc_lower[0] = 2
solver.aux_bc_upper[0] = 2
xlower = -100.0
xupper = 100.0
mx = steps
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 = 10.0
claw.setplot = setplot
claw.keep_copy = True
# print claw.solution._get_solution_attribute
return claw
def setup(nx=100,
kernel_language='Python',
use_petsc=False,
solver_type='classic',
weno_order=5,
outdir='./_output'):
import numpy as np
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_1D)
elif kernel_language == 'Python':
solver = pyclaw.ClawSolver1D(riemann.advection_1D_py.advection_1D)
elif solver_type == 'sharpclaw':
if kernel_language == 'Fortran':
solver = pyclaw.SharpClawSolver1D(riemann.advection_1D)
elif kernel_language == 'Python':
solver = pyclaw.SharpClawSolver1D(
riemann.advection_1D_py.advection_1D)
solver.weno_order = weno_order
else:
raise Exception('Unrecognized value of solver_type.')
solver.kernel_language = kernel_language
solver.bc_lower[0] = 2
solver.bc_upper[0] = 2
x = pyclaw.Dimension('x', 0.0, 1.0, nx)
domain = pyclaw.Domain(x)
num_eqn = 1
state = pyclaw.State(domain, num_eqn)
state.problem_data['u'] = 1.
grid = state.grid
xc = 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
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(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 wcblast(use_petsc=False,
iplot=False,
htmlplot=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.
"""
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.rp = riemann.rp1_euler_with_efix
solver.num_waves = 3
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
# Solve
status = claw.run()
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
return claw.solution.q
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.vc_advection_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.vc_advection_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('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
return claw
def setup(use_petsc=False,
outdir='./_output',
solver_type='classic',
kernel_language='Python',
disable_output=False):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if kernel_language == 'Python':
rs = riemann.euler_1D_py.euler_hllc_1D
elif kernel_language == 'Fortran':
rs = riemann.euler_hlle_1D
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D(rs)
elif solver_type == 'classic':
solver = pyclaw.ClawSolver1D(rs)
solver.kernel_language = kernel_language
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
mx = 800
x = pyclaw.Dimension(-1.0, 1.0, mx, name='x')
domain = pyclaw.Domain([x])
state = pyclaw.State(domain, num_eqn)
state.problem_data['gamma'] = gamma
state.problem_data['gamma1'] = gamma - 1.
x = state.grid.x.centers
rho_l = 1.
rho_r = 1. / 8
p_l = 1.
p_r = 0.1
state.q[density, :] = (x < 0.) * rho_l + (x >= 0.) * rho_r
state.q[momentum, :] = 0.
velocity = state.q[momentum, :] / state.q[density, :]
pressure = (x < 0.) * p_l + (x >= 0.) * p_r
state.q[energy, :] = pressure / (
gamma - 1.) + 0.5 * state.q[density, :] * velocity**2
claw = pyclaw.Controller()
claw.tfinal = 0.4
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.num_output_times = 10
claw.outdir = outdir
claw.setplot = setplot
claw.keep_copy = True
if disable_output:
claw.output_format = None
return claw
def advection(kernel_language='Python',iplot=False,htmlplot=False,
use_petsc=False,solver_type='classic', weno_order=5,
outdir='./_output'):
"""
Example python script for solving the 1d advection equation.
"""
import numpy as np
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
if solver_type=='sharpclaw':
solver = pyclaw.SharpClawSolver1D()
solver.weno_order=weno_order
else:
solver = pyclaw.ClawSolver1D()
solver.kernel_language = kernel_language
from clawpack.riemann import rp_advection
solver.num_waves = rp_advection.num_waves
if solver.kernel_language=='Python':
solver.rp = rp_advection.rp_advection_1d
else:
from clawpack import riemann
solver.rp = riemann.rp1_advection
solver.bc_lower[0] = 2
solver.bc_upper[0] = 2
x = pyclaw.Dimension('x',0.0,1.0,100)
domain = pyclaw.Domain(x)
num_eqn = 1
state = pyclaw.State(domain,num_eqn)
state.problem_data['u']=1.
grid = state.grid
xc=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
status = claw.run()
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
return claw
def setup(kernel_language='Python',
use_petsc=False,
outdir='./_output',
solver_type='classic'):
if use_petsc:
import clawpack.petclaw as pyclaw
else:
from clawpack import pyclaw
solver = pyclaw.ClawSolver1D(riemann.shallow_1D_py.shallow_fwave_1d)
solver.limiters = pyclaw.limiters.tvd.vanleer
solver.kernel_language = "Python"
solver.fwave = True
solver.num_waves = 2
solver.num_eqn = 2
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.step_source = stepSource
# solver.dt = 0.00001
x_star = numpy.sqrt(80.0 / 1e-2) - 1.2
xlower = -x_star
xupper = x_star
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['sea_level'] = 0.0
xc = state.grid.x.centers
# state.aux[0, :] = 0.8 * numpy.exp(-xc**2 / 0.2**2) - 1.0
state.aux[0, :] = 1.e-2 * (xc**2) - 80
ze = -((xc)**2) / 10
state.q[0, :] = numpy.where(
ze > -10., 40.e0 * numpy.exp(ze) - state.aux[0, :],
numpy.where(state.aux[0, :] <= 0, -state.aux[0, :], 0.))
state.q[1, :] = 0.0
claw = pyclaw.Controller()
claw.keep_copy = True
claw.tfinal = 8.0
claw.output_style = 1
claw.num_output_times = 25
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(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('x', 0.0, 1.0, nx)
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=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=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=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,
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 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 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 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 smooth_test(eigen_method, dry=False, **kargs):
r"""Smooth well-balanced test"""
# Construct output and plot directory paths
prefix = 'ml_e%s_d%s' % (eigen_method,dry)
name = 'multilayer/well_balancing_smooth'
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
# Use wall boundary condition at beach
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, 10.0, 200)
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'] = [0.98,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_gaussian_bathymetry(solution.state, 10.0, 5, numpy.sqrt(5 / 2),
5.0)
ml.aux.set_no_wind(solution.state)
if dry:
ml.aux.set_h_hat(solution.state, 0.5, [0.0, -6.0], [0.0, -6.0])
else:
ml.aux.set_h_hat(solution.state, 0.5, [0.0, -4.0], [0.0, -4.0])
# Set perturbation to sea at rest
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 = 1
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="./setplot_well_balanced.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 setup(use_petsc=False,
kernel_language='Fortran',
solver_type='classic',
outdir='./_output',
weno_order=5,
disable_output=False):
"""
This example solves the 1-dimensional acoustics equations in a homogeneous
medium.
"""
from numpy import sqrt, exp, cos
from clawpack import riemann
#=================================================================
# Import the appropriate classes, depending on the options passed
#=================================================================
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.acoustics_1D)
elif kernel_language == 'Python':
solver = pyclaw.ClawSolver1D(riemann.acoustics_1D_py.acoustics_1D)
elif solver_type == 'sharpclaw':
if kernel_language == 'Fortran':
solver = pyclaw.SharpClawSolver1D(riemann.acoustics_1D)
elif kernel_language == 'Python':
solver = pyclaw.SharpClawSolver1D(
riemann.acoustics_1D_py.acoustics_1D)
solver.weno_order = weno_order
else:
raise Exception('Unrecognized value of solver_type.')
#========================================================================
# Instantiate the solver and define the system of equations to be solved
#========================================================================
solver.kernel_language = kernel_language
solver.limiters = pyclaw.limiters.tvd.MC
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
#========================================================================
# Instantiate the domain and set the boundary conditions
#========================================================================
x = pyclaw.Dimension('x', 0.0, 1.0, 100)
domain = pyclaw.Domain(x)
num_eqn = 2
state = pyclaw.State(domain, num_eqn)
#========================================================================
# Set problem-specific variables
#========================================================================
rho = 1.0
bulk = 1.0
state.problem_data['rho'] = rho
state.problem_data['bulk'] = bulk
state.problem_data['zz'] = sqrt(rho * bulk)
state.problem_data['cc'] = sqrt(bulk / rho)
#========================================================================
# Set the initial condition
#========================================================================
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.
solver.dt_initial = domain.grid.delta[0] / state.problem_data['cc'] * 0.1
#========================================================================
# Set up the controller object
#========================================================================
claw = pyclaw.Controller()
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.keep_copy = True
claw.num_output_times = 5
if disable_output:
claw.output_format = None
claw.tfinal = 1.0
return claw
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 setup(use_petsc=False,
outdir='./_output',
solver_type='sharpclaw',
kernel_language='Fortran'):
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 = 'SSP33'
solver.cfl_max = 0.65
solver.cfl_desired = 0.6
try:
import sharpclaw1
solver.fmod = sharpclaw1
solver.tfluct_solver = True
solver.lim_type = 1 # TVD reconstruction
solver.char_decomp = 2 # characteristic-wise reconstructiong
except ImportError:
pass
elif solver_type == 'classic':
solver = pyclaw.ClawSolver1D(rs)
solver.limiters = 4
solver.kernel_language = kernel_language
solver.bc_lower[0] = pyclaw.BC.wall
solver.bc_upper[0] = pyclaw.BC.wall
mx = 800
x = pyclaw.Dimension('x', 0.0, 1.0, mx)
domain = pyclaw.Domain([x])
state = pyclaw.State(domain, solver.num_eqn)
state.problem_data['gamma'] = gamma
state.problem_data['gamma1'] = gamma1
if kernel_language == 'Python':
state.problem_data['efix'] = False
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
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='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=0,
kernel_language='Fortran',
solver_type='classic',
outdir='./_output'):
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.custom
solver.bc_upper[0] = pyclaw.BC.extrap
#Use the same BCs for the aux array
solver.aux_bc_lower[0] = pyclaw.BC.extrap
solver.aux_bc_upper[0] = pyclaw.BC.extrap
xlower = 0.0
xupper = 300.0
cells_per_layer = 12
mx = int(round(xupper - xlower)) * cells_per_layer
x = pyclaw.Dimension(xlower, xupper, mx, name='x')
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.1
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'] = 999999999.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=1, a2=1.0, xupper=xupper)
tfinal = 500.
num_output_times = 20
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.output_style = 1
claw.num_output_times = num_output_times
claw.tfinal = tfinal
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.setplot = setplot
claw.keep_copy = True
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(use_petsc=False,
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':
rs = riemann.advection_nonlinear_1D_py.advection_nonlinear_1D
elif kernel_language == 'Fortran':
print('No fortran solver available for advection_nonlinear_1D')
pass
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.custom
solver.bc_upper[0] = pyclaw.BC.custom
solver.user_bc_lower = lowerdirichlet
solver.user_bc_upper = upperdirichlet
xlower = 0.0
xupper = 1.0
mx = 51
x = pyclaw.Dimension(xlower, xupper, mx, name='x')
domain = pyclaw.Domain(x)
num_eqn = 2
state = pyclaw.State(domain, num_eqn)
# Gravitational constant
state.problem_data['u_rel'] = np.array([1., 1 / 30.])
state.problem_data['efix'] = False
xc = state.grid.x.centers
IC = 'dam-break'
# IC = 'uniform-all'
# IC = 'perturbation'
x0 = xc[2]
if IC == 'uniform-all':
c0 = np.array([0.2, 0.0])
# state defaults to empty. Convert to ones and fill with c0
state.q = np.ones_like(state.q) * c0[:, np.newaxis]
elif IC == 'dam-break':
# I changed state.is_valid() to always return true for fortran contiguity
cr0 = np.array([0.2, 0.0])
cl0 = np.array([0.0, 0.0])
state.q = np.ones_like(state.q)
state.q = cl0[:,np.newaxis]*(xc <= x0)[np.newaxis,:] + \
cr0[:,np.newaxis]*(xc > x0)[np.newaxis,:]
state.q[0, -1] = 1.
# Change these later to reflect initial conditions
# 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':
# x1 = x0
x1 = 0.3
x2 = 0.7
eps = 0.1
state.q[0, :] = eps * np.exp(-1 / eps * (xc - x1)**2)
state.q[1, :] = eps * np.exp(-1 / eps * (xc - x1)**2)
claw = pyclaw.Controller()
claw.keep_copy = True
claw.num_output_times = 50
claw.tfinal = 10
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.setplot = setplot
return claw
