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 petclaw as pyclaw
else:
import pyclaw
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D()
else:
solver = pyclaw.ClawSolver1D()
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 burgers(use_petsc=0,kernel_language='Fortran',iplot=0,htmlplot=0,outdir='./_output',solver_type='classic'):
"""
Example python script for solving the 1d Burgers equation.
"""
import numpy as np
if use_petsc:
import petclaw as pyclaw
else:
import pyclaw
#===========================================================================
# Setup solver and solver parameters
#===========================================================================
if solver_type=='sharpclaw':
solver = pyclaw.SharpClawSolver1D()
else:
solver = pyclaw.ClawSolver1D()
solver.limiters = pyclaw.limiters.tvd.vanleer
solver.kernel_language = kernel_language
if kernel_language=='Python':
solver.set_riemann_solver('burgers')
elif kernel_language=='Fortran':
import riemann
solver.rp = riemann.rp1_burgers
solver.num_waves = 1
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
status = claw.run()
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
def advection(kernel_language='Python',
iplot=False,
htmlplot=False,
use_petsc=False,
solver_type='classic',
outdir='./_output'):
"""
Example python script for solving the 1d advection equation.
"""
import numpy as np
if use_petsc:
import petclaw as pyclaw
else:
import pyclaw
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D()
else:
solver = pyclaw.ClawSolver1D()
solver.kernel_language = kernel_language
from riemann import rp_advection
solver.num_waves = rp_advection.num_waves
if solver.kernel_language == 'Python':
solver.rp = rp_advection.rp_advection_1d
else:
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.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
claw.tfinal = 1.0
status = claw.run()
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
def vc_advection(use_petsc=False,
solver_type='classic',
kernel_language='Python',
iplot=False,
htmlplot=False,
outdir='./_output'):
if use_petsc:
import petclaw as pyclaw
else:
import pyclaw
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D()
else:
solver = pyclaw.ClawSolver1D()
solver.kernel_language = kernel_language
from riemann import rp_vc_advection
solver.num_waves = rp_vc_advection.num_waves
if solver.kernel_language == 'Python':
solver.rp = rp_vc_advection.rp_vc_advection_1d
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 vc_advection(use_petsc=False,solver_type='classic',kernel_language='Python',iplot=False,htmlplot=False,outdir='./_output'):
if use_petsc:
import petclaw as pyclaw
else:
import pyclaw
if solver_type=='sharpclaw':
solver = pyclaw.SharpClawSolver1D()
else:
solver = pyclaw.ClawSolver1D()
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 acoustics(use_petsc=False,kernel_language='Fortran',solver_type='classic',iplot=False,htmlplot=False,outdir='./_output',weno_order=5):
"""
This example solves the 1-dimensional acoustics equations in a homogeneous
medium.
"""
from numpy import sqrt, exp, cos
from riemann import rp1_acoustics
#=================================================================
# Import the appropriate classes, depending on the options passed
#=================================================================
if use_petsc:
import petclaw as pyclaw
else:
import pyclaw
if solver_type=='classic':
solver = pyclaw.ClawSolver1D()
elif solver_type=='sharpclaw':
solver = pyclaw.SharpClawSolver1D()
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
from riemann import rp_acoustics
solver.num_waves=rp_acoustics.num_waves
if kernel_language=='Python':
solver.rp = rp_acoustics.rp_acoustics_1d
else:
from riemann import rp1_acoustics
solver.rp = rp1_acoustics
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.
#========================================================================
# Set up the controller object
#========================================================================
claw = pyclaw.Controller()
claw.solution = pyclaw.Solution(state,domain)
claw.solver = solver
claw.outdir = outdir
claw.tfinal = 1.0
# Solve
status = claw.run()
# Plot results
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
def shallow1D(use_petsc=False,
kernel_language='Fortran',
iplot=False,
htmlplot=False,
outdir='./_output',
solver_type='classic'):
#===========================================================================
# Import libraries
#===========================================================================
import numpy as np
if use_petsc:
import petclaw as pyclaw
else:
import pyclaw
if solver_type == 'classic':
solver = pyclaw.ClawSolver1D()
solver.limiters = pyclaw.limiters.tvd.vanleer
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D()
#===========================================================================
# Setup solver and solver parameters
#===========================================================================
solver.num_waves = 2
solver.kernel_language = kernel_language
if kernel_language == 'Python':
solver.set_riemann_solver('shallow_roe')
solver.problem_data['g'] = 1.0
solver.problem_data['efix'] = False
elif kernel_language == 'Fortran':
import riemann
solver.rp = riemann.rp1_shallow_roe_with_efix
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
#===========================================================================
xlower = -5.0
xupper = 5.0
mx = 500
x = pyclaw.Dimension('x', xlower, xupper, mx)
domain = pyclaw.Domain(x)
num_eqn = 2
state = pyclaw.State(domain, num_eqn)
# Parameters
state.problem_data['grav'] = 1.0
xc = state.grid.x.centers
IC = '2-shock'
x0 = 0.
if IC == 'dam-break':
hl = 3.
ul = 0.
hr = 1.
ur = 0.
state.q[0, :] = hl * (xc <= x0) + hr * (xc > x0)
state.q[1, :] = hl * ul * (xc <= x0) + hr * ur * (xc > x0)
elif IC == '2-shock':
hl = 1.
ul = 1.
hr = 1.
ur = -1.
state.q[0, :] = hl * (xc <= x0) + hr * (xc > x0)
state.q[1, :] = hl * ul * (xc <= x0) + hr * ur * (xc > x0)
elif IC == 'perturbation':
eps = 0.1
state.q[0, :] = 1.0 + eps * np.exp(-(xc - x0)**2 / 0.5)
state.q[1, :] = 0.
#===========================================================================
# Setup controller and controller paramters
#===========================================================================
claw = pyclaw.Controller()
claw.keep_copy = True
claw.tfinal = 2.0
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
#===========================================================================
# Solve the problem
#===========================================================================
status = claw.run()
#===========================================================================
# Plot results
#===========================================================================
if iplot:
pyclaw.plot.interactive_plot(outdir=outdir,
file_format=claw.output_format)
if htmlplot:
pyclaw.plot.html_plot(outdir=outdir, file_format=claw.output_format)
def acoustics(use_petsc=False,
kernel_language='Fortran',
solver_type='classic',
iplot=False,
htmlplot=False,
outdir='./_output',
weno_order=5):
"""
This example solves the 1-dimensional acoustics equations in a homogeneous
medium.
"""
import numpy as np
#=================================================================
# Import the appropriate classes, depending on the options passed
#=================================================================
if use_petsc:
import petclaw as pyclaw
else:
import pyclaw
if solver_type == 'classic':
solver = pyclaw.ClawSolver1D()
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D()
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
from riemann import rp_acoustics
solver.num_waves = rp_acoustics.num_waves
if kernel_language == 'Python':
solver.rp = rp_acoustics.rp_acoustics_1d
solver.limiters = pyclaw.limiters.tvd.MC
solver.bc_lower[0] = pyclaw.BC.wall
solver.bc_upper[0] = pyclaw.BC.wall
solver.cfl_desired = 1.0
solver.cfl_max = 1.0
#========================================================================
# Instantiate the grid and set the boundary conditions
#========================================================================
x = pyclaw.Dimension('x', 0.0, 1.0, 200)
grid = pyclaw.Grid(x)
num_eqn = 2
state = pyclaw.State(grid, 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'] = np.sqrt(rho * bulk)
state.problem_data['cc'] = np.sqrt(bulk / rho)
#========================================================================
# Set the initial condition
#========================================================================
xc = grid.x.center
state.q[0, :] = np.cos(2 * np.pi * xc)
state.q[1, :] = 0.
#========================================================================
# Set up the controller object
#========================================================================
claw = pyclaw.Controller()
claw.solution = pyclaw.Solution(state)
claw.solver = solver
claw.outdir = outdir
claw.num_output_times = 40
claw.tfinal = 2.0
# Solve
status = claw.run()
# Plot results
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
def acoustics(use_petsc=True,
kernel_language='Fortran',
solver_type='classic',
iplot=False,
htmlplot=False,
outdir='./_output',
weno_order=5):
import numpy as np
"""
1D acoustics example.
"""
output_format = None #Suppress output to make tests faster
if use_petsc:
import petclaw as pyclaw
else: #Pure pyclaw
import pyclaw
if solver_type == 'classic':
solver = pyclaw.ClawSolver1D()
elif solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D()
solver.weno_order = weno_order
else:
raise Exception('Unrecognized value of solver_type.')
# Initialize patches and solution
x = pyclaw.Dimension('x', 0.0, 1.0, 100)
domain = pyclaw.Domain(x)
num_eqn = 2
state = pyclaw.State(domain, num_eqn)
rho = 1.0
bulk = 1.0
state.problem_data['rho'] = rho
state.problem_data['bulk'] = bulk
state.problem_data['zz'] = np.sqrt(rho * bulk)
state.problem_data['cc'] = np.sqrt(rho / bulk)
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))
state.q[1, :] = 0.
init_solution = pyclaw.Solution(state, domain)
solver.num_waves = 2
solver.kernel_language = kernel_language
if kernel_language == 'Python':
from riemann import rp_acoustics
solver.rp = rp_acoustics.rp_acoustics_1d
solver.limiters = [4] * solver.num_waves
solver.dt_initial = grid.delta[0] / state.problem_data['cc'] * 0.1
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
claw = pyclaw.Controller()
claw.keep_copy = True
claw.num_output_times = 5
claw.output_format = output_format
claw.outdir = outdir
claw.tfinal = 1.0
claw.solution = init_solution
claw.solver = solver
# Solve
status = claw.run()
#This test is set up so that the waves pass through the domain
#exactly once, and the final solution should be equal to the
#initial condition. Here we output the 1-norm of their difference.
if use_petsc == True:
q0 = claw.frames[0].state.gqVec.getArray().reshape([-1])
qfinal = claw.frames[
claw.num_output_times].state.gqVec.getArray().reshape([-1])
else:
q0 = claw.frames[0].state.q.reshape([-1])
qfinal = claw.frames[claw.num_output_times].state.q.reshape([-1])
dx = claw.solution.domain.delta[0]
return dx * np.sum(np.abs(qfinal - q0))
def stegoton(use_petsc=0,
kernel_language='Fortran',
solver_type='classic',
iplot=0,
htmlplot=0,
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$$
"""
vary_Z = False
if use_petsc:
import petclaw as pyclaw
else:
import pyclaw
if solver_type == 'sharpclaw':
solver = pyclaw.SharpClawSolver1D()
else:
solver = pyclaw.ClawSolver1D()
solver.kernel_language = kernel_language
if kernel_language == 'Python':
solver.set_riemann_solver('nonlinear_elasticity')
elif kernel_language == 'Fortran':
import riemann
solver.rp = riemann.rp1_nonlinear_elasticity_fwave
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_lower
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)
num_eqn = 2
state = pyclaw.State(domain, 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,
solver.aux_bc_lower[0],
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
solver.num_waves = 2
if solver_type == 'sharpclaw':
solver.lim_type = 2
solver.char_decomp = 0
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
if vary_Z == True:
#Zvalues = [1.0,1.2,1.4,1.6,1.8,2.0,2.2,2.4,2.6,2.8,3.0,3.5,4.0]
Zvalues = [3.5, 4.0]
#a2values= [0.9766161130681, 1.0888194560100042, 1.1601786315361329, 1.20973731651806, 1.2462158254919984]
for ii, Z in enumerate(Zvalues):
a2 = 1.0 #a2values[ii]
KB = Z
rhoB = Z
state.problem_data['KB'] = KB
state.problem_data['rhoB'] = rhoB
state.problem_data['trdone'] = False
state.aux = setaux(xc,
rhoB,
KB,
rhoA,
KA,
alpha,
bc_lower,
xupper=xupper)
patch.x.bc_lower = 2
patch.x.bc_upper = 2
state.t = 0.0
qinit(state, ic=2, a2=a2)
init_solution = Solution(state, domain)
claw.solution = init_solution
claw.solution.t = 0.0
claw.tfinal = tfinal
claw.outdir = './_output_Z' + str(Z) + '_' + str(cellsperlayer)
status = claw.run()
else:
# Solve
status = claw.run()
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
