def main(ctx_factory, dim=2, order=4, visualize=False):
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
# {{{ parameters
# domain [-d/2, d/2]^dim
d = 1.0
# number of points in each dimension
npoints = 20
# grid spacing
h = d / npoints
# cfl
dt_factor = 2.0
# final time
final_time = 1.0
# compute number of steps
dt = dt_factor * h / order**2
nsteps = int(final_time // dt) + 1
dt = final_time / nsteps + 1.0e-15
# velocity field
c = np.array([0.5] * dim)
norm_c = la.norm(c)
# flux
flux_type = "central"
# }}}
# {{{ discretization
from meshmode.mesh.generation import generate_box_mesh
mesh = generate_box_mesh(
[np.linspace(-d / 2, d / 2, npoints) for _ in range(dim)], order=order)
from grudge import DiscretizationCollection
discr = DiscretizationCollection(actx, mesh, order=order)
# }}}
# {{{ symbolic operators
def f(x):
return sym.sin(3 * x)
def u_analytic(x):
t = sym.var("t", dof_desc.DD_SCALAR)
return f(-np.dot(c, x) / norm_c + t * norm_c)
from grudge.models.advection import WeakAdvectionOperator
op = WeakAdvectionOperator(c,
inflow_u=u_analytic(sym.nodes(dim, BTAG_ALL)),
flux_type=flux_type)
bound_op = bind(discr, op.sym_operator())
u = bind(discr, u_analytic(sym.nodes(dim)))(actx, t=0)
def rhs(t, u):
return bound_op(t=t, u=u)
# }}}
# {{{ time stepping
from grudge.shortcuts import set_up_rk4
dt_stepper = set_up_rk4("u", dt, u, rhs)
plot = Plotter(actx, discr, order, visualize=visualize, ylim=[-1.1, 1.1])
norm = bind(discr, sym.norm(2, sym.var("u")))
step = 0
norm_u = 0.0
for event in dt_stepper.run(t_end=final_time):
if not isinstance(event, dt_stepper.StateComputed):
continue
if step % 10 == 0:
norm_u = norm(u=event.state_component)
plot(event, "fld-weak-%04d" % step)
step += 1
logger.info("[%04d] t = %.5f |u| = %.5e", step, event.t, norm_u)
def main(write_output=True, order=4):
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
dim = 2
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(-0.5, -0.5),
b=(0.5, 0.5),
n=(20, 20),
order=order)
dt_factor = 4
h = 1 / 20
discr = DGDiscretizationWithBoundaries(cl_ctx, mesh, order=order)
c = np.array([0.1, 0.1])
norm_c = la.norm(c)
flux_type = "central"
def f(x):
return sym.sin(3 * x)
def u_analytic(x):
return f(-np.dot(c, x) / norm_c + sym.var("t", sym.DD_SCALAR) * norm_c)
from grudge.models.advection import WeakAdvectionOperator
discr = DGDiscretizationWithBoundaries(cl_ctx, mesh, order=order)
op = WeakAdvectionOperator(c,
inflow_u=u_analytic(sym.nodes(
dim, sym.BTAG_ALL)),
flux_type=flux_type)
bound_op = bind(discr, op.sym_operator())
u = bind(discr, u_analytic(sym.nodes(dim)))(queue, t=0)
def rhs(t, u):
return bound_op(queue, t=t, u=u)
final_time = 0.3
dt = dt_factor * h / order**2
nsteps = (final_time // dt) + 1
dt = final_time / nsteps + 1e-15
from grudge.shortcuts import set_up_rk4
dt_stepper = set_up_rk4("u", dt, u, rhs)
from grudge.shortcuts import make_visualizer
vis = make_visualizer(discr, vis_order=order)
step = 0
for event in dt_stepper.run(t_end=final_time):
if isinstance(event, dt_stepper.StateComputed):
step += 1
#print(step, event.t, norm(queue, u=event.state_component[0]))
vis.write_vtk_file("fld-weak-%04d.vtu" % step,
[("u", event.state_component)])