Example #1
0
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 petclaw as pyclaw
    else:
        import pyclaw

    if solver_type == 'sharpclaw':
        solver = pyclaw.SharpClawSolver1D()
    else:
        solver = pyclaw.ClawSolver1D()

    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
Example #2
0
def burgers(use_petsc=0,kernel_language='Fortran',iplot=0,htmlplot=0,outdir='./_output',solver_type='classic'):
    """
    Example python script for solving the 1d Burgers equation.
    """

    import numpy as np

    if use_petsc:
        import petclaw as pyclaw
    else:
        import pyclaw

    #===========================================================================
    # Setup solver and solver parameters
    #===========================================================================
    if solver_type=='sharpclaw':
        solver = pyclaw.SharpClawSolver1D()
    else:
        solver = pyclaw.ClawSolver1D()
        solver.limiters = pyclaw.limiters.tvd.vanleer

    solver.kernel_language = kernel_language
    if kernel_language=='Python': 
        solver.set_riemann_solver('burgers')
    elif kernel_language=='Fortran':
        import riemann
        solver.rp = riemann.rp1_burgers
        
    solver.num_waves = 1
    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

    status = claw.run()

    if htmlplot:  pyclaw.plot.html_plot(outdir=outdir)
    if iplot:     pyclaw.plot.interactive_plot(outdir=outdir)
Example #3
0
def advection(kernel_language='Python',
              iplot=False,
              htmlplot=False,
              use_petsc=False,
              solver_type='classic',
              outdir='./_output'):
    """
    Example python script for solving the 1d advection equation.
    """
    import numpy as np

    if use_petsc:
        import petclaw as pyclaw
    else:
        import pyclaw

    if solver_type == 'sharpclaw':
        solver = pyclaw.SharpClawSolver1D()
    else:
        solver = pyclaw.ClawSolver1D()

    solver.kernel_language = kernel_language
    from riemann import rp_advection
    solver.num_waves = rp_advection.num_waves
    if solver.kernel_language == 'Python':
        solver.rp = rp_advection.rp_advection_1d
    else:
        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.solution = pyclaw.Solution(state, domain)
    claw.solver = solver
    claw.outdir = outdir

    claw.tfinal = 1.0
    status = claw.run()

    if htmlplot: pyclaw.plot.html_plot(outdir=outdir)
    if iplot: pyclaw.plot.interactive_plot(outdir=outdir)
Example #4
0
def vc_advection(use_petsc=False,
                 solver_type='classic',
                 kernel_language='Python',
                 iplot=False,
                 htmlplot=False,
                 outdir='./_output'):

    if use_petsc:
        import petclaw as pyclaw
    else:
        import pyclaw

    if solver_type == 'sharpclaw':
        solver = pyclaw.SharpClawSolver1D()
    else:
        solver = pyclaw.ClawSolver1D()

    solver.kernel_language = kernel_language
    from riemann import rp_vc_advection
    solver.num_waves = rp_vc_advection.num_waves
    if solver.kernel_language == 'Python':
        solver.rp = rp_vc_advection.rp_vc_advection_1d
    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 vc_advection(use_petsc=False,solver_type='classic',kernel_language='Python',iplot=False,htmlplot=False,outdir='./_output'):

    if use_petsc:
        import petclaw as pyclaw
    else:
        import pyclaw

    if solver_type=='sharpclaw':
        solver = pyclaw.SharpClawSolver1D()
    else:
        solver = pyclaw.ClawSolver1D()

    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)
