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 = 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.grid.delta[0]
dy = domain.grid.delta[1]
# Define some parameters used in classic2
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
# 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
def shallow_4_Rossby_Haurwitz(use_petsc=False,solver_type='classic',iplot=0,htmlplot=False,outdir='./_output'):
# Import pyclaw module
if use_petsc:
raise Exception("petclaw does not currently support mapped grids (go bug Lisandro who promised to implement them)")
if solver_type != 'classic':
raise Exception("Only Classic-style solvers (solver_type='classic') are supported")
from clawpack import pyclaw
#===========================================================================
# Set up solver and solver parameters
#===========================================================================
solver = pyclaw.ClawSolver2D()
from clawpack import riemann
solver.rp = riemann.rp2_shallow_sphere
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 = 40
ylower = -1.0
yupper = 1.0
my = 20
# 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
# =======================
# 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 = 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)
return claw
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 setup(use_petsc=False, solver_type="classic", outdir="./_output", disable_output=False):
if use_petsc:
raise Exception(
"petclaw does not currently support mapped grids (go bug Lisandro who promised to implement them)"
)
if solver_type != "classic":
raise Exception("Only Classic-style solvers (solver_type='classic') are supported on mapped grids")
solver = pyclaw.ClawSolver2D(riemann.shallow_sphere_2D)
solver.fmod = classic2
# Set boundary conditions
# =======================
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
# 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
# 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:
message = (
"Please, use even numbers of cells in both direction. "
"Only even numbers allow to impose correctly the boundary "
"conditions!"
)
raise ValueError(message)
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_aux = 16 # Number of auxiliary variables
state = pyclaw.State(domain, solver.num_eqn, num_aux)
# Override default mapc2p function
# ================================
state.grid.mapc2p = mapc2p_sphere_vectorized
# Set auxiliary variables
# =======================
# 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=(solver.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
if disable_output:
claw.output_format = None
claw.output_style = 1
claw.num_output_times = 10
claw.tfinal = 10
claw.solution = pyclaw.Solution(state, domain)
claw.solver = solver
claw.outdir = outdir
return claw
def setup(use_petsc=False,solver_type='classic',outdir='./_output', disable_output=False):
if use_petsc:
raise Exception("petclaw does not currently support mapped grids (go bug Lisandro who promised to implement them)")
if solver_type != 'classic':
raise Exception("Only Classic-style solvers (solver_type='classic') are supported on mapped grids")
solver = pyclaw.ClawSolver2D(riemann.shallow_sphere_2D)
solver.fmod = classic2
# Set boundary conditions
# =======================
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
# 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
# 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):
message = 'Please, use even numbers of cells in both direction. ' \
'Only even numbers allow to impose correctly the boundary ' \
'conditions!'
raise ValueError(message)
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_aux = 16 # Number of auxiliary variables
state = pyclaw.State(domain,solver.num_eqn,num_aux)
# Override default mapc2p function
# ================================
state.grid.mapc2p = mapc2p_sphere_vectorized
# Set auxiliary variables
# =======================
# 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=(solver.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
if disable_output:
claw.output_format = None
claw.output_style = 1
claw.num_output_times = 10
claw.tfinal = 10
claw.solution = pyclaw.Solution(state,domain)
claw.solver = solver
claw.outdir = outdir
return claw
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.dim_split = 0
# Transverse increment waves and transverse correction waves are computed
# and propagated.
# =======================================================================
solver.order_trans = 2
# Number of waves in each Riemann solution
# ========================================
solver.mwaves = 3
# Use source splitting method
# ===========================
solver.src_split = 2
# Set source function
# ===================
solver.step_src = fortran_src_wrapper
# Set the limiter for the waves
# =============================
solver.limiters = pyclaw.limiters.tvd.MC
#===========================================================================
# Initialize grid and state, then initialize the solution associated to the
# state and finally initialize aux array
#===========================================================================
# Grid:
# ====
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)
grid = pyclaw.Grid([x,y])
dx = grid.d[0]
dy = grid.d[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.mapc2p = mapc2p_sphere_vectorized
# Define state object
# ===================
meqn = 4 # Number of equations
maux = 16 # Number of auxiliary variables
state = pyclaw.State(grid,meqn,maux)
# Set auxiliary variables
# =======================
import problem
# Get lower left corner coordinates
xlowerg,ylowerg = grid.lowerg[0],grid.lowerg[1]
mbc = 2
auxtmp = np.ndarray(shape=(maux,mx+2*mbc,my+2*mbc), dtype=float, order='F')
auxtmp = problem.setaux(mx,my,mbc,mx,my,xlowerg,ylowerg,dx,dy,auxtmp,Rsphere)
state.aux[:,:,:] = auxtmp[:,mbc:-mbc,mbc:-mbc]
# Set index for capa
state.mcapa = 0
# Set initial conditions
# ======================
# 1) Call fortran function
qtmp = np.ndarray(shape=(meqn,mx+2*mbc,my+2*mbc), dtype=float, order='F')
qtmp = problem.qinit(mx,my,mbc,mx,my,xlowerg,ylowerg,dx,dy,qtmp,auxtmp,Rsphere)
state.q[:,:,:] = qtmp[:,mbc:-mbc,mbc:-mbc]
# 2) call python function define above
#qinit(state,mx,my)
#===========================================================================
# Set up controller and controller parameters
#===========================================================================
claw = pyclaw.Controller()
claw.keep_copy = False
claw.outstyle = 1
claw.nout = 10
claw.tfinal = 10
claw.solution = pyclaw.Solution(state)
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