def setup_solver():
import pyclaw
import peanoclaw
solver = pyclaw.ClawSolver2D()
solver.limiters = pyclaw.limiters.tvd.MC
solver.dimensional_split=1
import riemann
solver.rp = riemann.rp2_shallow_roe_with_efix
solver.num_waves = 3
solver.bc_lower[0] = pyclaw.BC.extrap
solver.bc_upper[0] = pyclaw.BC.extrap
solver.bc_lower[1] = pyclaw.BC.wall
solver.bc_upper[1] = pyclaw.BC.wall
return solver
def shallow_4_Rossby_Haurwitz(iplot=0,htmlplot=False,outdir='./_output'):
# Import pyclaw module
import pyclaw
#===========================================================================
# Set up solver and solver parameters
#===========================================================================
solver = pyclaw.ClawSolver2D()
import riemann
solver.rp = riemann.rp2_shallow_sphere
import classic2
solver.fmod = classic2
# Set boundary conditions
# =======================
# Conserved variables
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
solver.bc_lower[1] = pyclaw.BC.custom # Custom BC for sphere
solver.bc_upper[1] = pyclaw.BC.custom # Custom BC for sphere
solver.user_bc_lower = qbc_lower_y
solver.user_bc_upper = qbc_upper_y
# Auxiliary array
solver.aux_bc_lower[0] = pyclaw.BC.periodic
solver.aux_bc_upper[0] = pyclaw.BC.periodic
solver.aux_bc_lower[1] = pyclaw.BC.custom # Custom BC for sphere
solver.aux_bc_upper[1] = pyclaw.BC.custom # Custom BC for sphere
solver.user_aux_bc_lower = auxbc_lower_y
solver.user_aux_bc_upper = auxbc_upper_y
# Dimensional splitting ?
# =======================
solver.dimensional_split = 0
# Transverse increment waves and transverse correction waves are computed
# and propagated.
# =======================================================================
solver.transverse_waves = 2
# Number of waves in each Riemann solution
# ========================================
solver.num_waves = 3
# Use source splitting method
# ===========================
solver.source_split = 2
# Set source function
# ===================
solver.step_source = fortran_src_wrapper
# Set the limiter for the waves
# =============================
solver.limiters = pyclaw.limiters.tvd.MC
#===========================================================================
# Initialize domain and state, then initialize the solution associated to the
# state and finally initialize aux array
#===========================================================================
# Domain:
# ====
xlower = -3.0
xupper = 1.0
mx = 100
ylower = -1.0
yupper = 1.0
my = 50
# Check whether or not the even number of cells are used in in both
# directions. If odd numbers are used a message is print at screen and the
# simulation is interrputed.
if(mx % 2 != 0 or my % 2 != 0):
import sys
message = 'Please, use even numbers of cells in both direction. ' \
'Only even numbers allow to impose correctly the boundary ' \
'conditions!'
print message
sys.exit(0)
x = pyclaw.Dimension('x',xlower,xupper,mx)
y = pyclaw.Dimension('y',ylower,yupper,my)
domain = pyclaw.Domain([x,y])
dx = domain.grid.delta[0]
dy = domain.grid.delta[1]
# Define some parameters used in Fortran common blocks
solver.fmod.comxyt.dxcom = dx
solver.fmod.comxyt.dycom = dy
solver.fmod.sw.g = 11489.57219
solver.rp.comxyt.dxcom = dx
solver.rp.comxyt.dycom = dy
solver.rp.sw.g = 11489.57219
# Define state object
# ===================
num_eqn = 4 # Number of equations
num_aux = 16 # Number of auxiliary variables
state = pyclaw.State(domain,num_eqn,num_aux)
# Override default mapc2p function
# ================================
state.grid.mapc2p = mapc2p_sphere_vectorized
# Set auxiliary variables
# =======================
import problem
# Get lower left corner coordinates
xlower,ylower = state.grid.lower[0],state.grid.lower[1]
num_ghost = 2
auxtmp = np.ndarray(shape=(num_aux,mx+2*num_ghost,my+2*num_ghost), dtype=float, order='F')
auxtmp = problem.setaux(mx,my,num_ghost,mx,my,xlower,ylower,dx,dy,auxtmp,Rsphere)
state.aux[:,:,:] = auxtmp[:,num_ghost:-num_ghost,num_ghost:-num_ghost]
# Set index for capa
state.index_capa = 0
# Set initial conditions
# ======================
# 1) Call fortran function
qtmp = np.ndarray(shape=(num_eqn,mx+2*num_ghost,my+2*num_ghost), dtype=float, order='F')
qtmp = problem.qinit(mx,my,num_ghost,mx,my,xlower,ylower,dx,dy,qtmp,auxtmp,Rsphere)
state.q[:,:,:] = qtmp[:,num_ghost:-num_ghost,num_ghost:-num_ghost]
# 2) call python function define above
#qinit(state,mx,my)
#===========================================================================
# Set up controller and controller parameters
#===========================================================================
claw = pyclaw.Controller()
claw.keep_copy = False
claw.output_style = 1
claw.num_output_times = 10
claw.tfinal = 10
claw.solution = pyclaw.Solution(state,domain)
claw.solver = solver
claw.outdir = outdir
#===========================================================================
# Solve the problem
#===========================================================================
status = claw.run()
#===========================================================================
# Plot results
#===========================================================================
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
def shallow_4_Rossby_Haurwitz(iplot=0, htmlplot=False, outdir='./_output'):
# Import pyclaw module
import pyclaw
#===========================================================================
# Set up solver and solver parameters
#===========================================================================
solver = pyclaw.ClawSolver2D()
# Set boundary conditions
# =======================
# Conserved variables
solver.bc_lower[0] = pyclaw.BC.periodic
solver.bc_upper[0] = pyclaw.BC.periodic
solver.bc_lower[1] = pyclaw.BC.custom # Custom BC for sphere
solver.bc_upper[1] = pyclaw.BC.custom # Custom BC for sphere
solver.user_bc_lower = qbc_lower_y
solver.user_bc_upper = qbc_upper_y
# Auxiliary array
solver.aux_bc_lower[0] = pyclaw.BC.periodic
solver.aux_bc_upper[0] = pyclaw.BC.periodic
solver.aux_bc_lower[1] = pyclaw.BC.custom # Custom BC for sphere
solver.aux_bc_upper[1] = pyclaw.BC.custom # Custom BC for sphere
solver.user_aux_bc_lower = auxbc_lower_y
solver.user_aux_bc_upper = auxbc_upper_y
# Dimensional splitting ?
# =======================
solver.dimensional_split = 0
# Transverse increment waves and transverse correction waves are computed
# and propagated.
# =======================================================================
solver.transverse_waves = 2
# Number of waves in each Riemann solution
# ========================================
solver.num_waves = 3
# Use source splitting method
# ===========================
solver.source_split = 2
# Set source function
# ===================
solver.step_source = fortran_src_wrapper
# Set the limiter for the waves
# =============================
solver.limiters = pyclaw.limiters.tvd.MC
#===========================================================================
# Initialize domain and state, then initialize the solution associated to the
# state and finally initialize aux array
#===========================================================================
# Domain:
# ====
xlower = -3.0
xupper = 1.0
mx = 40
ylower = -1.0
yupper = 1.0
my = 20
x = pyclaw.Dimension('x', xlower, xupper, mx)
y = pyclaw.Dimension('y', ylower, yupper, my)
domain = pyclaw.Domain([x, y])
dx = domain.delta[0]
dy = domain.delta[1]
# Define some parameters used in classic2
import classic2
classic2.comxyt.dxcom = dx
classic2.comxyt.dycom = dy
classic2.sw.g = 11489.57219
# Override default mapc2p function
# ================================
grid = domain.grid
grid.mapc2p = mapc2p_sphere_vectorized
# Define state object
# ===================
num_eqn = 4 # Number of equations
num_aux = 16 # Number of auxiliary variables
state = pyclaw.State(domain, num_eqn, num_aux)
# Set auxiliary variables
# =======================
import problem
# Get lower left corner coordinates
xlower, ylower = grid.lower[0], grid.lower[1]
num_ghost = 2
auxtmp = np.ndarray(shape=(num_aux, mx + 2 * num_ghost,
my + 2 * num_ghost),
dtype=float,
order='F')
auxtmp = problem.setaux(mx, my, num_ghost, mx, my, xlower, ylower, dx, dy,
auxtmp, Rsphere)
state.aux[:, :, :] = auxtmp[:, num_ghost:-num_ghost, num_ghost:-num_ghost]
# Set index for capa
state.index_capa = 0
# Set initial conditions
# ======================
# 1) Call fortran function
qtmp = np.ndarray(shape=(num_eqn, mx + 2 * num_ghost, my + 2 * num_ghost),
dtype=float,
order='F')
qtmp = problem.qinit(mx, my, num_ghost, mx, my, xlower, ylower, dx, dy,
qtmp, auxtmp, Rsphere)
state.q[:, :, :] = qtmp[:, num_ghost:-num_ghost, num_ghost:-num_ghost]
# 2) call python function define above
#qinit(state,mx,my)
#===========================================================================
# Set up controller and controller parameters
#===========================================================================
claw = pyclaw.Controller()
claw.keep_copy = True
claw.output_style = 1
claw.num_output_times = 10
claw.tfinal = 10
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
#===========================================================================
# Solve the problem
#===========================================================================
status = claw.run()
#===========================================================================
# Plot results
#===========================================================================
if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
# Define variable usedto verify the correctness of the regression test
# ====================================================================
height = claw.frames[claw.num_output_times].state.q[0, :, :]
return height