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 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