def test_3x3_grid(): r"""This test simply solves a 3x3 grid, once with PyClaw and once as one patch with PeanoClaw. In the end it checks if the resulting qbcs match. """ #=========================================================================== # Import libraries #=========================================================================== import numpy as np import pyclaw import peanoclaw #=========================================================================== # Setup solver and solver parameters for PyClaw run #=========================================================================== pyclaw_solver = setup_solver() #=========================================================================== # Setup solver and solver parameters for PeanoClaw run #=========================================================================== peanoclaw_solver = setup_solver() peano_solver = peanoclaw.Solver(peanoclaw_solver, 1.0) #=========================================================================== # Initialize domain and state, then initialize the solution associated to the # state and finally initialize aux array #=========================================================================== # Domain: xlower = 0.0 xupper = 1.0 mx = 3 ylower = 0.0 yupper = 1.0 my = 3 x = pyclaw.Dimension(xlower,xupper,mx,name='x') y = pyclaw.Dimension(ylower,yupper,my,name='y') domain = pyclaw.Domain([x,y]) num_eqn = 3 # Number of equations pyclaw_state = pyclaw.State(domain,num_eqn) peanoclaw_state = pyclaw.State(domain, num_eqn) grav = 1.0 # Parameter (global auxiliary variable) pyclaw_state.problem_data['grav'] = grav peanoclaw_state.problem_data['grav'] = grav # Initial solution # ================ # Riemann states of the dam break problem damRadius = 0.2 hl = 2. ul = 0. vl = 0. hr = 1. ur = 0. vr = 0. qinit(pyclaw_state,hl,ul,vl,hr,ur,vl,damRadius) # This function is defined above qinit(peanoclaw_state,hl,ul,vl,hr,ur,vl,damRadius) # This function is defined above tfinal = 1.0 #=========================================================================== # Set up controller and controller parameters for PyClaw run #=========================================================================== pyclaw_controller = pyclaw.Controller() pyclaw_controller.tfinal = tfinal pyclaw_controller.solution = pyclaw.Solution(pyclaw_state,domain) pyclaw_controller.solver = pyclaw_solver pyclaw_controller.num_output_times = 1 pyclaw_controller.run() #=========================================================================== # Set up controller and controller parameters for PyClaw run #=========================================================================== peanoclaw_controller = pyclaw.Controller() peanoclaw_controller.tfinal = tfinal peanoclaw_controller.solution = pyclaw.Solution(peanoclaw_state,domain) peanoclaw_controller.solver = peano_solver peanoclaw_controller.num_output_times = 1 peanoclaw_controller.run() assert(np.max(np.abs(pyclaw_solver.qbc - peanoclaw_solver.qbc)) < 1e-9)
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