def main(dims, write_output=True, order=4):
cl_ctx = cl.create_some_context()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(0.0, ) * dims,
b=(1.0, ) * dims,
nelements_per_axis=(4, ) * dims)
discr = DiscretizationCollection(actx, mesh, order=order)
if 0:
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4 * np.pi * 1e-7 # N/A**2.
epsilon = 1 * epsilon0
mu = 1 * mu0
else:
epsilon = 1
mu = 1
from grudge.models.em import MaxwellOperator
op = MaxwellOperator(epsilon, mu, flux_type=0.5, dimensions=dims)
if dims == 3:
sym_mode = get_rectangular_cavity_mode(1, (1, 2, 2))
fields = bind(discr, sym_mode)(actx, t=0, epsilon=epsilon, mu=mu)
else:
sym_mode = get_rectangular_cavity_mode(1, (2, 3))
fields = bind(discr, sym_mode)(actx, t=0)
# FIXME
#dt = op.estimate_rk4_timestep(discr, fields=fields)
op.check_bc_coverage(mesh)
# print(sym.pretty(op.sym_operator()))
bound_op = bind(discr, op.sym_operator())
def rhs(t, w):
return bound_op(t=t, w=w)
if mesh.dim == 2:
dt = 0.004
elif mesh.dim == 3:
dt = 0.002
dt_stepper = set_up_rk4("w", dt, fields, rhs)
final_t = dt * STEPS
nsteps = int(final_t / dt)
print("dt=%g nsteps=%d" % (dt, nsteps))
from grudge.shortcuts import make_visualizer
vis = make_visualizer(discr)
step = 0
norm = bind(discr, sym.norm(2, sym.var("u")))
from time import time
t_last_step = time()
e, h = op.split_eh(fields)
if 1:
vis.write_vtk_file("fld-cavities-%04d.vtu" % step, [
("e", e),
("h", h),
])
for event in dt_stepper.run(t_end=final_t):
if isinstance(event, dt_stepper.StateComputed):
assert event.component_id == "w"
step += 1
print(step, event.t, norm(u=e[0]), norm(u=e[1]), norm(u=h[0]),
norm(u=h[1]),
time() - t_last_step)
if step % 10 == 0:
e, h = op.split_eh(event.state_component)
vis.write_vtk_file("fld-cavities-%04d.vtu" % step, [
("e", e),
("h", h),
])
t_last_step = time()
def main(ctx_factory, dim=3, order=4, visualize=False):
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(
queue,
allocator=cl_tools.MemoryPool(cl_tools.ImmediateAllocator(queue)),
force_device_scalars=True,
)
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(0.0, ) * dim,
b=(1.0, ) * dim,
nelements_per_axis=(4, ) * dim)
dcoll = DiscretizationCollection(actx, mesh, order=order)
if 0:
epsilon0 = 8.8541878176e-12 # C**2 / (N m**2)
mu0 = 4 * np.pi * 1e-7 # N/A**2.
epsilon = 1 * epsilon0
mu = 1 * mu0
else:
epsilon = 1
mu = 1
from grudge.models.em import MaxwellOperator
maxwell_operator = MaxwellOperator(dcoll,
epsilon,
mu,
flux_type=0.5,
dimensions=dim)
def cavity_mode(x, t=0):
if dim == 3:
return get_rectangular_cavity_mode(actx, x, t, 1, (1, 2, 2))
else:
return get_rectangular_cavity_mode(actx, x, t, 1, (2, 3))
fields = cavity_mode(thaw(dcoll.nodes(), actx), t=0)
maxwell_operator.check_bc_coverage(mesh)
def rhs(t, w):
return maxwell_operator.operator(t, w)
dt = maxwell_operator.estimate_rk4_timestep(actx, dcoll, fields=fields)
dt_stepper = set_up_rk4("w", dt, fields, rhs)
target_steps = 60
final_t = dt * target_steps
nsteps = int(final_t / dt) + 1
logger.info("dt = %g nsteps = %d", dt, nsteps)
from grudge.shortcuts import make_visualizer
vis = make_visualizer(dcoll)
step = 0
def norm(u):
return op.norm(dcoll, u, 2)
e, h = maxwell_operator.split_eh(fields)
if visualize:
vis.write_vtk_file(f"fld-cavities-{step:04d}.vtu", [
("e", e),
("h", h),
])
for event in dt_stepper.run(t_end=final_t):
if isinstance(event, dt_stepper.StateComputed):
assert event.component_id == "w"
step += 1
e, h = maxwell_operator.split_eh(event.state_component)
norm_e0 = actx.to_numpy(norm(u=e[0]))
norm_e1 = actx.to_numpy(norm(u=e[1]))
norm_h0 = actx.to_numpy(norm(u=h[0]))
norm_h1 = actx.to_numpy(norm(u=h[1]))
logger.info(
"[%04d] t = %.5f |e0| = %.5e, |e1| = %.5e, |h0| = %.5e, |h1| = %.5e",
step, event.t, norm_e0, norm_e1, norm_h0, norm_h1)
if step % 10 == 0:
if visualize:
vis.write_vtk_file(f"fld-cavities-{step:04d}.vtu", [
("e", e),
("h", h),
])
# NOTE: These are here to ensure the solution is bounded for the
# time interval specified
assert norm_e0 < 0.5
assert norm_e1 < 0.5
assert norm_h0 < 0.5
assert norm_h1 < 0.5