Example #6
0
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.
    """
    from numpy import sqrt, exp, cos
    from riemann import rp1_acoustics

    #=================================================================
    # Import the appropriate classes, depending on the options passed
    #=================================================================
    if use_petsc:
        import petclaw as pyclaw
    else:
        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 riemann import rp_acoustics
    solver.num_waves=rp_acoustics.num_waves

    if kernel_language=='Python': 
        solver.rp = rp_acoustics.rp_acoustics_1d
    else:
        from riemann import rp1_acoustics
        solver.rp = rp1_acoustics

    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.
    
    #========================================================================
    # Set up the controller object
    #========================================================================
    claw = pyclaw.Controller()
    claw.solution = pyclaw.Solution(state,domain)
    claw.solver = solver
    claw.outdir = outdir
    claw.tfinal = 1.0

    # Solve
    status = claw.run()

    # Plot results
    if htmlplot:  pyclaw.plot.html_plot(outdir=outdir)
    if iplot:     pyclaw.plot.interactive_plot(outdir=outdir)
Example #7
0
def shallow1D(use_petsc=False,
              kernel_language='Fortran',
              iplot=False,
              htmlplot=False,
              outdir='./_output',
              solver_type='classic'):
    #===========================================================================
    # Import libraries
    #===========================================================================
    import numpy as np

    if use_petsc:
        import petclaw as pyclaw
    else:
        import pyclaw

    if solver_type == 'classic':
        solver = pyclaw.ClawSolver1D()
        solver.limiters = pyclaw.limiters.tvd.vanleer
    elif solver_type == 'sharpclaw':
        solver = pyclaw.SharpClawSolver1D()

    #===========================================================================
    # Setup solver and solver parameters
    #===========================================================================
    solver.num_waves = 2
    solver.kernel_language = kernel_language
    if kernel_language == 'Python':
        solver.set_riemann_solver('shallow_roe')
        solver.problem_data['g'] = 1.0
        solver.problem_data['efix'] = False
    elif kernel_language == 'Fortran':
        import riemann
        solver.rp = riemann.rp1_shallow_roe_with_efix

    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
    #===========================================================================
    xlower = -5.0
    xupper = 5.0
    mx = 500
    x = pyclaw.Dimension('x', xlower, xupper, mx)
    domain = pyclaw.Domain(x)
    num_eqn = 2
    state = pyclaw.State(domain, num_eqn)

    # Parameters
    state.problem_data['grav'] = 1.0

    xc = state.grid.x.centers

    IC = '2-shock'
    x0 = 0.

    if IC == 'dam-break':
        hl = 3.
        ul = 0.
        hr = 1.
        ur = 0.
        state.q[0, :] = hl * (xc <= x0) + hr * (xc > x0)
        state.q[1, :] = hl * ul * (xc <= x0) + hr * ur * (xc > x0)
    elif IC == '2-shock':
        hl = 1.
        ul = 1.
        hr = 1.
        ur = -1.
        state.q[0, :] = hl * (xc <= x0) + hr * (xc > x0)
        state.q[1, :] = hl * ul * (xc <= x0) + hr * ur * (xc > x0)
    elif IC == 'perturbation':
        eps = 0.1
        state.q[0, :] = 1.0 + eps * np.exp(-(xc - x0)**2 / 0.5)
        state.q[1, :] = 0.

    #===========================================================================
    # Setup controller and controller paramters
    #===========================================================================
    claw = pyclaw.Controller()
    claw.keep_copy = True
    claw.tfinal = 2.0
    claw.solution = pyclaw.Solution(state, domain)
    claw.solver = solver
    claw.outdir = outdir

    #===========================================================================
    # Solve the problem
    #===========================================================================
    status = claw.run()

    #===========================================================================
    # Plot results
    #===========================================================================
    if iplot:
        pyclaw.plot.interactive_plot(outdir=outdir,
                                     file_format=claw.output_format)
    if htmlplot:
        pyclaw.plot.html_plot(outdir=outdir, file_format=claw.output_format)
Example #8
0
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 petclaw as pyclaw
    else:
        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 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)
Example #9
0
def acoustics(use_petsc=True,
              kernel_language='Fortran',
              solver_type='classic',
              iplot=False,
              htmlplot=False,
              outdir='./_output',
              weno_order=5):
    import numpy as np
    """
    1D acoustics example.
    """

    output_format = None  #Suppress output to make tests faster
    if use_petsc:
        import petclaw as pyclaw
    else:  #Pure pyclaw
        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.')

    # Initialize patches and solution
    x = pyclaw.Dimension('x', 0.0, 1.0, 100)
    domain = pyclaw.Domain(x)
    num_eqn = 2
    state = pyclaw.State(domain, num_eqn)

    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(rho / bulk)

    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))
    state.q[1, :] = 0.

    init_solution = pyclaw.Solution(state, domain)

    solver.num_waves = 2
    solver.kernel_language = kernel_language

    if kernel_language == 'Python':
        from riemann import rp_acoustics
        solver.rp = rp_acoustics.rp_acoustics_1d

    solver.limiters = [4] * solver.num_waves
    solver.dt_initial = grid.delta[0] / state.problem_data['cc'] * 0.1
    solver.bc_lower[0] = pyclaw.BC.periodic
    solver.bc_upper[0] = pyclaw.BC.periodic

    claw = pyclaw.Controller()
    claw.keep_copy = True
    claw.num_output_times = 5

    claw.output_format = output_format

    claw.outdir = outdir
    claw.tfinal = 1.0
    claw.solution = init_solution
    claw.solver = solver

    # Solve
    status = claw.run()

    #This test is set up so that the waves pass through the domain
    #exactly once, and the final solution should be equal to the
    #initial condition.  Here we output the 1-norm of their difference.
    if use_petsc == True:
        q0 = claw.frames[0].state.gqVec.getArray().reshape([-1])
        qfinal = claw.frames[
            claw.num_output_times].state.gqVec.getArray().reshape([-1])
    else:
        q0 = claw.frames[0].state.q.reshape([-1])
        qfinal = claw.frames[claw.num_output_times].state.q.reshape([-1])
    dx = claw.solution.domain.delta[0]

    return dx * np.sum(np.abs(qfinal - q0))
Example #10
0
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 petclaw as pyclaw
    else:
        import pyclaw

    if solver_type == 'sharpclaw':
        solver = pyclaw.SharpClawSolver1D()
    else:
        solver = pyclaw.ClawSolver1D()

    solver.kernel_language = kernel_language
    if kernel_language == 'Python':
        solver.set_riemann_solver('nonlinear_elasticity')
    elif kernel_language == 'Fortran':
        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 = 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,
                       solver.aux_bc_lower[0],
                       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)