def fig_61_62_63(kernel_language='Python', iplot=False, htmlplot=False, solver_type='classic', outdir='./_output'): """ Compare several methods for advecting a Gaussian and square wave. The settings coded here are for Figure 6.1(a). For Figure 6.1(b), set solver.order=2. For Figure 6.2(a), set solver.order=2 and solver.limiters = pyclaw.limiters.tvd.minmod For Figure 6.2(b), set solver.order=2 and solver.limiters = pyclaw.limiters.tvd.superbee For Figure 6.2(c), set solver.order=2 and solver.limiters = pyclaw.limiters.tvd.MC For Figure 6.3, set IC='wavepacket' and other options as appropriate. """ import numpy as np 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_advection solver.num_waves = rp_advection.num_waves if solver.kernel_language == 'Python': solver.rp = rp_advection.rp_advection_1d solver.bc_lower[0] = 2 solver.bc_upper[0] = 2 solver.limiters = 0 solver.order = 1 solver.cfl_desired = 0.8 x = pyclaw.Dimension('x', 0.0, 1.0, mx) grid = pyclaw.Grid(x) num_eqn = 1 state = pyclaw.State(grid, num_eqn) state.problem_data['u'] = 1. xc = grid.x.center if IC == 'gauss_square': state.q[0, :] = np.exp(-beta * (xc - x0)**2) + (xc > 0.6) * (xc < 0.8) elif IC == 'wavepacket': state.q[0, :] = np.exp(-beta * (xc - x0)**2) * np.sin(80. * xc) else: raise Exception('Unrecognized initial condition specification.') claw = pyclaw.Controller() claw.solution = pyclaw.Solution(state) claw.solver = solver claw.outdir = outdir claw.tfinal = 10.0 status = claw.run() if htmlplot: pyclaw.plot.html_plot(outdir=outdir) if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
def advect_1d(u, qfunc, qkws={}, nx=200, dx=500., t_out=np.arange(0, 3601, 5*60), sharp=True): """ Run a 1D advection calculation via clawpack. CONSTANT U ONLY. """ rp = riemann.advection_1D if sharp: solver = pyclaw.SharpClawSolver1D(rp) solver.weno_order = 5 else: solver = pyclaw.ClawSolver1D(rp) solver.bc_lower[0] = pyclaw.BC.periodic solver.bc_upper[0] = pyclaw.BC.periodic x = pyclaw.Dimension(0, dx*nx, nx, name='x') domain = pyclaw.Domain(x) state = pyclaw.State(domain, solver.num_eqn) state.problem_data['u'] = u x1d = domain.grid.x.centers q = qfunc(x1d, t=0) state.q[0, ...] = q claw = pyclaw.Controller() claw.keep_copy = True claw.solution = pyclaw.Solution(state, domain) claw.solver = solver claw.tfinal = t_out[-1] claw.out_times = t_out claw.num_output_times = len(t_out) - 1 claw.run() times = claw.out_times tracers = [f.q.squeeze() for f in claw.frames] tracers = np.asarray(tracers) uarr = u*np.ones_like(x1d) ds = xr.Dataset( {'q': (('time', 'x'), tracers), 'u': (('x', ), uarr)}, {'time': times, 'x': x1d} ) ds['time'].attrs.update({'long_name': 'time', 'units': 'seconds since 2000-01-01 0:0:0'}) ds['x'].attrs.update({'long_name': 'x-coordinate', 'units': 'm'}) ds['u'].attrs.update({'long_name': 'zonal wind', 'units': 'm/s'}) ds.attrs.update({ 'Conventions': 'CF-1.7' }) return ds
def advection_setup(nx=100, solver_type='classic', lim_type=2, weno_order=5, CFL=0.9, time_integrator='SSP104', outdir='./_output'): riemann_solver = riemann.advection_1D if solver_type == 'classic': solver = pyclaw.ClawSolver1D(riemann_solver) elif solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D(riemann_solver) solver.lim_type = lim_type solver.weno_order = weno_order solver.time_integrator = time_integrator else: raise Exception('Unrecognized value of solver_type.') solver.kernel_language = 'Fortran' solver.cfl_desired = CFL solver.cfl_max = CFL * 1.1 solver.bc_lower[0] = pyclaw.BC.periodic solver.bc_upper[0] = pyclaw.BC.periodic x = pyclaw.Dimension(0.0, 1.0, nx, name='x') 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 return claw
def __init__(self, cparams, dtype_u, dtype_f): """ Initialization routine Args: cparams: custom parameters for the example dtype_u: particle data type (will be passed parent class) dtype_f: acceleration data type (will be passed parent class) """ # these parameters will be used later, so assert their existence assert 'nvars' in cparams assert 'dt' in cparams # add parameters as attributes for further reference for k, v in cparams.items(): setattr(self, k, v) # invoke super init, passing number of dofs, dtype_u and dtype_f super(sharpclaw, self).__init__(self.nvars, dtype_u, dtype_f) riemann_solver = riemann.advection_1D # NOTE: This uses the FORTRAN kernels of clawpack self.solver = pyclaw.SharpClawSolver1D(riemann_solver) self.solver.weno_order = 5 self.solver.time_integrator = 'Euler' # Remove later self.solver.kernel_language = 'Fortran' self.solver.bc_lower[0] = pyclaw.BC.periodic self.solver.bc_upper[0] = pyclaw.BC.periodic self.solver.cfl_max = 1.0 assert self.solver.is_valid() x = pyclaw.Dimension(0.0, 1.0, self.nvars, name='x') self.domain = pyclaw.Domain(x) self.state = pyclaw.State(self.domain, self.solver.num_eqn) self.state.problem_data['u'] = 1.0 self.dx = self.state.grid.x.centers[1] - self.state.grid.x.centers[0] # Initial data u0 = self.u_exact(0.0) self.state.q[0, :] = u0.values solution = pyclaw.Solution(self.state, self.domain) self.solver.setup(solution)
def __init__(self, domain_config, solver_type="sharpclaw", kernel_language="Python"): tau = domain_config["tau"] if kernel_language == "Python": rs = riemann.euler_1D_py.euler_hllc_1D elif kernel_language == "Fortran": rs = riemann.euler_with_efix_1D if solver_type == "sharpclaw": solver = pyclaw.SharpClawSolver1D(rs) solver.dq_src = lambda x, y, z: dq_src(x, y, z, tau) elif solver_type == "classic": solver = pyclaw.ClawSolver1D(rs) solver.step_source = lambda x, y, z: q_src(x, y, z, tau) solver.kernel_language = kernel_language solver.bc_lower[0] = pyclaw.BC.periodic solver.bc_upper[0] = pyclaw.BC.periodic nx = domain_config["nx"] xmin, xmax = domain_config["xmin"], domain_config["xmax"] x = pyclaw.Dimension(xmin, xmax, nx, name="x") domain = pyclaw.Domain([x]) state = pyclaw.State(domain, num_eqn) state.problem_data["gamma"] = gamma state.problem_data["gamma1"] = gamma - 1.0 solution = pyclaw.Solution(state, domain) claw = pyclaw.Controller() claw.solution = solution claw.solver = solver self._solver = solver self._domain = domain self._solution = solution self._claw = claw
def stegoton(rkm, tol, 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$$ """ from clawpack import pyclaw solver = pyclaw.SharpClawSolver1D() solver.time_integrator = 'RK' solver.A = rkm.A solver.b = rkm.b solver.b_hat = rkm.bhat solver.c = rkm.c solver.error_tolerance = tol solver.dt_variable = True solver.cfl_max = 2.5 solver.cfl_desired = 1.5 solver.weno_order = 5 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_lower xlower = 0.0 xupper = 300.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'] = 25000.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) a2 = 1.0 sigma = a2 * np.exp(-((xc - xupper / 2.) / 5.)**2.) state.q[0, :] = np.log(sigma + 1.) / state.aux[1, :] state.q[1, :] = 0. tfinal = 100. num_output_times = 10 solver.max_steps = 5000000 solver.fwave = True solver.num_waves = 2 solver.lim_type = 2 solver.char_decomp = 0 claw = pyclaw.Controller() claw.keep_copy = True claw.output_style = 1 claw.num_output_times = num_output_times claw.tfinal = tfinal claw.solution = pyclaw.Solution(state, domain) claw.solver = solver # Solve status = claw.run() print claw.solver.status['totalsteps'] if htmlplot: pyclaw.plot.html_plot(outdir=outdir) if iplot: pyclaw.plot.interactive_plot(outdir=outdir) epsilon = claw.frames[-1].q[0, :] aux = claw.frames[1].aux from clawpack.riemann.rp_nonlinear_elasticity import sigma stress = sigma(epsilon, aux[1, :]) dx = state.grid.delta[0] work = solver.status['totalsteps'] return stress, dx, work
def fig_31_38(kernel_language='Fortran', solver_type='classic', iplot=False, htmlplot=False, outdir='./_output'): r"""Produces the output shown in Figures 3.1 and 3.8 of the FVM book. These involve simple waves in the acoustics system.""" from clawpack import pyclaw import numpy as np #================================================================= # Import the appropriate solver type, depending on the options passed #================================================================= if solver_type == 'classic': solver = pyclaw.ClawSolver1D() elif solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D() 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.extrap #======================================================================== # Instantiate the grid and set the boundary conditions #======================================================================== x = pyclaw.Dimension('x', -1.0, 1.0, 800) grid = pyclaw.Grid(x) num_eqn = 2 state = pyclaw.State(grid, num_eqn) #======================================================================== # Set problem-specific variables #======================================================================== rho = 1.0 bulk = 0.25 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 beta = 100 gamma = 0 x0 = 0.75 state.q[0, :] = 0.5 * np.exp(-80 * xc**2) + 0.5 * (np.abs(xc + 0.2) < 0.1) state.q[1, :] = 0. #======================================================================== # Set up the controller object #======================================================================== claw = pyclaw.Controller() claw.solution = pyclaw.Solution(state) claw.solver = solver claw.outdir = outdir claw.tfinal = 3.0 claw.num_output_times = 30 # Solve status = claw.run() # Plot results if htmlplot: pyclaw.plot.html_plot(outdir=outdir) if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
def acoustics(solver_type='classic', iplot=True, htmlplot=False, outdir='./_output', problem='figure 9.4'): """ This example solves the 1-dimensional variable-coefficient acoustics equations in a medium with a single interface. """ from numpy import sqrt, abs from clawpack import pyclaw if solver_type == 'classic': solver = pyclaw.ClawSolver1D() elif solver_type == 'sharpclaw': solver = pyclaw.SharpClawSolver1D() else: raise Exception('Unrecognized value of solver_type.') solver.num_waves = 2 solver.limiters = pyclaw.limiters.tvd.MC solver.bc_lower[0] = pyclaw.BC.extrap solver.bc_upper[0] = pyclaw.BC.extrap solver.aux_bc_lower[0] = pyclaw.BC.extrap solver.aux_bc_upper[0] = pyclaw.BC.extrap x = pyclaw.Dimension('x', -5.0, 5.0, 500) grid = pyclaw.Grid(x) num_eqn = 2 num_aux = 2 state = pyclaw.State(grid, num_eqn, num_aux) if problem == 'figure 9.4': rhol = 1.0 cl = 1.0 rhor = 2.0 cr = 0.5 elif problem == 'figure 9.5': rhol = 1.0 cl = 1.0 rhor = 4.0 cr = 0.5 zl = rhol * cl zr = rhor * cr xc = grid.x.center state.aux[0, :] = (xc <= 0) * zl + (xc > 0) * zr # Impedance state.aux[1, :] = (xc <= 0) * cl + (xc > 0) * cr # Sound speed # initial condition: half-ellipse state.q[0, :] = sqrt(abs(1. - (xc + 3.)**2)) * (xc > -4.) * (xc < -2.) state.q[1, :] = state.q[0, :] + 0. claw = pyclaw.Controller() claw.solution = pyclaw.Solution(state) claw.solver = solver claw.tfinal = 5.0 claw.num_output_times = 10 # Solve status = claw.run() # Plot results if htmlplot: pyclaw.plot.html_plot(outdir=outdir) if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
:param p: Pressure :param lambd: Reaction progression \in [0, 1] :return: """ return np.heaviside(p - p_ign, 1) * k * (p/p_cj)**mu * (1 - lambd)**upsilon ## PDE equations # Solvers """Solver""" from clawpack import pyclaw from clawpack import riemann rs = riemann.euler_1D_py.euler_hllc_1D solver = pyclaw.SharpClawSolver1D(rs) solver.kernel_language = 'Python' # Boundary conditions solver.bc_lower[0] = pyclaw.BC.extrap #.wall # Wall in left solver.bc_upper[0] = pyclaw.BC.extrap # non-wall (zero-order extrapolation) condition at the right boundary # Domain mx = 800 x = pyclaw.Dimension(0.0, 0.1, mx, name='x') print(x) domain = pyclaw.Domain([x]) # Solution container solution = pyclaw.Solution(solver.num_eqn, domain)
def setup(use_petsc=False, outdir='./_output', solver_type='classic'): from clawpack import pyclaw import euler_roe_1D import euler_efix_roe_1D 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.weno_order = 5 #solver.lim_type = 2 solver.char_decomp = 1 solver.time_integrator = 'SSP104' else: #solver = pyclaw.ClawSolver1D(euler_roe_1D) solver = pyclaw.ClawSolver1D(euler_efix_roe_1D) solver.bc_lower[0]=pyclaw.BC.extrap solver.bc_upper[0]=pyclaw.BC.extrap solver.order = 1 solver.limiters = 1 solver.num_waves = 3 solver.num_eqn = 3 # Initialize domain mx=400; x = pyclaw.Dimension('x',0.0,4.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 rhol = 1. rhor = 0.125 ul = 0.5 ur = 0.5 pl = 1. pr = 0.1 xs1 = -1. xs2 = 1.25 x =state.grid.x.centers state.q[0,:] = (x>xs1)*(x<xs2)*rhol + ~((x>xs1)*(x<xs2))*rhor state.q[1,:] = (x>xs1)*(x<xs2)*rhol*ul + ~((x>xs1)*(x<xs2))*rhor*ur state.q[2,:] = ((x>xs1)*(x<xs2)*(pl/gamma1 + rhol*ul**2/2) + ~((x>xs1)*(x<xs2))*(pr/gamma1 + rhor*ur**2/2) ) # rhol = 1. # rhor = 0.125 # ul = 0. # ur = 0. # pl = 1. # pr = 0.1 # xs = 0.5 # # x =state.grid.x.centers # state.q[0,:] = (x<xs)*rhol + (x>=xs)*rhor # state.q[1,:] = (x<xs)*rhol*ul + (x>=xs)*rhor*ur # state.q[2,:] = (x<xs)*(pl/gamma1 + rhol*ul**2/2) + (x>=xs)*(pr/gamma1 + rhor*ur**2/2) ## claw = pyclaw.Controller() claw.tfinal = 2. claw.solution = pyclaw.Solution(state,domain) claw.solver = solver claw.num_output_times = 10 claw.outdir = outdir claw.setplot = setplot claw.keep_copy = True #state.mp = 1 #claw.compute_p = pressure #claw.write_aux_always = 'True' 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: from . 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: from . 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