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 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 sloped_shelf(num_cells,eigen_method,**kargs):
r"""Shelf test"""
# Construct output and plot directory paths
prefix = 'ml_e%s_n%s' % (eigen_method,num_cells)
name = 'multilayer/sloped_shelf'
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
# Use wall boundary condition at beach
solver.bc_lower[0] = 1
solver.bc_upper[0] = 0
solver.user_bc_upper = ml.bc.wall_qbc_upper
solver.aux_bc_lower[0] = 1
solver.aux_bc_upper[0] = 1
# Set the Riemann solver
solver.rp = layered_shallow_water_1D
# 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('x',-400e3,0.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
x0 = -130e3
x1 = -30e3
ml.aux.set_sloped_shelf_bathymetry(solution.state,x0,x1,-4000.0,-100.0)
ml.aux.set_no_wind(solution.state)
ml.aux.set_h_hat(solution.state,0.5,[0.0,-300.0],[0.0,-300.0])
# Set perturbation to sea at rest
ml.qinit.set_acta_numerica_init_condition(solution.state,0.4)
# ================================
# = Create simulation controller =
# ================================
controller = pyclaw.Controller()
controller.solution = solution
controller.solver = solver
# Output parameters
controller.output_style = 1
controller.tfinal = 7200.0
controller.num_output_times = 300
controller.write_aux_init = True
controller.outdir = outdir
controller.write_aux = True
# ==================
# = Run Simulation =
# ==================
state = controller.run()
# ============
# = Plotting =
# ============
plot_kargs = {"eta":[0.0,-300.0],
"rho":solution.state.problem_data['rho'],
"g":solution.state.problem_data['g'],
"dry_tolerance":solution.state.problem_data['dry_tolerance'],
"bathy_ref_lines":[x0,x1]}
plot(setplot="./setplot_shelf.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 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 ['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
# 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 Riemann solver
solver.rp = layered_shallow_water_1D
# 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('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.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 rarefaction(num_cells,eigen_method,entropy_fix,**kargs):
r"""docstring for oscillatory_wind"""
# Construct output and plot directory paths
prefix = 'ml_e%s_m%s_fix' % (eigen_method,num_cells)
if entropy_fix:
prefix = "".join((prefix,"T"))
else:
prefix = "".join((prefix,"F"))
name = 'all_rare'
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 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('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.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
eta = [0.0,-0.5]
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,eta,eta)
# Set sea at rest initial condition with diverging velocities
u_left = [0.0,-0.5]
u_right = [0.0,0.5]
h_hat = [eta[0] - eta[1],eta[1] + 1.0]
q_left = [h_hat[0] * state.problem_data['rho'][0],
u_left[0] * h_hat[0] * state.problem_data['rho'][0],
h_hat[1] * state.problem_data['rho'][1],
u_left[1] * h_hat[1] * state.problem_data['rho'][1]]
q_right = [h_hat[0] * state.problem_data['rho'][0],
u_right[0] * h_hat[0] * state.problem_data['rho'][0],
h_hat[1] * state.problem_data['rho'][1],
u_right[1] * h_hat[1] * state.problem_data['rho'][1]]
ml.qinit.set_riemann_init_condition(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(setplot_path="./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 wave_family(num_cells,eigen_method,wave_family,dry_state=True,**kargs):
r"""docstring for oscillatory_wind"""
# Construct output and plot directory paths
prefix = 'ml_e%s_n%s' % (eigen_method,num_cells)
if dry_state:
name = 'multilayer/dry_wave_%s' % wave_family
else:
name = 'multilayer/wet_wave_%s' % wave_family
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()
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 = layered_shallow_water_1D
# 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.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'] = False
solution = pyclaw.Solution(state,domain)
solution.t = 0.0
# Set aux arrays including bathymetry, wind field and linearized depths
if dry_state:
ml.aux.set_jump_bathymetry(solution.state,0.5,[-1.0,-0.2])
else:
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.6],[0.0,-0.6])
# Set initial condition
if wave_family == 3:
ml.qinit.set_wave_family_init_condition(solution.state,wave_family,0.45,0.1)
elif wave_family == 4:
# The perturbation must be less in this case otherwise the internal
# wave will crest the bathymetry jump
ml.qinit.set_wave_family_init_condition(solution.state,wave_family,0.45,0.04)
# ================================
# = Create simulation controller =
# ================================
controller = pyclaw.Controller()
controller.solution = solution
controller.solver = solver
# Output parameters
controller.output_style = 1
controller.tfinal = 0.5
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 = {'wave_family':wave_family,
'rho':solution.state.problem_data['rho'],
'dry_tolerance':solution.state.problem_data['dry_tolerance']}
plot(setplot="./setplot_wave_family.py",outdir=outdir,plotdir=plotdir,
htmlplot=kargs.get('htmlplot',False),iplot=kargs.get('iplot',False),
file_format=controller.output_format,**plot_kargs)
def jump_shelf(wave_height, **kargs):
r"""Shelf test"""
# Single layer test
single_layer = kargs.get("single_layer", False)
# Construct output and plot directory paths
if single_layer:
prefix = 'sl_h%s' % (int(wave_height))
elif kargs.get("internal_only", False):
prefix = 'il_h%s' % (int(wave_height))
else:
prefix = 'ml_h%s' % (int(wave_height))
name = 'multilayer/tsunami/jump'
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()
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
solver.num_eqn = 4
# Boundary conditions
# Use wall boundary condition at beach
solver.bc_lower[0] = 1
solver.bc_upper[0] = 0
solver.user_bc_upper = ml.bc.wall_qbc_upper
solver.aux_bc_lower[0] = 1
solver.aux_bc_upper[0] = 1
# Set the Riemann solver
solver.rp = layered_shallow_water_1D
# 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(-400e3, 0.0, 2000)
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'] = 2
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,-30e3,[-4000.0,-100.0])
ml.aux.set_no_wind(solution.state)
if single_layer:
ml.aux.set_h_hat(solution.state, 0.5, [0.0, -1e10], [0.0, -1e10])
else:
ml.aux.set_h_hat(solution.state, 0.5, [0.0, -300.0], [0.0, -300.0])
# Ocean at rest
ml.qinit.set_quiescent_init_condition(state, single_layer=single_layer)
# Set surface perturbations
# set_tsunami_init_condition(solution.state, wave_height, single_layer=single_layer,
# bounds=[-50e3, -30e3])
set_acta_numerica_init_condition(state, wave_height, single_layer=single_layer, internal_only=kargs.get('internal_only', False))
# Set momentum from horizontal movement
# set_momentum_impulse(solution.state, energy_impulse, single_layer=single_layer,
# bounds=[-50e3, -30e3])
# ================================
# = Create simulation controller =
# ================================
controller = pyclaw.Controller()
controller.solution = solution
controller.solver = solver
# Output parameters
controller.output_style = 1
controller.tfinal = 7200.0 * 2
controller.num_output_times = 300 * 2
# controller.output_style = 2
# controller.out_times = [0.0,720.0,2400.0,4800.0,7200.0]
controller.write_aux_init = True
controller.outdir = outdir
controller.write_aux = True
# ==================
# = Run Simulation =
# ==================
state = controller.run()
# ============
# = Plotting =
# ============
plot_kargs = {"eta":[0.0,-300.0],
"rho":solution.state.problem_data['rho'],
"g":solution.state.problem_data['g'],
"dry_tolerance":solution.state.problem_data['dry_tolerance'],
"bathy_ref_lines":[-30e3]}
plot(setplot="./setplot_shelf.py",outdir=outdir,plotdir=plotdir,
htmlplot=kargs.get('htmlplot',False),iplot=kargs.get('iplot',False),
file_format=controller.output_format,**plot_kargs)
