def setup(nx=100, kernel_language='Python', use_petsc=False, solver_type='classic', weno_order=5, outdir='./_output'): import numpy as np from clawpack import riemann if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type == 'classic': if kernel_language == 'Fortran': solver = pyclaw.ClawSolver1D(riemann.advection_1D) elif kernel_language == 'Python': solver = pyclaw.ClawSolver1D(riemann.advection_1D_py.advection_1D) elif solver_type == 'sharpclaw': if kernel_language == 'Fortran': solver = pyclaw.SharpClawSolver1D(riemann.advection_1D) elif kernel_language == 'Python': solver = pyclaw.SharpClawSolver1D( riemann.advection_1D_py.advection_1D) solver.weno_order = weno_order else: raise Exception('Unrecognized value of solver_type.') solver.kernel_language = kernel_language solver.bc_lower[0] = 2 solver.bc_upper[0] = 2 x = pyclaw.Dimension('x', 0.0, 1.0, nx) 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.keep_copy = True claw.solution = pyclaw.Solution(state, domain) claw.solver = solver if outdir is not None: claw.outdir = outdir else: claw.output_format = None claw.tfinal = 1.0 return claw
def setup(use_petsc=False, solver_type='classic', kernel_language='Python', outdir='./_output'): from clawpack import riemann if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type == 'classic': if kernel_language == 'Fortran': solver = pyclaw.ClawSolver1D(riemann.vc_advection_1D) elif kernel_language == 'Python': solver = pyclaw.ClawSolver1D( riemann.vc_advection_1D_py.vc_advection_1D) elif solver_type == 'sharpclaw': if kernel_language == 'Fortran': solver = pyclaw.SharpClawSolver1D(riemann.vc_advection_1D) elif kernel_language == 'Python': solver = pyclaw.SharpClawSolver1D( riemann.vc_advection_1D_py.vc_advection_1D) solver.weno_order = weno_order else: raise Exception('Unrecognized value of solver_type.') solver.kernel_language = kernel_language solver.limiters = pyclaw.limiters.tvd.MC solver.bc_lower[0] = pyclaw.BC.custom solver.user_bc_lower = custom_bc solver.bc_upper[0] = pyclaw.BC.custom solver.user_bc_upper = custom_bc solver.aux_bc_lower[0] = 2 solver.aux_bc_upper[0] = 2 xlower = -100.0 xupper = 100.0 mx = steps x = pyclaw.Dimension(xlower, xupper, mx, name='x') 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 = 10.0 claw.setplot = setplot claw.keep_copy = True # print claw.solution._get_solution_attribute return claw
def setup(use_petsc=0, kernel_language='Fortran', outdir='./_output', solver_type='classic'): """ Example python script for solving the 1d Burgers equation. """ import numpy as np from clawpack import riemann if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw #=========================================================================== # Setup solver and solver parameters #=========================================================================== if solver_type == 'sharpclaw': if kernel_language == 'Python': solver = pyclaw.SharpClawSolver1D(riemann.burgers_1D_py.burgers_1D) elif kernel_language == 'Fortran': solver = pyclaw.SharpClawSolver1D(riemann.burgers_1D) else: if kernel_language == 'Python': solver = pyclaw.ClawSolver1D(riemann.burgers_1D_py.burgers_1D) elif kernel_language == 'Fortran': solver = pyclaw.ClawSolver1D(riemann.burgers_1D) solver.limiters = pyclaw.limiters.tvd.vanleer solver.kernel_language = kernel_language 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 return claw
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 clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D() else: solver = pyclaw.ClawSolver1D() from clawpack 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 setup(use_petsc=False,solver_type='classic',kernel_language='Python',outdir='./_output'): from clawpack import riemann if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type=='classic': if kernel_language == 'Fortran': solver = pyclaw.ClawSolver1D(riemann.vc_advection_1D) elif kernel_language=='Python': solver = pyclaw.ClawSolver1D(riemann.vc_advection_1D_py.vc_advection_1D) elif solver_type=='sharpclaw': if kernel_language == 'Fortran': solver = pyclaw.SharpClawSolver1D(riemann.vc_advection_1D) elif kernel_language=='Python': solver = pyclaw.SharpClawSolver1D(riemann.vc_advection_1D_py.vc_advection_1D) solver.weno_order=weno_order else: raise Exception('Unrecognized value of solver_type.') solver.kernel_language = kernel_language 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 return claw
def advection(kernel_language='Python',iplot=False,htmlplot=False, use_petsc=False,solver_type='classic', weno_order=5, outdir='./_output'): """ Example python script for solving the 1d advection equation. """ import numpy as np if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type=='sharpclaw': solver = pyclaw.SharpClawSolver1D() solver.weno_order=weno_order else: solver = pyclaw.ClawSolver1D() solver.kernel_language = kernel_language from clawpack.riemann import rp_advection solver.num_waves = rp_advection.num_waves if solver.kernel_language=='Python': solver.rp = rp_advection.rp_advection_1d else: from clawpack 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.keep_copy = True claw.solution = pyclaw.Solution(state,domain) claw.solver = solver if outdir is not None: claw.outdir = outdir else: claw.output_format = None claw.tfinal =1.0 status = claw.run() if htmlplot: pyclaw.plot.html_plot(outdir=outdir) if iplot: pyclaw.plot.interactive_plot(outdir=outdir) return claw
def setup(use_petsc=False, outdir='./_output', solver_type='classic', kernel_language='Python', disable_output=False): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': rs = riemann.euler_1D_py.euler_hllc_1D elif kernel_language == 'Fortran': rs = riemann.euler_hlle_1D if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) elif solver_type == 'classic': solver = pyclaw.ClawSolver1D(rs) solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.extrap solver.bc_upper[0] = pyclaw.BC.extrap mx = 800 x = pyclaw.Dimension(-1.0, 1.0, mx, name='x') domain = pyclaw.Domain([x]) state = pyclaw.State(domain, num_eqn) state.problem_data['gamma'] = gamma state.problem_data['gamma1'] = gamma - 1. x = state.grid.x.centers rho_l = 1. rho_r = 1. / 8 p_l = 1. p_r = 0.1 state.q[density, :] = (x < 0.) * rho_l + (x >= 0.) * rho_r state.q[momentum, :] = 0. velocity = state.q[momentum, :] / state.q[density, :] pressure = (x < 0.) * p_l + (x >= 0.) * p_r state.q[energy, :] = pressure / ( gamma - 1.) + 0.5 * state.q[density, :] * velocity**2 claw = pyclaw.Controller() claw.tfinal = 0.4 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.num_output_times = 10 claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True if disable_output: claw.output_format = None return claw
def setup(nx=100, kernel_language='Python', use_petsc=False, solver_type='classic', weno_order=5, time_integrator='SSP104', outdir='./_output'): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Fortran': riemann_solver = riemann.advection_1D elif kernel_language == 'Python': riemann_solver = riemann.advection_1D_py.advection_1D if solver_type == 'classic': solver = pyclaw.ClawSolver1D(riemann_solver) elif solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(riemann_solver) solver.weno_order = weno_order solver.time_integrator = time_integrator else: raise Exception('Unrecognized value of solver_type.') solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.periodic solver.bc_upper[0] = pyclaw.BC.periodic x = pyclaw.Dimension('x', 0.0, 1.0, nx) domain = pyclaw.Domain(x) state = pyclaw.State(domain, solver.num_eqn) state.problem_data['u'] = 1. # Advection velocity # Initial data xc = state.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.keep_copy = True claw.solution = pyclaw.Solution(state, domain) claw.solver = solver if outdir is not None: claw.outdir = outdir else: claw.output_format = None claw.tfinal = 1.0 claw.setplot = setplot return claw
def setup(use_petsc=False, iplot=False, htmlplot=False, outdir='./_output', solver_type='sharpclaw', kernel_language='Fortran'): """ Solve the Euler equations of compressible fluid dynamics. This example involves a shock wave impacting a sinusoidal density field. """ from clawpack import riemann if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(riemann.euler_with_efix_1D) solver.time_integrator = 'RK' solver.a, solver.b, solver.c = a, b, c solver.cfl_desired = 0.6 solver.cfl_max = 0.7 else: solver = pyclaw.ClawSolver1D(riemann.euler_with_efix_1D) solver.bc_lower[0] = pyclaw.BC.extrap solver.bc_upper[0] = pyclaw.BC.extrap # Initialize domain mx = 400 x = pyclaw.Dimension('x', -5.0, 5.0, mx) domain = pyclaw.Domain([x]) state = pyclaw.State(domain, solver.num_eqn) state.problem_data['gamma'] = gamma state.problem_data['gamma1'] = gamma1 xc = state.grid.x.centers epsilon = 0.2 state.q[0, :] = (xc < -4.) * 3.857143 + (xc >= -4.) * ( 1 + epsilon * np.sin(5 * xc)) velocity = (xc < -4.) * 2.629369 state.q[1, :] = velocity * state.q[0, :] pressure = (xc < -4.) * 10.33333 + (xc >= -4.) * 1. state.q[2, :] = pressure / gamma1 + 0.5 * state.q[0, :] * velocity**2 claw = pyclaw.Controller() claw.tfinal = 1.8 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.num_output_times = 10 claw.outdir = outdir claw.setplot = setplot return claw
def setup(use_petsc=0, outdir='./_output', solver_type='classic'): """ Example python script for solving 1d traffic model: $$ q_t + umax( q(1-q) )_x = 0.$$ """ import numpy as np from clawpack import riemann if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw #=========================================================================== # Setup solver and solver parameters #=========================================================================== if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(riemann.traffic_1D) else: solver = pyclaw.ClawSolver1D(riemann.traffic_1D) 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 #=========================================================================== x = pyclaw.Dimension('x', -1.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, :] = 0.75 * (xc < 0) + 0.1 * (xc > 0.) state.problem_data['efix'] = True state.problem_data['umax'] = 1. #=========================================================================== # Setup controller and controller parameters. Then solve the problem #=========================================================================== claw = pyclaw.Controller() claw.tfinal = 2.0 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True return claw
def setup(use_petsc=0, kernel_language='Python', outdir='./_output', solver_type='classic'): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': riemann_solver = adsolver elif kernel_language == 'Fortran': riemann_solver = riemann.burgers_1D if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(riemann_solver) else: solver = pyclaw.ClawSolver1D(riemann_solver) solver.limiters = pyclaw.limiters.tvd.vanleer solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.periodic #solver.user_bc_lower=custom_bc_one solver.bc_upper[0] = pyclaw.BC.periodic #solver.user_bc_upper=custom_bc_two solver.num_waves = 1 solver.num_eqn = 1 x = pyclaw.Dimension(0.0, 1.0, 500, name='x') domain = pyclaw.Domain(x) num_eqn = 1 state = pyclaw.State(domain, num_eqn) xc = state.grid.x.centers state.q[0, :] = np.sin(np.pi * 2 * xc) + 0.50 state.problem_data['efix'] = True state.problem_data['a'] = 1.0 claw = pyclaw.Controller() claw.tfinal = 2.0 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True return claw
def vc_advection(use_petsc=False,solver_type='classic',kernel_language='Python',iplot=False,htmlplot=False,outdir='./_output'): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type=='sharpclaw': solver = pyclaw.SharpClawSolver1D() else: solver = pyclaw.ClawSolver1D() from clawpack 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 setup(use_petsc=0, kernel_language='Fortran', outdir='./_output', solver_type='classic'): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': riemann_solver = riemann.burgers_1D_py.burgers_1D elif kernel_language == 'Fortran': riemann_solver = riemann.burgers_1D if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(riemann_solver) else: solver = pyclaw.ClawSolver1D(riemann_solver) solver.limiters = pyclaw.limiters.tvd.vanleer solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.custom solver.user_bc_lower = custom_bc solver.bc_upper[0] = pyclaw.BC.custom solver.user_bc_upper = custom_bc x = pyclaw.Dimension(-100.0, 100.0, steps, name='x') domain = pyclaw.Domain(x) num_eqn = 1 state = pyclaw.State(domain, num_eqn) xc = state.grid.x.centers state.q[0, :] = np.exp(-xc**2) state.problem_data['efix'] = True claw = pyclaw.Controller() claw.tfinal = 10.0 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True return claw
def setup(use_petsc=0, outdir='./_output', solver_type='classic', weno_order=5, N=1000): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw riemann_solver = riemann.cubic_1D if solver_type=='sharpclaw': solver = pyclaw.SharpClawSolver1D(riemann_solver) solver.weno_order = weno_order else: solver = pyclaw.ClawSolver1D(riemann_solver) solver.limiters = pyclaw.limiters.tvd.vanleer solver.cfl_max = 1.0 solver.cfl_desired = 0.5 solver.kernel_language = 'Fortran' solver.bc_lower[0] = pyclaw.BC.extrap solver.bc_upper[0] = pyclaw.BC.extrap x = pyclaw.Dimension(-1.0, 3.0, N, name='x') domain = pyclaw.Domain(x) num_eqn = 1 state = pyclaw.State(domain, num_eqn) xc = state.grid.x.centers qL = 4.0 qR = -2.0 state.q[0,:] = (xc < -0.5) * qL + (xc >= -0.5) * qR claw = pyclaw.Controller() claw.tfinal = 0.2 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True return claw
def setup(use_petsc=0,outdir='./_output',solver_type='classic'): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type=='sharpclaw': solver = pyclaw.SharpClawSolver1D(riemann.traffic_1D) else: solver = pyclaw.ClawSolver1D(riemann.traffic_1D) solver.bc_lower[0] = pyclaw.BC.extrap solver.bc_upper[0] = pyclaw.BC.extrap x = pyclaw.Dimension('x',-1.0,1.0,500) domain = pyclaw.Domain(x) num_eqn = 1 state = pyclaw.State(domain,num_eqn) grid = state.grid xc=grid.p_centers[0] state.q[0,:] = 0.75*(xc<0) + 0.1*(xc>0.) state.problem_data['efix']=True state.problem_data['umax']=1. claw = pyclaw.Controller() claw.tfinal =2.0 claw.solution = pyclaw.Solution(state,domain) claw.solver = solver claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True return claw
def setup(use_petsc=False, kernel_language='Fortran', outdir='./_output', solver_type='classic'): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': rs = riemann.shallow_1D_py.shallow_1D elif kernel_language == 'Fortran': rs = riemann.shallow_roe_with_efix_1D if solver_type == 'classic': solver = pyclaw.ClawSolver1D(rs) solver.limiters = pyclaw.limiters.tvd.vanleer elif solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.extrap solver.bc_upper[0] = pyclaw.BC.extrap xlower = -5.0 xupper = 5.0 mx = 500 x = pyclaw.Dimension(xlower, xupper, mx, name='x') domain = pyclaw.Domain(x) state = pyclaw.State(domain, num_eqn) # Gravitational constant state.problem_data['grav'] = 1.0 xc = state.grid.x.centers IC = 'dam-break' x0 = 0. if IC == 'dam-break': hl = 3. ul = 0. hr = 1. ur = 0. state.q[depth, :] = hl * (xc <= x0) + hr * (xc > x0) state.q[momentum, :] = hl * ul * (xc <= x0) + hr * ur * (xc > x0) elif IC == '2-shock': hl = 1. ul = 1. hr = 1. ur = -1. state.q[depth, :] = hl * (xc <= x0) + hr * (xc > x0) state.q[momentum, :] = hl * ul * (xc <= x0) + hr * ur * (xc > x0) elif IC == 'perturbation': eps = 0.1 state.q[depth, :] = 1.0 + eps * np.exp(-(xc - x0)**2 / 0.5) state.q[momentum, :] = 0. claw = pyclaw.Controller() claw.keep_copy = True claw.tfinal = 2.0 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.setplot = setplot return claw
def setup(use_petsc=False, iplot=False, htmlplot=False, outdir='./_output', solver_type='sharpclaw', kernel_language='Fortran', use_char_decomp=False, tfluct_solver=True): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': rs = riemann.euler_1D_py.euler_roe_1D elif kernel_language == 'Fortran': rs = riemann.euler_with_efix_1D if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) solver.time_integrator = 'RK' solver.a, solver.b, solver.c = a, b, c solver.cfl_desired = 0.6 solver.cfl_max = 0.7 if use_char_decomp: try: import sharpclaw1 # Import custom Fortran code solver.fmod = sharpclaw1 solver.tfluct_solver = tfluct_solver # Use total fluctuation solver for efficiency if solver.tfluct_solver: try: import euler_tfluct solver.tfluct = euler_tfluct except ImportError: import logging logger = logging.getLogger() logger.error( 'Unable to load tfluct solver, did you run make?') print 'Unable to load tfluct solver, did you run make?' raise except ImportError: import logging logger = logging.getLogger() logger.error( 'Unable to load sharpclaw1 solver, did you run make?') print 'Unable to load sharpclaw1 solver, did you run make?' pass solver.lim_type = 2 # WENO reconstruction solver.char_decomp = 2 # characteristic-wise reconstruction else: solver = pyclaw.ClawSolver1D(rs) solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.extrap solver.bc_upper[0] = pyclaw.BC.extrap mx = 400 x = pyclaw.Dimension(-5.0, 5.0, mx, name='x') domain = pyclaw.Domain([x]) state = pyclaw.State(domain, num_eqn) state.problem_data['gamma'] = gamma if kernel_language == 'Python': state.problem_data['efix'] = False xc = state.grid.p_centers[0] epsilon = 0.2 velocity = (xc < -4.) * 2.629369 pressure = (xc < -4.) * 10.33333 + (xc >= -4.) * 1. state.q[density, :] = (xc < -4.) * 3.857143 + (xc >= -4.) * ( 1 + epsilon * np.sin(5 * xc)) state.q[momentum, :] = velocity * state.q[density, :] state.q[energy, :] = pressure / ( gamma - 1.) + 0.5 * state.q[density, :] * velocity**2 claw = pyclaw.Controller() claw.tfinal = 1.8 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.num_output_times = 10 claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True return claw
def setup(use_petsc=0,kernel_language='Fortran',solver_type='classic',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$$ """ from clawpack import riemann if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language=='Python': rs = riemann.nonlinear_elasticity_1D_py.nonlinear_elasticity_1D elif kernel_language=='Fortran': rs = riemann.nonlinear_elasticity_fwave_1D if solver_type=='sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) solver.char_decomp=0 else: solver = pyclaw.ClawSolver1D(rs) solver.kernel_language = kernel_language 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_upper 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) state = pyclaw.State(domain,solver.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,xlower=xlower,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 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 return claw
def setup(use_petsc=False, kernel_language='Fortran', solver_type='classic', outdir='./_output', ptwise=False, weno_order=5, time_integrator='SSP104', disable_output=False, output_style=1): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Fortran': if ptwise: riemann_solver = riemann.acoustics_1D_ptwise else: riemann_solver = riemann.acoustics_1D elif kernel_language == 'Python': riemann_solver = riemann.acoustics_1D_py.acoustics_1D if solver_type == 'classic': solver = pyclaw.ClawSolver1D(riemann_solver) solver.limiters = pyclaw.limiters.tvd.MC elif solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(riemann_solver) solver.weno_order = weno_order solver.time_integrator = time_integrator if time_integrator == 'SSPLMMk3': solver.lmm_steps = 4 else: raise Exception('Unrecognized value of solver_type.') solver.kernel_language = kernel_language x = pyclaw.Dimension(0.0, 1.0, 100, name='x') domain = pyclaw.Domain(x) num_eqn = 2 state = pyclaw.State(domain, num_eqn) solver.bc_lower[0] = pyclaw.BC.periodic solver.bc_upper[0] = pyclaw.BC.periodic rho = 1.0 # Material density bulk = 1.0 # Material bulk modulus state.problem_data['rho'] = rho state.problem_data['bulk'] = bulk state.problem_data['zz'] = sqrt(rho * bulk) # Impedance state.problem_data['cc'] = sqrt(bulk / rho) # Sound speed 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.0 solver.dt_initial = domain.grid.delta[0] / state.problem_data['cc'] * 0.1 claw = pyclaw.Controller() claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.output_style = output_style if output_style == 1: claw.tfinal = 1.0 claw.num_output_times = 10 elif output_style == 3: claw.nstep = 1 claw.num_output_times = 1 claw.keep_copy = True if disable_output: claw.output_format = None claw.setplot = setplot return claw
def em1D(mx=1024, num_frames=5, cfl=1.0, outdir='./_output', before_step=True, debug=False, chi3=0.0, chi2=0.0, nl=False, psi=True, em=True, homogeneous=True): import clawpack.petclaw as pyclaw import petsc4py.PETSc as MPI if not homogeneous: if nl: material.chi3_e = chi3 material.chi2_e = chi2 if em: material.chi3_m = chi3 material.chi2_m = chi2 if MPI.COMM_WORLD.rank == 0: material._outdir = outdir source._outdir = outdir material._dump_to_latex() source._dump_to_latex() num_eqn = 2 num_waves = 2 num_aux = 4 # grid pre calculations and domain setup dx, dt, tf = grid_basic(x_lower, x_upper, mx, cfl) x = pyclaw.Dimension('x', x_lower, x_upper, mx) domain = pyclaw.Domain([x]) # Solver settings solver = pyclaw.SharpClawSolver1D() solver.num_waves = num_waves solver.num_eqn = num_eqn solver.weno_order = 5 solver.dt_variable = True solver.dt_initial = dt / 2.0 solver.dt_max = dt solver.max_steps = int(2 * tf / dt) # Set the source if not psi: print 'using dq_src' solver.dq_src = dq_source # Import Riemann and Tfluct solvers if homogeneous: import maxwell_1d_rp else: import maxwell_1d_nl_rp as maxwell_1d_rp solver.tfluct_solver = False solver.fwave = True solver.rp = maxwell_1d_rp if solver.tfluct_solver: if homogeneous: import maxwell_1d_tfluct else: import maxwell_1d_nl_tfluct as maxwell_1d_tfluct solver.tfluct = maxwell_1d_tfluct solver.cfl_max = cfl + 0.05 solver.cfl_desired = cfl # boundary conditions solver.bc_lower[0] = pyclaw.BC.wall solver.bc_upper[0] = pyclaw.BC.wall solver.aux_bc_lower[0] = pyclaw.BC.wall solver.aux_bc_upper[0] = pyclaw.BC.wall solver.reflect_index = [0] # before step configure if before_step: solver.call_before_step_each_stage = True solver.before_step = material.update_aux # state setup state = pyclaw.State(domain, num_eqn, num_aux) state.problem_data['chi2_e'] = material.chi2_e state.problem_data['chi3_e'] = material.chi3_e state.problem_data['chi2_m'] = material.chi2_m state.problem_data['chi3_m'] = material.chi3_m state.problem_data['eo'] = material.eo state.problem_data['mo'] = material.mo state.problem_data['co'] = material.co state.problem_data['zo'] = material.zo state.problem_data['dx'] = state.grid.x.delta state.problem_data['nl'] = nl state.problem_data['psi'] = psi source._dx = state.grid.x.delta material._dx = state.grid.x.delta # array initialization source.init(state) material.init(state) state.q = state.q * state.aux[0:2, :] # controller claw = pyclaw.Controller() claw.tfinal = tf claw.num_output_times = num_frames claw.solver = solver claw.solution = pyclaw.Solution(state, domain) claw.outdir = outdir claw.write_aux_always = True return claw
def setup(use_petsc=False, kernel_language='Fortran', outdir='./_output', solver_type='sharpclaw', riemann_solver='roe', disable_output=False): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': if riemann_solver.lower() == 'roe': raise Exception('Python Roe solver not implemented.') elif riemann_solver.lower() == 'hlle': rs = riemann.shallow_1D_py.shallow_hll_1D elif kernel_language == 'Fortran': if riemann_solver.lower() == 'roe': rs = riemann.shallow_roe_with_efix_1D elif riemann_solver.lower() == 'hlle': rs = riemann.shallow_hlle_1D if solver_type == 'classic': solver = pyclaw.ClawSolver1D(rs) # solver.limiters = pyclaw.limiters.tvd.vanleer elif solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type == 'sharpclaw': solver.dq_src = dq_swe # solver.dq_src = fortran_src_wrapper # use fortran subroutine # solver.call_before_step_each_stage = False # default is False solver.weno_order = 5 solver.lim_type = 2 # weno resonstruction solver.cfl_max = 0.21 solver.cfl_desired = 0.20 else: # solver = pyclaw.ClawSolver2D(riemann.euler_5wave_2D) solver.step_source = step_swe solver.source_split = 1 # Godunov splitting # solver.limiters = [11, 11] # 11 for A-R limiter solver.limiters = [4, 4] # 4 for MC limiter solver.cfl_max = 0.36 solver.cfl_desired = 0.35 # to remove maximum time step restriction using a sufficiently large number solver.max_steps = 1000000000 solver.kernel_language = kernel_language solver.user_bc_lower = incoming_sin solver.bc_lower[0] = pyclaw.BC.custom solver.bc_upper[0] = pyclaw.BC.extrap solver.before_step = b4step x = pyclaw.Dimension(xlower, xupper, mx, name='x') domain = pyclaw.Domain(x) # num_aux = 1 state = pyclaw.State(domain, num_eqn) # Auxiliary array solver.aux_bc_lower[0] = pyclaw.BC.periodic solver.aux_bc_upper[0] = pyclaw.BC.periodic # Gravitational constant state.problem_data['grav'] = 9.81 state.problem_data['dry_tolerance'] = 1e-5 state.problem_data['sea_level'] = 0.0 # xc = state.grid.x.centers # I.C.: normal flow state.q[depth, :] = normal_depth state.q[momentum, :] = normal_velocity * normal_depth # X = state.grid.x.centers # state.p_centers does not work, dont know why # state.aux[0,:] = channel_slope*(1.0 + dist_amp * np.sin(2.0 * np.pi * X/wave_length)) # state.aux[0,:] = bathymetry(X) claw = pyclaw.Controller() claw.keep_copy = True if disable_output: claw.output_format = None claw.output_style = 1 claw.tfinal = sim_time claw.num_output_times = int( sim_time / output_interval) # conversion between two output styles claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.setplot = setplot return claw
def em1D(mx=1024, num_frames=10, use_petsc=True, reconstruction_order=5, lim_type=2, cfl=1.0, conservative=True, chi3=0.0, chi2=0.0, nl=False, psi=True, em=True, before_step=False, debug=False, outdir='./_output', output_style=1): if use_petsc: import clawpack.petclaw as pyclaw import petsc4py.PETSc as MPI else: from clawpack import pyclaw if nl: material.chi3_e = chi3 material.chi2_e = chi2 if em: material.chi3_m = chi3 material.chi2_m = chi2 if np.logical_and(use_petsc, MPI.COMM_WORLD.rank == 0): basics.set_outdirs(material, source, outdir=outdir, debug=debug) else: basics.set_outdirs(material, source, outdir=outdir, debug=debug) num_eqn = 2 num_waves = 2 num_aux = 4 # grid pre calculations and domain setup dx, dt, tf = basics.grid_basic([[x_lower, x_upper, mx]], cfl, material.co, source.v) x = pyclaw.Dimension(x_lower, x_upper, mx, name='x') domain = pyclaw.Domain([x]) # Solver settings solver = pyclaw.SharpClawSolver1D() solver.num_waves = num_waves solver.num_eqn = num_eqn solver.reconstruction_order = 5 solver.lim_type = 2 solver.dt_variable = True solver.dt_initial = dt / 2.0 solver.dt_max = dt solver.max_steps = int(2 * tf / dt) # Import Riemann and Tfluct solvers if conservative: from emclaw.riemann import maxwell_1d_rp else: from emclaw.riemann import maxwell_1d_nc_rp as maxwell_1d_rp solver.tfluct_solver = True solver.fwave = True solver.rp = maxwell_1d_rp if solver.tfluct_solver: if conservative: from emclaw.riemann import maxwell_1d_tfluct else: from emclaw.riemann import maxwell_1d_nc_tfluct as maxwell_1d_tfluct solver.tfluct = maxwell_1d_tfluct solver.cfl_max = cfl + 0.5 solver.cfl_desired = cfl # boundary conditions solver.bc_lower[0] = pyclaw.BC.wall solver.bc_upper[0] = pyclaw.BC.wall solver.aux_bc_lower[0] = pyclaw.BC.wall solver.aux_bc_upper[0] = pyclaw.BC.wall solver.reflect_index = [0] # before step configure if before_step: solver.call_before_step_each_stage = True solver.before_step = material.update_aux # state setup state = pyclaw.State(domain, num_eqn, num_aux) state.problem_data['chi2_e'] = material.chi2_e state.problem_data['chi3_e'] = material.chi3_e state.problem_data['chi2_m'] = material.chi2_m state.problem_data['chi3_m'] = material.chi3_m state.problem_data['eo'] = material.eo state.problem_data['mo'] = material.mo state.problem_data['co'] = material.co state.problem_data['zo'] = material.zo state.problem_data['dx'] = state.grid.x.delta state.problem_data['nl'] = nl state.problem_data['psi'] = psi state.problem_data['conservative'] = conservative source._dx = state.grid.x.delta material._dx = state.grid.x.delta # array initialization source.init(state) material.init(state) if conservative: state.q = state.q * state.aux[0:2, :] # controller claw = pyclaw.Controller() claw.tfinal = tf claw.num_output_times = num_frames claw.solver = solver claw.solution = pyclaw.Solution(state, domain) claw.outdir = outdir claw.write_aux_always = True claw.output_style = output_style return claw
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 clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type=='sharpclaw': solver = pyclaw.SharpClawSolver1D() else: solver = pyclaw.ClawSolver1D() solver.kernel_language = kernel_language from clawpack.riemann import rp_nonlinear_elasticity if kernel_language=='Python': solver.rp = rp_nonlinear_elasticity.rp_nonlinear_elasticity_1d elif kernel_language=='Fortran': from clawpack 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_upper 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,xlower=xlower,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)
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 clawpack.petclaw as pyclaw else: from clawpack 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 clawpack.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 setup(use_petsc=False, outdir='./_output', solver_type='classic', kernel_language='Fortran', disable_output=False): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': raise Exception('Not implemented.') elif kernel_language == 'Fortran': rs = riemann.mhd_roe_1D if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) elif solver_type == 'classic': solver = pyclaw.ClawSolver1D(rs) solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.extrap solver.bc_upper[0] = pyclaw.BC.extrap mx = 800 x = pyclaw.Dimension(-4.0, 4.0, mx, name='x') domain = pyclaw.Domain([x]) state = pyclaw.State(domain, num_eqn) state.problem_data['gamma'] = gamma state.problem_data['gamma1'] = gamma - 1. x = state.grid.x.centers pressure = 1.0 B1_l = 1.5 B1_r = 1.5 B2_l = 0.5 B2_r = 1.6 B3_l = 0.6 B3_r = 0.2 state.q[density, :] = 1.0 state.q[momentum_1, :] = 0.0 state.q[momentum_2, :] = 0.0 state.q[momentum_3, :] = 0.0 state.q[B_1, :] = (x < 0.) * B1_l + (x >= 0.) * B1_r state.q[B_2, :] = (x < 0.) * B2_l + (x >= 0.) * B2_r state.q[B_3, :] = (x < 0.) * B3_l + (x >= 0.) * B3_r state.q[energy, :] = pressure / (gamma - 1.) + 0.5 * ( state.q[momentum_1, :]**2 + state.q[momentum_2, :]**2 + state.q[momentum_3, :]**2) / state.q[density, :] + 0.5 * ( state.q[B_1, :]**2 + state.q[B_2, :]**2 + state.q[B_3, :]**2) claw = pyclaw.Controller() claw.tfinal = 1.0 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.num_output_times = 10 claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True if disable_output: claw.output_format = None return claw
def setup(use_petsc=False, kernel_language='Fortran', solver_type='classic', outdir='./_output', weno_order=5, disable_output=False): """ This example solves the 1-dimensional acoustics equations in a homogeneous medium. """ from numpy import sqrt, exp, cos from clawpack import riemann #================================================================= # Import the appropriate classes, depending on the options passed #================================================================= if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type == 'classic': if kernel_language == 'Fortran': solver = pyclaw.ClawSolver1D(riemann.acoustics_1D) elif kernel_language == 'Python': solver = pyclaw.ClawSolver1D(riemann.acoustics_1D_py.acoustics_1D) elif solver_type == 'sharpclaw': if kernel_language == 'Fortran': solver = pyclaw.SharpClawSolver1D(riemann.acoustics_1D) elif kernel_language == 'Python': solver = pyclaw.SharpClawSolver1D( riemann.acoustics_1D_py.acoustics_1D) 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 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. solver.dt_initial = domain.grid.delta[0] / state.problem_data['cc'] * 0.1 #======================================================================== # Set up the controller object #======================================================================== claw = pyclaw.Controller() claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.keep_copy = True claw.num_output_times = 5 if disable_output: claw.output_format = None claw.tfinal = 1.0 return claw
def setup(use_petsc=False, kernel_language='Python', outdir='./_output', solver_type='classic'): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': rs = riemann.advection_nonlinear_1D_py.advection_nonlinear_1D elif kernel_language == 'Fortran': print('No fortran solver available for advection_nonlinear_1D') pass if solver_type == 'classic': solver = pyclaw.ClawSolver1D(rs) solver.limiters = pyclaw.limiters.tvd.vanleer elif solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.custom solver.bc_upper[0] = pyclaw.BC.custom solver.user_bc_lower = lowerdirichlet solver.user_bc_upper = upperdirichlet xlower = 0.0 xupper = 1.0 mx = 51 x = pyclaw.Dimension(xlower, xupper, mx, name='x') domain = pyclaw.Domain(x) num_eqn = 2 state = pyclaw.State(domain, num_eqn) # Gravitational constant state.problem_data['u_rel'] = np.array([1., 1 / 30.]) state.problem_data['efix'] = False xc = state.grid.x.centers IC = 'dam-break' # IC = 'uniform-all' # IC = 'perturbation' x0 = xc[2] if IC == 'uniform-all': c0 = np.array([0.2, 0.0]) # state defaults to empty. Convert to ones and fill with c0 state.q = np.ones_like(state.q) * c0[:, np.newaxis] elif IC == 'dam-break': # I changed state.is_valid() to always return true for fortran contiguity cr0 = np.array([0.2, 0.0]) cl0 = np.array([0.0, 0.0]) state.q = np.ones_like(state.q) state.q = cl0[:,np.newaxis]*(xc <= x0)[np.newaxis,:] + \ cr0[:,np.newaxis]*(xc > x0)[np.newaxis,:] state.q[0, -1] = 1. # Change these later to reflect initial conditions # elif IC=='2-shock': # hl = 1. # ul = 1. # hr = 1. # ur = -1. # state.q[depth,:] = hl * (xc <= x0) + hr * (xc > x0) # state.q[momentum,:] = hl*ul * (xc <= x0) + hr*ur * (xc > x0) elif IC == 'perturbation': # x1 = x0 x1 = 0.3 x2 = 0.7 eps = 0.1 state.q[0, :] = eps * np.exp(-1 / eps * (xc - x1)**2) state.q[1, :] = eps * np.exp(-1 / eps * (xc - x1)**2) claw = pyclaw.Controller() claw.keep_copy = True claw.num_output_times = 50 claw.tfinal = 10 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.setplot = setplot return claw
def setup(use_petsc=0, kernel_language='Fortran', solver_type='classic', outdir='./_output'): from clawpack import riemann if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': rs = riemann.nonlinear_elasticity_1D_py.nonlinear_elasticity_1D elif kernel_language == 'Fortran': rs = riemann.nonlinear_elasticity_fwave_1D if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) solver.char_decomp = 0 else: solver = pyclaw.ClawSolver1D(rs) solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.custom solver.bc_upper[0] = pyclaw.BC.extrap #Use the same BCs for the aux array solver.aux_bc_lower[0] = pyclaw.BC.extrap solver.aux_bc_upper[0] = pyclaw.BC.extrap xlower = 0.0 xupper = 300.0 cells_per_layer = 12 mx = int(round(xupper - xlower)) * cells_per_layer x = pyclaw.Dimension(xlower, xupper, mx, name='x') domain = pyclaw.Domain(x) state = pyclaw.State(domain, solver.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.1 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'] = 999999999.0 state.problem_data['trdone'] = False #Initialize q and aux xc = state.grid.x.centers state.aux = setaux(xc, rhoB, KB, rhoA, KA, alpha, xlower=xlower, xupper=xupper) qinit(state, ic=1, a2=1.0, xupper=xupper) tfinal = 500. num_output_times = 20 solver.max_steps = 5000000 solver.fwave = True solver.before_step = b4step solver.user_bc_lower = moving_wall_bc solver.user_bc_upper = zero_bc claw = pyclaw.Controller() claw.output_style = 1 claw.num_output_times = num_output_times claw.tfinal = tfinal claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.setplot = setplot claw.keep_copy = True return claw
def setup(use_petsc=False, outdir='./_output', solver_type='sharpclaw', kernel_language='Fortran'): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': rs = riemann.euler_1D_py.euler_roe_1D elif kernel_language == 'Fortran': rs = riemann.euler_with_efix_1D if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) solver.time_integrator = 'SSP33' solver.cfl_max = 0.65 solver.cfl_desired = 0.6 try: import sharpclaw1 solver.fmod = sharpclaw1 solver.tfluct_solver = True solver.lim_type = 1 # TVD reconstruction solver.char_decomp = 2 # characteristic-wise reconstructiong except ImportError: pass elif solver_type == 'classic': solver = pyclaw.ClawSolver1D(rs) solver.limiters = 4 solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.wall solver.bc_upper[0] = pyclaw.BC.wall mx = 800 x = pyclaw.Dimension('x', 0.0, 1.0, mx) domain = pyclaw.Domain([x]) state = pyclaw.State(domain, solver.num_eqn) state.problem_data['gamma'] = gamma state.problem_data['gamma1'] = gamma1 if kernel_language == 'Python': state.problem_data['efix'] = False 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 claw = pyclaw.Controller() claw.tfinal = 0.038 claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.num_output_times = 10 claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True return claw
def setup(use_petsc=False, kernel_language='Fortran', outdir='./_output', solver_type='classic', riemann_solver='roe', disable_output=False): if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if kernel_language == 'Python': if riemann_solver.lower() == 'roe': raise Exception('Python Roe solver not implemented.') elif riemann_solver.lower() == 'hlle': rs = riemann.shallow_1D_py.shallow_hll_1D elif kernel_language == 'Fortran': if riemann_solver.lower() == 'roe': rs = riemann.shallow_roe_with_efix_1D elif riemann_solver.lower() == 'hlle': rs = riemann.shallow_hlle_1D if solver_type == 'classic': solver = pyclaw.ClawSolver1D(rs) solver.limiters = pyclaw.limiters.tvd.vanleer elif solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(rs) if use_petsc: import clawpack.petclaw as pyclaw else: from clawpack import pyclaw if solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver2D(riemann.euler_5wave_2D) solver.dq_src = dq_swe solver.weno_order = 5 solver.lim_type = 2 else: # solver = pyclaw.ClawSolver2D(riemann.euler_5wave_2D) solver.step_source = step_swe solver.source_split = 1 # solver.limiters = [11, 11] # 11 for A-R limiter solver.limiters = [4, 4] # 4 for MC limiter solver.cfl_max = 0.36 solver.cfl_desired = 0.35 solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.periodic solver.bc_upper[0] = pyclaw.BC.periodic x = pyclaw.Dimension(xlower, xupper, mx, name='x') domain = pyclaw.Domain(x) state = pyclaw.State(domain, num_eqn) # Gravitational constant state.problem_data['grav'] = 9.81 state.problem_data['dry_tolerance'] = 1e-5 state.problem_data['sea_level'] = 0.0 xc = state.grid.x.centers # I.C.: spatially varying disturbance state.q[depth, :] = normal_depth * ( 1.0 + dist_amp * np.sin(2.0 * np.pi * xc / wave_length)) state.q[momentum, :] = normal_velocity * normal_depth * ( 1.0 + dist_amp * np.sin(2.0 * np.pi * xc / wave_length)) claw = pyclaw.Controller() claw.keep_copy = True if disable_output: claw.output_format = None claw.output_style = 1 claw.tfinal = sim_time claw.num_output_times = int( sim_time / output_interval) # conversion between two output styles claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.outdir = outdir claw.setplot = setplot return claw