def all_refine(num_mesh, depth, fname):
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron, generate_torus,
generate_regular_rect_mesh, generate_box_mesh)
import timeit
nelements = []
runtimes = []
for el_fact in range(2, num_mesh + 2):
mesh = generate_box_mesh(3 * (np.linspace(0, 1, el_fact), ))
r = Refiner(mesh)
for time in range(depth):
flags = np.ones(len(mesh.groups[0].vertex_indices))
if time < depth - 1:
mesh = r.refine(flags)
else:
start = timeit.default_timer()
mesh = r.refine(flags)
stop = timeit.default_timer()
nelements.append(mesh.nelements)
runtimes.append(stop - start)
check_nodal_adj_against_geometry(mesh)
import matplotlib.pyplot as pt
pt.plot(nelements, runtimes, "o")
pt.savefig(fname)
pt.clf()
def all_refine(num_mesh, depth, fname):
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron,
generate_torus, generate_regular_rect_mesh,
generate_box_mesh)
import timeit
nelements = []
runtimes = []
for el_fact in range(2, num_mesh+2):
mesh = generate_box_mesh(3*(np.linspace(0, 1, el_fact),))
r = Refiner(mesh)
for time in range(depth):
flags = np.ones(len(mesh.groups[0].vertex_indices))
if time < depth-1:
mesh = r.refine(flags)
else:
start = timeit.default_timer()
mesh = r.refine(flags)
stop = timeit.default_timer()
nelements.append(mesh.nelements)
runtimes.append(stop-start)
check_nodal_adj_against_geometry(mesh)
import matplotlib.pyplot as pt
pt.plot(nelements, runtimes, "o")
pt.savefig(fname)
pt.clf()
def main2():
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron, generate_torus,
generate_regular_rect_mesh, generate_box_mesh)
# mesh = generate_icosphere(1, order=order)
#mesh = generate_icosahedron(1, order=order)
#mesh = generate_torus(3, 1, order=order)
#mesh = generate_regular_rect_mesh()
#mesh = generate_box_mesh(3*(np.linspace(0, 3, 5),))
#mesh = generate_box_mesh(3*(np.linspace(0, 1, 3),))
mesh = generate_box_mesh(3 * (np.linspace(0, 1, 5), ))
refine_and_generate_chart_function(mesh, "plot.pdf", sine_func)
def test_box_mesh(actx_factory, visualize=False):
mesh = mgen.generate_box_mesh(3 * (np.linspace(0, 1, 5), ))
if visualize:
from meshmode.discretization import Discretization
actx = actx_factory()
discr = Discretization(actx, mesh,
PolynomialWarpAndBlendGroupFactory(7))
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(actx, discr, 7)
vis.write_vtk_file("box_mesh.vtu", [])
def main2():
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron,
generate_torus, generate_regular_rect_mesh,
generate_box_mesh)
# mesh = generate_icosphere(1, order=order)
#mesh = generate_icosahedron(1, order=order)
#mesh = generate_torus(3, 1, order=order)
#mesh = generate_regular_rect_mesh()
#mesh = generate_box_mesh(3*(np.linspace(0, 3, 5),))
#mesh = generate_box_mesh(3*(np.linspace(0, 1, 3),))
mesh = generate_box_mesh(3*(np.linspace(0, 1, 5),))
refine_and_generate_chart_function(mesh, "plot.pdf", sine_func)
def test_merge_and_map(ctx_factory, visualize=False):
from meshmode.mesh.io import generate_gmsh, FileSource
from meshmode.mesh.generation import generate_box_mesh
from meshmode.mesh import TensorProductElementGroup
from meshmode.discretization.poly_element import (
PolynomialWarpAndBlendGroupFactory,
LegendreGaussLobattoTensorProductGroupFactory)
mesh_order = 3
if 1:
mesh = generate_gmsh(
FileSource("blob-2d.step"),
2,
order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.02;"])
discr_grp_factory = PolynomialWarpAndBlendGroupFactory(3)
else:
mesh = generate_box_mesh((
np.linspace(0, 1, 4),
np.linspace(0, 1, 4),
np.linspace(0, 1, 4),
),
10,
group_factory=TensorProductElementGroup)
discr_grp_factory = LegendreGaussLobattoTensorProductGroupFactory(3)
from meshmode.mesh.processing import merge_disjoint_meshes, affine_map
mesh2 = affine_map(mesh,
A=np.eye(mesh.ambient_dim),
b=np.array([5, 0, 0])[:mesh.ambient_dim])
mesh3 = merge_disjoint_meshes((mesh2, mesh))
mesh3.facial_adjacency_groups
mesh3.copy()
if visualize:
from meshmode.discretization import Discretization
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
discr = Discretization(cl_ctx, mesh3, discr_grp_factory)
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, 3, element_shrink_factor=0.8)
vis.write_vtk_file("merged.vtu", [])
def test_quad_multi_element(visualize=False):
mesh = mgen.generate_box_mesh((
np.linspace(3, 8, 4),
np.linspace(3, 8, 4),
np.linspace(3, 8, 4),
),
10,
group_cls=TensorProductElementGroup)
if visualize:
import matplotlib.pyplot as plt
mg = mesh.groups[0]
plt.plot(mg.nodes[0].reshape(-1), mg.nodes[1].reshape(-1), "o")
plt.show()
def test_merge_and_map(ctx_factory, visualize=False):
from meshmode.mesh.io import generate_gmsh, FileSource
from meshmode.mesh.generation import generate_box_mesh
from meshmode.mesh import TensorProductElementGroup
from meshmode.discretization.poly_element import (
PolynomialWarpAndBlendGroupFactory,
LegendreGaussLobattoTensorProductGroupFactory)
mesh_order = 3
if 1:
mesh = generate_gmsh(
FileSource("blob-2d.step"), 2, order=mesh_order,
force_ambient_dim=2,
other_options=["-string", "Mesh.CharacteristicLengthMax = 0.02;"]
)
discr_grp_factory = PolynomialWarpAndBlendGroupFactory(3)
else:
mesh = generate_box_mesh(
(
np.linspace(0, 1, 4),
np.linspace(0, 1, 4),
np.linspace(0, 1, 4),
),
10, group_factory=TensorProductElementGroup)
discr_grp_factory = LegendreGaussLobattoTensorProductGroupFactory(3)
from meshmode.mesh.processing import merge_disjoint_meshes, affine_map
mesh2 = affine_map(mesh,
A=np.eye(mesh.ambient_dim),
b=np.array([5, 0, 0])[:mesh.ambient_dim])
mesh3 = merge_disjoint_meshes((mesh2, mesh))
mesh3.facial_adjacency_groups
mesh3.copy()
if visualize:
from meshmode.discretization import Discretization
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
discr = Discretization(cl_ctx, mesh3, discr_grp_factory)
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, 3, element_shrink_factor=0.8)
vis.write_vtk_file("merged.vtu", [])
def test_quad_multi_element():
from meshmode.mesh.generation import generate_box_mesh
from meshmode.mesh import TensorProductElementGroup
mesh = generate_box_mesh((
np.linspace(3, 8, 4),
np.linspace(3, 8, 4),
np.linspace(3, 8, 4),
),
10,
group_factory=TensorProductElementGroup)
if 0:
import matplotlib.pyplot as plt
mg = mesh.groups[0]
plt.plot(mg.nodes[0].reshape(-1), mg.nodes[1].reshape(-1), "o")
plt.show()
def test_box_mesh(ctx_getter, visualize=False):
from meshmode.mesh.generation import generate_box_mesh
mesh = generate_box_mesh(3*(np.linspace(0, 1, 5),))
if visualize:
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
PolynomialWarpAndBlendGroupFactory
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
discr = Discretization(cl_ctx, mesh,
PolynomialWarpAndBlendGroupFactory(1))
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, 1)
vis.write_vtk_file("box.vtu", [])
def test_mesh_as_python():
mesh = mgen.generate_box_mesh(3 * (np.linspace(0, 1, 5), ))
# These implicitly compute these adjacency structures.
assert mesh.nodal_adjacency
assert mesh.facial_adjacency_groups
from meshmode.mesh import as_python
code = as_python(mesh)
print(code)
exec_dict = {}
exec(compile(code, "gen_code.py", "exec"), exec_dict)
mesh_2 = exec_dict["make_mesh"]()
assert mesh == mesh_2
def test_box_mesh(ctx_getter, visualize=False):
from meshmode.mesh.generation import generate_box_mesh
mesh = generate_box_mesh(3 * (np.linspace(0, 1, 5), ))
if visualize:
from meshmode.discretization import Discretization
from meshmode.discretization.poly_element import \
PolynomialWarpAndBlendGroupFactory
cl_ctx = ctx_getter()
queue = cl.CommandQueue(cl_ctx)
discr = Discretization(cl_ctx, mesh,
PolynomialWarpAndBlendGroupFactory(1))
from meshmode.discretization.visualization import make_visualizer
vis = make_visualizer(queue, discr, 1)
vis.write_vtk_file("box.vtu", [])
def uniform_refine(num_mesh, fract, depth, fname):
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron,
generate_torus, generate_regular_rect_mesh,
generate_box_mesh)
import timeit
nelements = []
runtimes = []
for el_fact in range(2, num_mesh+2):
mesh = generate_box_mesh(3*(np.linspace(0, 1, el_fact),))
r = Refiner(mesh)
all_els = list(range(mesh.nelements))
for time in range(depth):
print("EL_FACT", el_fact, "TIME", time)
flags = np.zeros(mesh.nelements)
from random import shuffle, seed
seed(1)
shuffle(all_els)
nels_this_round = 0
for i in range(len(all_els)):
if i / len(flags) > fract:
break
flags[all_els[i]] = 1
nels_this_round += 1
if time < depth-1:
mesh = r.refine(flags)
else:
start = timeit.default_timer()
mesh = r.refine(flags)
stop = timeit.default_timer()
nelements.append(mesh.nelements)
runtimes.append(stop-start)
all_els = []
for i in range(len(flags)):
if flags[i]:
all_els.append(i)
for i in range(len(flags), mesh.nelements):
all_els.append(i)
check_nodal_adj_against_geometry(mesh)
import matplotlib.pyplot as pt
pt.plot(nelements, runtimes, "o")
pt.savefig(fname)
pt.clf()
def uniform_refine(num_mesh, fract, depth, fname):
from meshmode.mesh.generation import ( # noqa
generate_icosphere, generate_icosahedron,
generate_torus, generate_regular_rect_mesh,
generate_box_mesh)
import timeit
nelements = []
runtimes = []
for el_fact in range(2, num_mesh+2):
mesh = generate_box_mesh(3*(np.linspace(0, 1, el_fact),))
r = Refiner(mesh)
all_els = list(range(mesh.nelements))
for time in range(depth):
print("EL_FACT", el_fact, "TIME", time)
flags = np.zeros(mesh.nelements)
from random import shuffle, seed
seed(1)
shuffle(all_els)
nels_this_round = 0
for i in range(len(all_els)):
if i / len(flags) > fract:
break
flags[all_els[i]] = 1
nels_this_round += 1
if time < depth-1:
mesh = r.refine(flags)
else:
start = timeit.default_timer()
mesh = r.refine(flags)
stop = timeit.default_timer()
nelements.append(mesh.nelements)
runtimes.append(stop-start)
all_els = []
for i in range(len(flags)):
if flags[i]:
all_els.append(i)
for i in range(len(flags), mesh.nelements):
all_els.append(i)
check_nodal_adj_against_geometry(mesh)
import matplotlib.pyplot as pt
pt.plot(nelements, runtimes, "o")
pt.savefig(fname)
pt.clf()
def test_quad_multi_element():
from meshmode.mesh.generation import generate_box_mesh
from meshmode.mesh import TensorProductElementGroup
mesh = generate_box_mesh(
(
np.linspace(3, 8, 4),
np.linspace(3, 8, 4),
np.linspace(3, 8, 4),
),
10, group_factory=TensorProductElementGroup)
if 0:
import matplotlib.pyplot as plt
mg = mesh.groups[0]
plt.plot(
mg.nodes[0].reshape(-1),
mg.nodes[1].reshape(-1), "o")
plt.show()
def test_as_python():
from meshmode.mesh.generation import generate_box_mesh
mesh = generate_box_mesh(3*(np.linspace(0, 1, 5),))
# These implicitly compute these adjacency structures.
mesh.nodal_adjacency
mesh.facial_adjacency_groups
from meshmode.mesh import as_python
code = as_python(mesh)
print(code)
exec_dict = {}
exec(compile(code, "gen_code.py", "exec"), exec_dict)
mesh_2 = exec_dict["make_mesh"]()
assert mesh == mesh_2
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 test_convergence_advec(ctx_factory,
mesh_name,
mesh_pars,
op_type,
flux_type,
order,
visualize=False):
"""Test whether 2D advection actually converges"""
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
actx = PyOpenCLArrayContext(queue)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
for mesh_par in mesh_pars:
if mesh_name == "segment":
from meshmode.mesh.generation import generate_box_mesh
mesh = generate_box_mesh([np.linspace(-1.0, 1.0, mesh_par)],
order=order)
dim = 1
dt_factor = 1.0
elif mesh_name == "disk":
pytest.importorskip("meshpy")
from meshpy.geometry import make_circle, GeometryBuilder
from meshpy.triangle import MeshInfo, build
geob = GeometryBuilder()
geob.add_geometry(*make_circle(1))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info = build(mesh_info, max_volume=mesh_par)
from meshmode.mesh.io import from_meshpy
mesh = from_meshpy(mesh_info, order=1)
dim = 2
dt_factor = 4
elif mesh_name.startswith("rect"):
dim = int(mesh_name[4:])
from meshmode.mesh.generation import generate_regular_rect_mesh
mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
b=(0.5, ) * dim,
n=(mesh_par, ) * dim,
order=4)
if dim == 2:
dt_factor = 4
elif dim == 3:
dt_factor = 2
else:
raise ValueError("dt_factor not known for %dd" % dim)
else:
raise ValueError("invalid mesh name: " + mesh_name)
v = np.array([0.27, 0.31, 0.1])[:dim]
norm_v = la.norm(v)
def f(x):
return sym.sin(10 * x)
def u_analytic(x):
return f(-v.dot(x) / norm_v + sym.var("t", sym.DD_SCALAR) * norm_v)
from grudge.models.advection import (StrongAdvectionOperator,
WeakAdvectionOperator)
discr = DGDiscretizationWithBoundaries(actx, mesh, order=order)
op_class = {
"strong": StrongAdvectionOperator,
"weak": WeakAdvectionOperator,
}[op_type]
op = op_class(v,
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)))(actx, t=0)
def rhs(t, u):
return bound_op(t=t, u=u)
if dim == 3:
final_time = 0.1
else:
final_time = 0.2
h_max = bind(discr, sym.h_max_from_volume(discr.ambient_dim))(actx)
dt = dt_factor * h_max / 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)
last_u = None
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
logger.debug("[%04d] t = %.5f", step, event.t)
last_t = event.t
last_u = event.state_component
if visualize:
vis.write_vtk_file("fld-%s-%04d.vtu" % (mesh_par, step),
[("u", event.state_component)])
error_l2 = bind(discr,
sym.norm(2,
sym.var("u") - u_analytic(sym.nodes(dim))))(
t=last_t, u=last_u)
logger.info("h_max %.5e error %.5e", h_max, error_l2)
eoc_rec.add_data_point(h_max, error_l2)
logger.info(
"\n%s", eoc_rec.pretty_print(abscissa_label="h",
error_label="L2 Error"))
assert eoc_rec.order_estimate() > order
def test_convergence_advec(actx_factory,
mesh_name,
mesh_pars,
op_type,
flux_type,
order,
visualize=False):
"""Test whether 2D advection actually converges"""
actx = actx_factory()
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
for mesh_par in mesh_pars:
if mesh_name == "segment":
mesh = mgen.generate_box_mesh([np.linspace(-1.0, 1.0, mesh_par)],
order=order)
dim = 1
dt_factor = 1.0
elif mesh_name == "disk":
pytest.importorskip("meshpy")
from meshpy.geometry import make_circle, GeometryBuilder
from meshpy.triangle import MeshInfo, build
geob = GeometryBuilder()
geob.add_geometry(*make_circle(1))
mesh_info = MeshInfo()
geob.set(mesh_info)
mesh_info = build(mesh_info, max_volume=mesh_par)
from meshmode.mesh.io import from_meshpy
mesh = from_meshpy(mesh_info, order=1)
dim = 2
dt_factor = 4
elif mesh_name.startswith("rect"):
dim = int(mesh_name[-1:])
mesh = mgen.generate_regular_rect_mesh(
a=(-0.5, ) * dim,
b=(0.5, ) * dim,
nelements_per_axis=(mesh_par, ) * dim,
order=4)
if dim == 2:
dt_factor = 4
elif dim == 3:
dt_factor = 2
else:
raise ValueError("dt_factor not known for %dd" % dim)
elif mesh_name.startswith("warped"):
dim = int(mesh_name[-1:])
mesh = mgen.generate_warped_rect_mesh(dim,
order=order,
nelements_side=mesh_par)
if dim == 2:
dt_factor = 4
elif dim == 3:
dt_factor = 2
else:
raise ValueError("dt_factor not known for %dd" % dim)
else:
raise ValueError("invalid mesh name: " + mesh_name)
v = np.array([0.27, 0.31, 0.1])[:dim]
norm_v = la.norm(v)
def f(x):
return actx.np.sin(10 * x)
def u_analytic(x, t=0):
return f(-v.dot(x) / norm_v + t * norm_v)
from grudge.models.advection import (StrongAdvectionOperator,
WeakAdvectionOperator)
from meshmode.mesh import BTAG_ALL
dcoll = DiscretizationCollection(actx, mesh, order=order)
op_class = {
"strong": StrongAdvectionOperator,
"weak": WeakAdvectionOperator
}[op_type]
adv_operator = op_class(dcoll,
v,
inflow_u=lambda t: u_analytic(
thaw(dcoll.nodes(dd=BTAG_ALL), actx), t=t),
flux_type=flux_type)
nodes = thaw(dcoll.nodes(), actx)
u = u_analytic(nodes, t=0)
def rhs(t, u):
return adv_operator.operator(t, u)
if dim == 3:
final_time = 0.1
else:
final_time = 0.2
from grudge.dt_utils import h_max_from_volume
h_max = h_max_from_volume(dcoll, dim=dcoll.ambient_dim)
dt = dt_factor * h_max / 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)
last_u = None
from grudge.shortcuts import make_visualizer
vis = make_visualizer(dcoll)
step = 0
for event in dt_stepper.run(t_end=final_time):
if isinstance(event, dt_stepper.StateComputed):
step += 1
logger.debug("[%04d] t = %.5f", step, event.t)
last_t = event.t
last_u = event.state_component
if visualize:
vis.write_vtk_file("fld-%s-%04d.vtu" % (mesh_par, step),
[("u", event.state_component)])
error_l2 = op.norm(dcoll, last_u - u_analytic(nodes, t=last_t), 2)
logger.info("h_max %.5e error %.5e", h_max, error_l2)
eoc_rec.add_data_point(h_max, actx.to_numpy(error_l2))
logger.info(
"\n%s", eoc_rec.pretty_print(abscissa_label="h",
error_label="L2 Error"))
if mesh_name.startswith("warped"):
# NOTE: curvilinear meshes are hard
assert eoc_rec.order_estimate() > order - 0.5
else:
assert eoc_rec.order_estimate() > order
def test_mesh_copy():
mesh = mgen.generate_box_mesh(3 * (np.linspace(0, 1, 5), ))
mesh.copy()
def test_opposite_face_interpolation(actx_factory, group_factory, mesh_name,
dim, mesh_pars):
if (group_factory is LegendreGaussLobattoTensorProductGroupFactory
and mesh_name in ["segment", "blob"]):
pytest.skip("tensor products not implemented on blobs")
logging.basicConfig(level=logging.INFO)
actx = actx_factory()
if group_factory is LegendreGaussLobattoTensorProductGroupFactory:
group_cls = TensorProductElementGroup
else:
group_cls = SimplexElementGroup
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (
make_face_restriction, make_opposite_face_connection, check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 5
def f(x):
return 0.1 * actx.np.sin(30 * x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "segment":
assert dim == 1
mesh = mgen.generate_box_mesh([np.linspace(-0.5, 0.5, mesh_par)],
order=order,
group_cls=group_cls)
h = 1.0 / mesh_par
elif mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(
FileSource("blob-2d.step"),
2,
order=order,
force_ambient_dim=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %s;" % h
],
target_unit="MM",
)
print("END GEN")
elif mesh_name == "warp":
mesh = mgen.generate_warped_rect_mesh(dim,
order=order,
nelements_side=mesh_par,
group_cls=group_cls)
h = 1 / mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(actx, mesh, group_factory(order))
print("h=%s -> %d elements" %
(h, sum(mgrp.nelements for mgrp in mesh.groups)))
bdry_connection = make_face_restriction(actx, vol_discr,
group_factory(order),
FACE_RESTR_INTERIOR)
bdry_discr = bdry_connection.to_discr
opp_face = make_opposite_face_connection(actx, bdry_connection)
check_connection(actx, opp_face)
bdry_x = thaw(bdry_discr.nodes()[0], actx)
bdry_f = f(bdry_x)
bdry_f_2 = opp_face(bdry_f)
err = flat_norm(bdry_f - bdry_f_2, np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1.7e-13)
def test_box_mesh():
from meshmode.mesh.generation import generate_box_mesh
generate_box_mesh(3*(np.linspace(0, 1, 5),))
def test_mesh_copy():
from meshmode.mesh.generation import generate_box_mesh
mesh = generate_box_mesh(3 * (np.linspace(0, 1, 5), ))
mesh.copy()
def test_mesh_copy():
from meshmode.mesh.generation import generate_box_mesh
mesh = generate_box_mesh(3*(np.linspace(0, 1, 5),))
mesh.copy()
def test_opposite_face_interpolation(ctx_factory, group_factory, mesh_name,
dim, mesh_pars):
logging.basicConfig(level=logging.INFO)
cl_ctx = ctx_factory()
queue = cl.CommandQueue(cl_ctx)
from meshmode.discretization import Discretization
from meshmode.discretization.connection import (
make_face_restriction, make_opposite_face_connection, check_connection)
from pytools.convergence import EOCRecorder
eoc_rec = EOCRecorder()
order = 5
def f(x):
return 0.1 * cl.clmath.sin(30 * x)
for mesh_par in mesh_pars:
# {{{ get mesh
if mesh_name == "segment":
assert dim == 1
from meshmode.mesh.generation import generate_box_mesh
mesh = generate_box_mesh([np.linspace(-0.5, 0.5, mesh_par)],
order=order)
h = 1.0 / mesh_par
elif mesh_name == "blob":
assert dim == 2
h = mesh_par
from meshmode.mesh.io import generate_gmsh, FileSource
print("BEGIN GEN")
mesh = generate_gmsh(FileSource("blob-2d.step"),
2,
order=order,
force_ambient_dim=2,
other_options=[
"-string",
"Mesh.CharacteristicLengthMax = %s;" % h
])
print("END GEN")
elif mesh_name == "warp":
from meshmode.mesh.generation import generate_warped_rect_mesh
mesh = generate_warped_rect_mesh(dim, order=4, n=mesh_par)
h = 1 / mesh_par
else:
raise ValueError("mesh_name not recognized")
# }}}
vol_discr = Discretization(cl_ctx, mesh, group_factory(order))
print("h=%s -> %d elements" %
(h, sum(mgrp.nelements for mgrp in mesh.groups)))
bdry_connection = make_face_restriction(vol_discr,
group_factory(order),
FACE_RESTR_INTERIOR)
bdry_discr = bdry_connection.to_discr
opp_face = make_opposite_face_connection(bdry_connection)
check_connection(opp_face)
bdry_x = bdry_discr.nodes()[0].with_queue(queue)
bdry_f = f(bdry_x)
bdry_f_2 = opp_face(queue, bdry_f)
err = la.norm((bdry_f - bdry_f_2).get(), np.inf)
eoc_rec.add_data_point(h, err)
print(eoc_rec)
assert (eoc_rec.order_estimate() >= order - 0.5
or eoc_rec.max_error() < 1e-13)
from grudge.discretization import DiscretizationCollection
import grudge.op as op
from meshmode.mesh.generation import generate_box_mesh
from meshmode.array_context import PyOpenCLArrayContext
from arraycontext import thaw
from grudge.dof_desc import DTAG_BOUNDARY, FACE_RESTR_INTERIOR
ctx = cl.create_some_context()
queue = cl.CommandQueue(ctx)
actx = PyOpenCLArrayContext(queue)
nel = 10
coords = np.linspace(0, 2*np.pi, nel)
mesh = generate_box_mesh((coords,),
boundary_tag_to_face={"left": ["-x"],
"right": ["+x"]})
dcoll = DiscretizationCollection(actx, mesh, order=1)
def initial_condition(x):
# 'x' contains ndim arrays.
# 'x[0]' gets the first coordinate value of all the nodes
return actx.np.sin(x[0])
def left_boundary_condition(x, t):
return actx.np.sin(x[0] - 2 * np.pi * t)
def flux(dcoll, u_tpair):
def main(ctx_factory, dim=2, 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,
)
# {{{ parameters
# domain [-d/2, d/2]^dim
d = 1.0
# number of points in each dimension
npoints = 20
# final time
final_time = 1.0
# 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
dcoll = DiscretizationCollection(actx, mesh, order=order)
# }}}
# {{{ weak advection operator
def f(x):
return actx.np.sin(3 * x)
def u_analytic(x, t=0):
return f(-np.dot(c, x) / norm_c + t * norm_c)
from grudge.models.advection import WeakAdvectionOperator
adv_operator = WeakAdvectionOperator(
dcoll,
c,
inflow_u=lambda t: u_analytic(thaw(dcoll.nodes(dd=BTAG_ALL), actx),
t=t),
flux_type=flux_type)
nodes = thaw(dcoll.nodes(), actx)
u = u_analytic(nodes, t=0)
def rhs(t, u):
return adv_operator.operator(t, u)
dt = actx.to_numpy(
adv_operator.estimate_rk4_timestep(actx, dcoll, fields=u))
logger.info("Timestep size: %g", dt)
# }}}
# {{{ time stepping
from grudge.shortcuts import set_up_rk4
dt_stepper = set_up_rk4("u", dt, u, rhs)
plot = Plotter(actx, dcoll, order, visualize=visualize, ylim=[-1.1, 1.1])
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 = actx.to_numpy(op.norm(dcoll, event.state_component, 2))
plot(event, "fld-weak-%04d" % step)
step += 1
logger.info("[%04d] t = %.5f |u| = %.5e", step, event.t, norm_u)
# NOTE: These are here to ensure the solution is bounded for the
# time interval specified
assert norm_u < 1
