def test_from_fd_consistency(ctx_factory, fdrake_mesh, fspace_degree): """ Check basic consistency with a FiredrakeConnection built from firedrake """ # make discretization from firedrake fdrake_fspace = FunctionSpace(fdrake_mesh, "DG", fspace_degree) cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) fdrake_connection = build_connection_from_firedrake(actx, fdrake_fspace) discr = fdrake_connection.discr # Check consistency check_consistency(fdrake_fspace, discr)
def main(): # If can't import firedrake, do nothing # # filename MUST include "firedrake" (i.e. match *firedrake*.py) in order # to be run during CI try: import firedrake # noqa : F401 except ImportError: return 0 from meshmode.interop.firedrake import build_connection_from_firedrake from firedrake import (UnitSquareMesh, FunctionSpace, SpatialCoordinate, Function, cos) # Create a firedrake mesh and interpolate cos(x+y) onto it fd_mesh = UnitSquareMesh(10, 10) fd_fspace = FunctionSpace(fd_mesh, "DG", 2) spatial_coord = SpatialCoordinate(fd_mesh) fd_fntn = Function(fd_fspace).interpolate(cos(sum(spatial_coord))) # Make connections cl_ctx = cl.create_some_context() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) fd_connection = build_connection_from_firedrake(actx, fd_fspace) fd_bdy_connection = \ build_connection_from_firedrake(actx, fd_fspace, restrict_to_boundary="on_boundary") # Plot the meshmode meshes that the connections connect to import matplotlib.pyplot as plt from meshmode.mesh.visualization import draw_2d_mesh fig, (ax1, ax2) = plt.subplots(1, 2) ax1.set_title("FiredrakeConnection") plt.sca(ax1) draw_2d_mesh(fd_connection.discr.mesh, draw_vertex_numbers=False, draw_element_numbers=False, set_bounding_box=True) ax2.set_title("FiredrakeConnection 'on_boundary'") plt.sca(ax2) draw_2d_mesh(fd_bdy_connection.discr.mesh, draw_vertex_numbers=False, draw_element_numbers=False, set_bounding_box=True) plt.show() # Plot fd_fntn using unrestricted FiredrakeConnection from meshmode.discretization.visualization import make_visualizer discr = fd_connection.discr vis = make_visualizer(actx, discr, discr.groups[0].order + 3) field = fd_connection.from_firedrake(fd_fntn, actx=actx) fig = plt.figure() ax1 = fig.add_subplot(1, 2, 1, projection="3d") ax1.set_title("cos(x+y) in\nFiredrakeConnection") vis.show_scalar_in_matplotlib_3d(field, do_show=False) # Now repeat using FiredrakeConnection restricted to "on_boundary" bdy_discr = fd_bdy_connection.discr bdy_vis = make_visualizer(actx, bdy_discr, bdy_discr.groups[0].order + 3) bdy_field = fd_bdy_connection.from_firedrake(fd_fntn, actx=actx) ax2 = fig.add_subplot(1, 2, 2, projection="3d") plt.sca(ax2) ax2.set_title("cos(x+y) in\nFiredrakeConnection 'on_boundary'") bdy_vis.show_scalar_in_matplotlib_3d(bdy_field, do_show=False) import matplotlib.cm as cm fig.colorbar(cm.ScalarMappable()) plt.show()
def test_from_fd_idempotency(ctx_factory, fdrake_mesh, fspace_degree, fspace_type, only_convert_bdy): """ Make sure fd->mm->fd and (fd->)->mm->fd->mm are identity """ # Make a function space and a function with unique values at each node if fspace_type == "scalar": fdrake_fspace = FunctionSpace(fdrake_mesh, "DG", fspace_degree) # Just use the node nr fdrake_unique = Function(fdrake_fspace) fdrake_unique.dat.data[:] = np.arange(fdrake_unique.dat.data.shape[0]) elif fspace_type == "vector": fdrake_fspace = VectorFunctionSpace(fdrake_mesh, "DG", fspace_degree) # use the coordinates xx = SpatialCoordinate(fdrake_fspace.mesh()) fdrake_unique = Function(fdrake_fspace).interpolate(xx) elif fspace_type == "tensor": fdrake_fspace = TensorFunctionSpace(fdrake_mesh, "DG", fspace_degree) # use the coordinates, duplicated into the right tensor shape xx = SpatialCoordinate(fdrake_fspace.mesh()) dim = fdrake_fspace.mesh().geometric_dimension() unique_expr = as_tensor([xx for _ in range(dim)]) fdrake_unique = Function(fdrake_fspace).interpolate(unique_expr) # Make connection cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) # If only converting boundary, first go ahead and do one round of # fd->mm->fd. This will zero out any degrees of freedom absent in # the meshmode mesh (because they are not associated to cells # with >= 1 node on the boundary) # # Otherwise, just continue as normal if only_convert_bdy: fdrake_connection = \ build_connection_from_firedrake(actx, fdrake_fspace, restrict_to_boundary="on_boundary") temp = fdrake_connection.from_firedrake(fdrake_unique, actx=actx) fdrake_unique = fdrake_connection.from_meshmode(temp) else: fdrake_connection = build_connection_from_firedrake( actx, fdrake_fspace) # Test for idempotency fd->mm->fd mm_field = fdrake_connection.from_firedrake(fdrake_unique, actx=actx) fdrake_unique_copy = Function(fdrake_fspace) fdrake_connection.from_meshmode(mm_field, out=fdrake_unique_copy) np.testing.assert_allclose(fdrake_unique_copy.dat.data, fdrake_unique.dat.data, atol=CLOSE_ATOL) # Test for idempotency (fd->)mm->fd->mm mm_field_copy = fdrake_connection.from_firedrake(fdrake_unique_copy, actx=actx) if fspace_type == "scalar": np.testing.assert_allclose(actx.to_numpy(mm_field_copy[0]), actx.to_numpy(mm_field[0]), atol=CLOSE_ATOL) else: for dof_arr_cp, dof_arr in zip(mm_field_copy.flatten(), mm_field.flatten()): np.testing.assert_allclose(actx.to_numpy(dof_arr_cp[0]), actx.to_numpy(dof_arr[0]), atol=CLOSE_ATOL)
def test_from_fd_transfer(ctx_factory, fspace_degree, fdrake_mesh_name, fdrake_mesh_pars, dim, only_convert_bdy): """ Make sure creating a function which projects onto one dimension then transports it is the same (up to resampling error) as projecting to one dimension on the transported mesh """ # build estimate-of-convergence recorder from pytools.convergence import EOCRecorder # (fd -> mm ? True : False, dimension projecting onto) eoc_recorders = {(True, d): EOCRecorder() for d in range(dim)} if not only_convert_bdy: for d in range(dim): eoc_recorders[(False, d)] = EOCRecorder() # make a computing context cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) def get_fdrake_mesh_and_h_from_par(mesh_par): if fdrake_mesh_name == "UnitInterval": assert dim == 1 n = mesh_par fdrake_mesh = UnitIntervalMesh(n) h = 1 / n elif fdrake_mesh_name == "UnitSquare": assert dim == 2 n = mesh_par fdrake_mesh = UnitSquareMesh(n, n) h = 1 / n elif fdrake_mesh_name == "UnitCube": assert dim == 3 n = mesh_par fdrake_mesh = UnitCubeMesh(n, n, n) h = 1 / n elif fdrake_mesh_name in ("blob2d-order1", "blob2d-order4"): assert dim == 2 if fdrake_mesh_name == "blob2d-order1": from firedrake import Mesh fdrake_mesh = Mesh(f"{fdrake_mesh_name}-h{mesh_par}.msh", dim=dim) else: from meshmode.mesh.io import read_gmsh from meshmode.interop.firedrake import export_mesh_to_firedrake mm_mesh = read_gmsh(f"{fdrake_mesh_name}-h{mesh_par}.msh", force_ambient_dim=dim) fdrake_mesh, _, _ = export_mesh_to_firedrake(mm_mesh) h = float(mesh_par) elif fdrake_mesh_name == "warp": from meshmode.mesh.generation import generate_warped_rect_mesh from meshmode.interop.firedrake import export_mesh_to_firedrake mm_mesh = generate_warped_rect_mesh(dim, order=4, n=mesh_par) fdrake_mesh, _, _ = export_mesh_to_firedrake(mm_mesh) h = 1 / mesh_par else: raise ValueError("fdrake_mesh_name not recognized") return (fdrake_mesh, h) # Record error for each refinement of each mesh for mesh_par in fdrake_mesh_pars: fdrake_mesh, h = get_fdrake_mesh_and_h_from_par(mesh_par) # make function space and build connection fdrake_fspace = FunctionSpace(fdrake_mesh, "DG", fspace_degree) if only_convert_bdy: fdrake_connection = \ build_connection_from_firedrake(actx, fdrake_fspace, restrict_to_boundary="on_boundary") else: fdrake_connection = build_connection_from_firedrake( actx, fdrake_fspace) # get this for making functions in firedrake spatial_coord = SpatialCoordinate(fdrake_mesh) # get nodes in handier format for making meshmode functions discr = fdrake_connection.discr # nodes is np array (ambient_dim,) of DOFArray (ngroups,) # of arrays (nelements, nunit_dofs), we want a single np array # of shape (ambient_dim, nelements, nunit_dofs) nodes = discr.nodes() group_nodes = np.array( [actx.to_numpy(dof_arr[0]) for dof_arr in nodes]) # Now, for each coordinate d, test transferring the function # x -> sin(dth component of x) for d in range(dim): fdrake_f = Function(fdrake_fspace).interpolate( sin(spatial_coord[d])) # transport fdrake function and put in numpy fd2mm_f = fdrake_connection.from_firedrake(fdrake_f, actx=actx) fd2mm_f = actx.to_numpy(fd2mm_f[0]) meshmode_f = np.sin(group_nodes[d, :, :]) # record fd -> mm error err = np.max(np.abs(fd2mm_f - meshmode_f)) eoc_recorders[(True, d)].add_data_point(h, err) if not only_convert_bdy: # now transport mm -> fd meshmode_f_dofarr = discr.zeros(actx) meshmode_f_dofarr[0][:] = meshmode_f mm2fd_f = fdrake_connection.from_meshmode(meshmode_f_dofarr) # record mm -> fd error err = np.max(np.abs(fdrake_f.dat.data - mm2fd_f.dat.data)) eoc_recorders[(False, d)].add_data_point(h, err) # assert that order is correct or error is "low enough" for ((fd2mm, d), eoc_rec) in eoc_recorders.items(): print( "\nfiredrake -> meshmode: %s\nvector *x* -> *sin(x[%s])*\n" % (fd2mm, d), eoc_rec) assert (eoc_rec.order_estimate() >= fspace_degree or eoc_rec.max_error() < 2e-14)
def test_from_boundary_consistency(ctx_factory, fdrake_mesh, fspace_degree): """ Make basic checks that FiredrakeConnection restricted to cells near the boundary is not doing something obviously wrong, i.e. that the firedrake boundary tags partition the converted meshmode mesh, that the firedrake boundary tags correspond to the same physical regions in the converted meshmode mesh as in the original firedrake mesh, and that each boundary tag is associated to the same number of facets in the converted meshmode mesh as in the original firedrake mesh. """ fdrake_fspace = FunctionSpace(fdrake_mesh, "DG", fspace_degree) cl_ctx = ctx_factory() queue = cl.CommandQueue(cl_ctx) actx = PyOpenCLArrayContext(queue) frombdy_conn = \ build_connection_from_firedrake(actx, fdrake_fspace, restrict_to_boundary="on_boundary") # Ensure the meshmode mesh has one group and make sure both # meshes agree on some basic properties discr = frombdy_conn.discr assert len(discr.mesh.groups) == 1 fdrake_mesh_fspace = fdrake_mesh.coordinates.function_space() fdrake_mesh_order = fdrake_mesh_fspace.finat_element.degree assert discr.mesh.groups[0].dim == fdrake_mesh.topological_dimension() assert discr.mesh.groups[0].order == fdrake_mesh_order # Get the unit vertex indices (in each cell) fdrake_mesh = fdrake_fspace.mesh() cfspace = fdrake_mesh.coordinates.function_space() entity_dofs = cfspace.finat_element.entity_dofs()[0] fdrake_unit_vert_indices = [] for _, local_node_nrs in sorted(entity_dofs.items()): assert len(local_node_nrs) == 1 fdrake_unit_vert_indices.append(local_node_nrs[0]) fdrake_unit_vert_indices = np.array(fdrake_unit_vert_indices) # only look at cells "near" bdy (with >= 1 vertex on) from meshmode.interop.firedrake.connection import _get_cells_to_use cells_near_bdy = _get_cells_to_use(fdrake_mesh, "on_boundary") # get the firedrake vertices of cells near the boundary, # in no particular order fdrake_vert_indices = \ cfspace.cell_node_list[cells_near_bdy, fdrake_unit_vert_indices[:, np.newaxis]] fdrake_vert_indices = np.unique(fdrake_vert_indices) fdrake_verts = fdrake_mesh.coordinates.dat.data[fdrake_vert_indices, ...] if fdrake_mesh.geometric_dimension() == 1: fdrake_verts = fdrake_verts[:, np.newaxis] # Get meshmode vertices (shaped like (dim, nverts)) meshmode_verts = discr.mesh.vertices # Ensure that the vertices of firedrake elements on # the boundary are identical to the resultant meshes' vertices up to # reordering # Nb: I got help on this from stack overflow: # https://stackoverflow.com/questions/38277143/sort-2d-numpy-array-lexicographically # noqa: E501 lex_sorted_mm_verts = meshmode_verts[:, np.lexsort(meshmode_verts)] lex_sorted_fdrake_verts = fdrake_verts[np.lexsort(fdrake_verts.T)] np.testing.assert_allclose(lex_sorted_mm_verts, lex_sorted_fdrake_verts.T, atol=CLOSE_ATOL) # Ensure the discretization and the firedrake function space reference element # agree on some basic properties finat_elt = fdrake_fspace.finat_element assert len(discr.groups) == 1 assert discr.groups[0].order == finat_elt.degree assert discr.groups[0].nunit_dofs == finat_elt.space_dimension()
def run_method(trial, method, cl_ctx=None, queue=None, clear_memoized_objects=False, true_sol_name="True Solution", comp_sol_name="Computed Solution", **kwargs): """ Returns (true solution, computed solution, snes_or_ksp) :arg clear_memoized_objects: Destroy memoized objects if true. :arg trial: A dict mapping each trial option to a valid value :arg method: A valid method (see the keys of *method_options*) :arg cl_ctx: the computing context :arg queue: the computing queue for the context kwargs should include the boundary id of the scatterer as 'scatterer_bdy_id' and the boundary id of the outer boundary as 'outer_bdy_id' kwargs should include the method options for :arg:`trial['method']`. for the given method. """ if clear_memoized_objects: global memoized_objects memoized_objects = {} if cl_ctx is None: raise ValueError("Missing cl_ctx") if queue is None: raise ValueError("Missing queue") # Get boundary ids scatterer_bdy_id = kwargs['scatterer_bdy_id'] outer_bdy_id = kwargs['outer_bdy_id'] # Get degree and wave number degree = trial['degree'] wave_number = trial['kappa'] # Get options prefix and solver parameters, if any options_prefix = kwargs.get('options_prefix', None) solver_parameters = dict(kwargs.get('solver_parameters', None)) # Get prepared trial args in kwargs prepared_trial = prepare_trial(trial, true_sol_name, cl_ctx, queue) mesh, fspace, vfspace, true_sol, true_sol_grad_expr = prepared_trial # Create a place to memoize any objects if necessary tuple_trial = trial_to_tuple(trial) memo_key = tuple_trial[:2] if memo_key not in memoized_objects: memoized_objects[memo_key] = {} comp_sol = None # Handle any special kwargs and get computed solution if method == 'pml': # Get required objects pml_max = kwargs['pml_max'] pml_min = kwargs['pml_min'] # Get optional argumetns pml_type = kwargs.get('pml_type', None) quad_const = kwargs.get('quad_const', None) speed = kwargs.get('speed', None) # Make tensor function space if 'tfspace' not in memoized_objects[memo_key]: memoized_objects[memo_key]['tfspace'] = \ TensorFunctionSpace(mesh, 'CG', degree) tfspace = memoized_objects[memo_key]['tfspace'] snes, comp_sol = pml( mesh, scatterer_bdy_id, outer_bdy_id, wave_number, options_prefix=options_prefix, solver_parameters=solver_parameters, fspace=fspace, tfspace=tfspace, true_sol_grad_expr=true_sol_grad_expr, pml_type=pml_type, quad_const=quad_const, speed=speed, pml_min=pml_min, pml_max=pml_max, ) snes_or_ksp = snes elif method == 'nonlocal': # Build DG spaces if not already built if 'dgfspace' not in memoized_objects[memo_key]: memoized_objects[memo_key]['dgfspace'] = \ FunctionSpace(mesh, 'DG', degree) if 'dgvfspace' not in memoized_objects[memo_key]: memoized_objects[memo_key]['dgvfspace'] = \ VectorFunctionSpace(mesh, 'DG', degree) dgfspace = memoized_objects[memo_key]['dgfspace'] dgvfspace = memoized_objects[memo_key]['dgvfspace'] # Get opencl array context from meshmode.array_context import PyOpenCLArrayContext actx = PyOpenCLArrayContext(queue) # Build connection fd -> meshmode if not already built if 'meshmode_src_connection' not in memoized_objects[memo_key]: from meshmode.interop.firedrake import build_connection_from_firedrake memoized_objects[memo_key]['meshmode_src_connection'] = \ build_connection_from_firedrake( actx, dgfspace, grp_factory=None, restrict_to_boundary=scatterer_bdy_id) meshmode_src_connection = memoized_objects[memo_key][ 'meshmode_src_connection'] # Set defaults for qbx kwargs qbx_order = kwargs.get('qbx_order', degree + 2) fine_order = kwargs.get('fine_order', 4 * degree) fmm_order = kwargs.get('FMM Order', None) fmm_tol = kwargs.get('FMM Tol', None) # make sure got either fmm_order xor fmm_tol if fmm_order is None and fmm_tol is None: raise ValueError("At least one of 'fmm_order', 'fmm_tol' must not " "be *None*") if fmm_order is not None and fmm_tol is not None: raise ValueError("At most one of 'fmm_order', 'fmm_tol' must not " "be *None*") # if got fmm_tol, make a level-to-order fmm_level_to_order = None if fmm_tol is not None: if not isinstance(fmm_tol, float): raise TypeError("fmm_tol of type '%s' is not of type float" % type(fmm_tol)) if fmm_tol <= 0.0: raise ValueError( "fmm_tol of '%s' is less than or equal to 0.0" % fmm_tol) from sumpy.expansion.level_to_order import SimpleExpansionOrderFinder fmm_level_to_order = SimpleExpansionOrderFinder(fmm_tol) # Otherwise, make sure we got a valid fmm_order else: if not isinstance(fmm_order, int): if fmm_order != False: raise TypeError( "fmm_order of type '%s' is not of type int" % type(fmm_order)) if fmm_order != False and fmm_order < 1: raise ValueError("fmm_order of '%s' is less than 1" % fmm_order) qbx_kwargs = { 'qbx_order': qbx_order, 'fine_order': fine_order, 'fmm_order': fmm_order, 'fmm_level_to_order': fmm_level_to_order, 'fmm_backend': 'fmmlib', } # }}} ksp, comp_sol = nonlocal_integral_eq( mesh, scatterer_bdy_id, outer_bdy_id, wave_number, options_prefix=options_prefix, solver_parameters=solver_parameters, fspace=fspace, vfspace=vfspace, true_sol_grad_expr=true_sol_grad_expr, actx=actx, dgfspace=dgfspace, dgvfspace=dgvfspace, meshmode_src_connection=meshmode_src_connection, qbx_kwargs=qbx_kwargs, ) snes_or_ksp = ksp elif method == 'transmission': snes, comp_sol = transmission( mesh, scatterer_bdy_id, outer_bdy_id, wave_number, options_prefix=options_prefix, solver_parameters=solver_parameters, fspace=fspace, true_sol_grad_expr=true_sol_grad_expr, ) snes_or_ksp = snes else: raise ValueError("Invalid method") comp_sol.rename(name=comp_sol_name) return true_sol, comp_sol, snes_or_ksp