Exemple #1
0
    def ic_expr(t, x, fields):
        from hedge.optemplate import CFunction
        from pymbolic.primitives import IfPositive
        from pytools.obj_array import make_obj_array

        tanh = CFunction("tanh")
        sin = CFunction("sin")

        rho = 1
        u0 = 0.05
        w = 0.05
        delta = 0.05

        from hedge.optemplate.primitives import make_common_subexpression as cse
        u = cse(make_obj_array([
            IfPositive(x[1]-1/2,
                u0*tanh(4*(3/4-x[1])/w),
                u0*tanh(4*(x[1]-1/4)/w)),
            u0*delta*sin(2*np.pi*(x[0]+1/4))]),
            "u")

        return make_obj_array([
            op.method.f_equilibrium(rho, alpha, u)
            for alpha in range(len(op.method))
            ])
Exemple #2
0
def test_make_obj_array_iteration():
    pytest.importorskip("numpy")

    from pytools.obj_array import make_obj_array
    make_obj_array([FakeArray()])

    assert FakeArray.nopes == 0, FakeArray.nopes
Exemple #3
0
    def __call__(self, t, x_vec, eos=IdealSingleGas()):
        """
        Create the lump-of-mass solution at time *t* and locations *x_vec*.

        Note that *t* is used to advect the mass lump under the assumption of
        constant, and uniform velocity.

        Parameters
        ----------
        t: float
            Current time at which the solution is desired
        x_vec: numpy.ndarray
            Nodal coordinates
        eos: :class:`mirgecom.eos.GasEOS`
            Equation of state class to be used in construction of soln (if needed)
        """
        lump_loc = self._center + t * self._velocity
        assert len(x_vec) == self._dim
        # coordinates relative to lump center
        rel_center = make_obj_array(
            [x_vec[i] - lump_loc[i] for i in range(self._dim)]
        )
        actx = x_vec[0].array_context
        r = actx.np.sqrt(np.dot(rel_center, rel_center))

        gamma = eos.gamma()
        expterm = self._rhoamp * actx.np.exp(1 - r ** 2)
        mass = expterm + self._rho0
        mom = self._velocity * make_obj_array([mass])
        energy = (self._p0 / (gamma - 1.0)) + np.dot(mom, mom) / (2.0 * mass)

        return flat_obj_array(mass, energy, mom)
Exemple #4
0
def cross_rank_trace_pairs(discrwb, vec, tag=None):
    if (isinstance(vec, np.ndarray)
            and vec.dtype.char == "O"
            and not isinstance(vec, DOFArray)):

        n, = vec.shape
        result = {}
        for ivec in range(n):
            for rank_tpair in _cross_rank_trace_pairs_scalar_field(
                    discrwb, vec[ivec]):
                assert isinstance(rank_tpair.dd.domain_tag, sym.DTAG_BOUNDARY)
                assert isinstance(rank_tpair.dd.domain_tag.tag, BTAG_PARTITION)
                result[rank_tpair.dd.domain_tag.tag.part_nr, ivec] = rank_tpair

        return [
            TracePair(
                dd=sym.as_dofdesc(sym.DTAG_BOUNDARY(BTAG_PARTITION(remote_rank))),
                interior=make_obj_array([
                    result[remote_rank, i].int for i in range(n)]),
                exterior=make_obj_array([
                    result[remote_rank, i].ext for i in range(n)])
                )
            for remote_rank in discrwb.connected_ranks()]
    else:
        return _cross_rank_trace_pairs_scalar_field(discrwb, vec, tag=tag)
Exemple #5
0
    def ic_expr(t, x, fields):
        from hedge.optemplate import CFunction
        from pymbolic.primitives import IfPositive
        from pytools.obj_array import make_obj_array

        tanh = CFunction("tanh")
        sin = CFunction("sin")

        rho = 1
        u0 = 0.05
        w = 0.05
        delta = 0.05

        from hedge.optemplate.primitives import make_common_subexpression as cse
        u = cse(
            make_obj_array([
                IfPositive(x[1] - 1 / 2, u0 * tanh(4 * (3 / 4 - x[1]) / w),
                           u0 * tanh(4 * (x[1] - 1 / 4) / w)),
                u0 * delta * sin(2 * np.pi * (x[0] + 1 / 4))
            ]), "u")

        return make_obj_array([
            op.method.f_equilibrium(rho, alpha, u)
            for alpha in range(len(op.method))
        ])
Exemple #6
0
    def exact_rhs(self, discr, cv, t=0.0):
        """
        Create the RHS for the uniform solution. (Hint - it should be all zero).

        Parameters
        ----------
        q
            State array which expects at least the canonical conserved quantities
            (mass, energy, momentum) for the fluid at each point. (unused)
        t: float
            Time at which RHS is desired (unused)
        """
        actx = cv.array_context
        nodes = thaw(actx, discr.nodes())
        mass = nodes[0].copy()
        mass[:] = 1.0
        massrhs = 0.0 * mass
        energyrhs = 0.0 * mass
        momrhs = make_obj_array([0 * mass for i in range(self._dim)])
        yrhs = make_obj_array([0 * mass for i in range(self._nspecies)])

        return make_conserved(dim=self._dim,
                              mass=massrhs,
                              energy=energyrhs,
                              momentum=momrhs,
                              species_mass=yrhs)
Exemple #7
0
    def __call__(self, x_vec, eos, **kwargs):
        """
        Create the mixture state at locations *x_vec* (t is ignored).

        Parameters
        ----------
        x_vec: numpy.ndarray
            Coordinates at which solution is desired
        eos:
            Mixture-compatible equation-of-state object must provide
            these functions:
            `eos.get_density`
            `eos.get_internal_energy`
        """
        if x_vec.shape != (self._dim,):
            raise ValueError(f"Position vector has unexpected dimensionality,"
                             f" expected {self._dim}.")

        ones = (1.0 + x_vec[0]) - x_vec[0]
        pressure = self._pressure * ones
        temperature = self._temperature * ones
        velocity = make_obj_array([self._velocity[i] * ones
                                   for i in range(self._dim)])
        y = make_obj_array([self._massfracs[i] * ones
                            for i in range(self._nspecies)])
        mass = eos.get_density(pressure, temperature, y)
        specmass = mass * y
        mom = mass * velocity
        internal_energy = eos.get_internal_energy(temperature=temperature,
                                                  species_mass_fractions=y)
        kinetic_energy = 0.5 * np.dot(velocity, velocity)
        energy = mass * (internal_energy + kinetic_energy)

        return make_conserved(dim=self._dim, mass=mass, energy=energy,
                              momentum=mom, species_mass=specmass)
Exemple #8
0
def test_inviscid_flux(actx_factory, dim):
    """Identity test - directly check inviscid flux
    routine :func:`mirgecom.euler.inviscid_flux` against the exact
    expected result. This test is designed to fail
    if the flux routine is broken.
    The expected inviscid flux is:
      F(q) = <rhoV, (E+p)V, rho(V.x.V) + pI>
    """
    actx = actx_factory()

    nel_1d = 16

    from meshmode.mesh.generation import generate_regular_rect_mesh

    #    for dim in [1, 2, 3]:
    mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
                                      b=(0.5, ) * dim,
                                      n=(nel_1d, ) * dim)

    order = 3
    discr = EagerDGDiscretization(actx, mesh, order=order)
    eos = IdealSingleGas()

    logger.info(f"Number of {dim}d elems: {mesh.nelements}")

    mass = cl.clrandom.rand(actx.queue, (mesh.nelements, ), dtype=np.float64)
    energy = cl.clrandom.rand(actx.queue, (mesh.nelements, ), dtype=np.float64)
    mom = make_obj_array([
        cl.clrandom.rand(actx.queue, (mesh.nelements, ), dtype=np.float64)
        for i in range(dim)
    ])

    q = join_conserved(dim, mass=mass, energy=energy, momentum=mom)
    cv = split_conserved(dim, q)

    # {{{ create the expected result

    p = eos.pressure(cv)
    escale = (energy + p) / mass

    expected_flux = np.zeros((dim + 2, dim), dtype=object)
    expected_flux[0] = mom
    expected_flux[1] = mom * make_obj_array([escale])

    for i in range(dim):
        for j in range(dim):
            expected_flux[2 + i,
                          j] = (mom[i] * mom[j] / mass + (p if i == j else 0))

    # }}}

    from mirgecom.euler import inviscid_flux

    flux = inviscid_flux(discr, eos, q)
    flux_resid = flux - expected_flux

    for i in range(dim + 2, dim):
        for j in range(dim):
            assert (la.norm(flux_resid[i, j].get())) == 0.0
Exemple #9
0
def make_surface_particle_array(queue, nparticles, dims, dtype, seed=15):
    if dims == 2:
        def get_2d_knl(dtype):
            knl = lp.make_kernel(
                "{[i]: 0<=i<n}",
                """
                    for i
                        <> phi = 2*M_PI/n * i
                        x[i] = 0.5* (3*cos(phi) + 2*sin(3*phi))
                        y[i] = 0.5* (1*sin(phi) + 1.5*sin(2*phi))
                    end
                    """,
                [
                    lp.GlobalArg("x,y", dtype, shape=lp.auto),
                    lp.ValueArg("n", np.int32),
                    ],
                name="make_surface_dist")

            knl = lp.split_iname(knl, "i", 128, outer_tag="g.0", inner_tag="l.0")

            return knl

        evt, result = get_2d_knl(dtype)(queue, n=nparticles)

        result = [x.ravel() for x in result]

        return make_obj_array(result)
    elif dims == 3:
        n = int(nparticles**0.5)

        def get_3d_knl(dtype):
            knl = lp.make_kernel(
                "{[i,j]: 0<=i,j<n}",
                """
                    for i,j
                        <> phi = 2*M_PI/n * i
                        <> theta = 2*M_PI/n * j
                        x[i,j] = 5*cos(phi) * (3 + cos(theta))
                        y[i,j] = 5*sin(phi) * (3 + cos(theta))
                        z[i,j] = 5*sin(theta)
                    end
                    """,
                [
                    lp.GlobalArg("x,y,z,", dtype, shape=lp.auto),
                    lp.ValueArg("n", np.int32),
                    ])

            knl = lp.split_iname(knl, "i", 16, outer_tag="g.1", inner_tag="l.1")
            knl = lp.split_iname(knl, "j", 16, outer_tag="g.0", inner_tag="l.0")

            return knl

        evt, result = get_3d_knl(dtype)(queue, n=n)

        result = [x.ravel() for x in result]

        return make_obj_array(result)
    else:
        raise NotImplementedError
Exemple #10
0
def make_surface_particle_array(queue, nparticles, dims, dtype, seed=15):
    import loopy as lp

    if dims == 2:
        @first_arg_dependent_memoize_nested
        def get_2d_knl(context, dtype):
            knl = lp.make_kernel(
                "{[i]: 0<=i<n}",
                """
                    <> phi = 2*M_PI/n * i
                    x[i] = 0.5* (3*cos(phi) + 2*sin(3*phi))
                    y[i] = 0.5* (1*sin(phi) + 1.5*sin(2*phi))
                    """,
                [
                    lp.GlobalArg("x,y", dtype, shape=lp.auto),
                    lp.ValueArg("n", np.int32),
                    ],
                name="make_surface_dist")

            knl = lp.split_iname(knl, "i", 128, outer_tag="g.0", inner_tag="l.0")

            return lp.CompiledKernel(context, knl)

        evt, result = get_2d_knl(queue.context, dtype)(queue, n=nparticles)

        result = [x.ravel() for x in result]

        return make_obj_array(result)
    elif dims == 3:
        n = int(nparticles**0.5)

        @first_arg_dependent_memoize_nested
        def get_3d_knl(context, dtype):
            knl = lp.make_kernel(
                "{[i,j]: 0<=i,j<n}",
                """
                    <> phi = 2*M_PI/n * i
                    <> theta = 2*M_PI/n * j
                    x[i,j] = 5*cos(phi) * (3 + cos(theta))
                    y[i,j] = 5*sin(phi) * (3 + cos(theta))
                    z[i,j] = 5*sin(theta)
                    """,
                [
                    lp.GlobalArg("x,y,z,", dtype, shape=lp.auto),
                    lp.ValueArg("n", np.int32),
                    ])

            knl = lp.split_iname(knl, "i", 16, outer_tag="g.1", inner_tag="l.1")
            knl = lp.split_iname(knl, "j", 16, outer_tag="g.0", inner_tag="l.0")

            return lp.CompiledKernel(context, knl)

        evt, result = get_3d_knl(queue.context, dtype)(queue, n=n)

        result = [x.ravel() for x in result]

        return make_obj_array(result)
    else:
        raise NotImplementedError
Exemple #11
0
def test_velocity_gradient_eoc(actx_factory, dim):
    """Test that the velocity gradient converges at the proper rate."""
    from mirgecom.fluid import velocity_gradient
    actx = actx_factory()

    order = 3

    from pytools.convergence import EOCRecorder
    eoc = EOCRecorder()

    nel_1d_0 = 4
    for hn1 in [1, 2, 3, 4]:

        nel_1d = hn1 * nel_1d_0
        h = 1/nel_1d

        from meshmode.mesh.generation import generate_regular_rect_mesh
        mesh = generate_regular_rect_mesh(
            a=(1.0,) * dim, b=(2.0,) * dim, nelements_per_axis=(nel_1d,) * dim
        )

        discr = EagerDGDiscretization(actx, mesh, order=order)
        nodes = thaw(actx, discr.nodes())
        zeros = discr.zeros(actx)
        energy = zeros + 2.5

        mass = nodes[dim-1]*nodes[dim-1]
        velocity = make_obj_array([actx.np.cos(nodes[i]) for i in range(dim)])
        mom = mass*velocity

        q = join_conserved(dim, mass=mass, energy=energy, momentum=mom)
        cv = split_conserved(dim, q)

        grad_q = obj_array_vectorize(discr.grad, q)
        grad_cv = split_conserved(dim, grad_q)

        grad_v = velocity_gradient(discr, cv, grad_cv)

        def exact_grad_row(xdata, gdim, dim):
            exact_grad_row = make_obj_array([zeros for _ in range(dim)])
            exact_grad_row[gdim] = -actx.np.sin(xdata)
            return exact_grad_row

        comp_err = make_obj_array([
            discr.norm(grad_v[i] - exact_grad_row(nodes[i], i, dim), np.inf)
            for i in range(dim)])
        err_max = comp_err.max()
        eoc.add_data_point(h, err_max)

    logger.info(eoc)
    assert (
        eoc.order_estimate() >= order - 0.5
        or eoc.max_error() < 1e-9
    )
Exemple #12
0
def test_species_mass_gradient(actx_factory, dim):
    """Test gradY structure and values against exact."""
    actx = actx_factory()
    nel_1d = 4

    from meshmode.mesh.generation import generate_regular_rect_mesh
    mesh = generate_regular_rect_mesh(
        a=(1.0,) * dim, b=(2.0,) * dim, nelements_per_axis=(nel_1d,) * dim
    )

    order = 1

    discr = EagerDGDiscretization(actx, mesh, order=order)
    nodes = thaw(actx, discr.nodes())
    zeros = discr.zeros(actx)
    ones = zeros + 1

    nspecies = 2*dim
    mass = 2*ones  # make mass != 1
    energy = zeros + 2.5
    velocity = make_obj_array([ones for _ in range(dim)])
    mom = mass * velocity
    # assemble y so that each one has simple, but unique grad components
    y = make_obj_array([ones for _ in range(nspecies)])
    for idim in range(dim):
        ispec = 2*idim
        y[ispec] = ispec*(idim*dim+1)*sum([(iidim+1)*nodes[iidim]
                                           for iidim in range(dim)])
        y[ispec+1] = -y[ispec]
    species_mass = mass*y

    cv = make_conserved(dim, mass=mass, energy=energy, momentum=mom,
                        species_mass=species_mass)
    from grudge.op import local_grad
    grad_cv = local_grad(discr, cv)

    from mirgecom.fluid import species_mass_fraction_gradient
    grad_y = species_mass_fraction_gradient(cv, grad_cv)

    assert grad_y.shape == (nspecies, dim)
    from meshmode.dof_array import DOFArray
    assert type(grad_y[0, 0]) == DOFArray

    def inf_norm(x):
        return actx.to_numpy(discr.norm(x, np.inf))

    tol = 1e-11
    for idim in range(dim):
        ispec = 2*idim
        exact_grad = np.array([(ispec*(idim*dim+1))*(iidim+1)
                                for iidim in range(dim)])
        assert inf_norm(grad_y[ispec] - exact_grad) < tol
        assert inf_norm(grad_y[ispec+1] + exact_grad) < tol
Exemple #13
0
def cross_rank_trace_pairs(dcoll: DiscretizationCollection,
                           ary,
                           tag=None) -> list:
    r"""Get a :class:`list` of *ary* trace pairs for each partition boundary.

    For each partition boundary, the field data values in *ary* are
    communicated to/from the neighboring partition. Presumably, this
    communication is MPI (but strictly speaking, may not be, and this
    routine is agnostic to the underlying communication).

    For each face on each partition boundary, a
    :class:`TracePair` is created with the locally, and
    remotely owned partition boundary face data as the `internal`, and `external`
    components, respectively. Each of the TracePair components are structured
    like *ary*.

    :arg ary: a single :class:`~meshmode.dof_array.DOFArray`, or an object
        array of :class:`~meshmode.dof_array.DOFArray`\ s
        of arbitrary shape.
    :returns: a :class:`list` of :class:`TracePair` objects.
    """
    if isinstance(ary, np.ndarray):
        oshape = ary.shape
        comm_vec = ary.flatten()

        n, = comm_vec.shape
        result = {}
        # FIXME: Batch this communication rather than
        # doing it in sequence.
        for ivec in range(n):
            for rank_tpair in _cross_rank_trace_pairs_scalar_field(
                    dcoll, comm_vec[ivec]):
                assert isinstance(rank_tpair.dd.domain_tag,
                                  dof_desc.DTAG_BOUNDARY)
                assert isinstance(rank_tpair.dd.domain_tag.tag, BTAG_PARTITION)
                result[rank_tpair.dd.domain_tag.tag.part_nr, ivec] = rank_tpair

        return [
            TracePair(dd=dof_desc.as_dofdesc(
                dof_desc.DTAG_BOUNDARY(BTAG_PARTITION(remote_rank))),
                      interior=make_obj_array(
                          [result[remote_rank, i].int
                           for i in range(n)]).reshape(oshape),
                      exterior=make_obj_array(
                          [result[remote_rank, i].ext
                           for i in range(n)]).reshape(oshape))
            for remote_rank in connected_ranks(dcoll)
        ]
    else:
        return _cross_rank_trace_pairs_scalar_field(dcoll, ary, tag=tag)
Exemple #14
0
def xyz_to_tangential(xyz_vec, where=None):
    ambient_dim = len(xyz_vec)
    tonb = tangential_onb(ambient_dim, where=where)
    return make_obj_array([
        np.dot(tonb[:, i], xyz_vec)
        for i in range(ambient_dim - 1)
        ])
Exemple #15
0
 def polyfn(coeff):  # , x_vec):
     # r = actx.np.sqrt(np.dot(nodes, nodes))
     r = nodes[0]
     result = 0
     for n, a in enumerate(coeff):
         result += a * r**n
     return make_obj_array([result])
Exemple #16
0
def _small_mat_eigenvalues(mat):
    m, n = mat.shape
    if m != n:
        raise ValueError("eigenvalues only make sense for square matrices")

    if m == 1:
        return make_obj_array([mat[0, 0]])
    elif m == 2:
        (a, b), (c, d) = mat
        return make_obj_array([
                -(sqrt(d**2-2*a*d+4*b*c+a**2)-d-a)/2,
                 (sqrt(d**2-2*a*d+4*b*c+a**2)+d+a)/2
                ])
    else:
        raise NotImplementedError(
                "eigenvalue formula for %dx%d matrices" % (m, n))
Exemple #17
0
    def nodes(self):
        r"""
        :returns: object array of shape ``(ambient_dim,)`` containing
            :class:`~meshmode.dof_array.DOFArray`\ s of node coordinates.
        """

        actx = self._setup_actx

        @memoize_in(actx, (Discretization, "nodes_prg"))
        def prg():
            return make_loopy_program("""{[iel,idof,j]:
                    0<=iel<nelements and
                    0<=idof<ndiscr_nodes and
                    0<=j<nmesh_nodes}""",
                                      """
                    result[iel, idof] = \
                        sum(j, resampling_mat[idof, j] * nodes[iel, j])
                    """,
                                      name="nodes")

        return make_obj_array([
            _DOFArray.from_list(None, [
                actx.freeze(
                    actx.call_loopy(
                        prg(),
                        resampling_mat=actx.from_numpy(
                            grp.from_mesh_interp_matrix()),
                        nodes=actx.from_numpy(
                            grp.mesh_el_group.nodes[iaxis]))["result"])
                for grp in self.groups
            ]) for iaxis in range(self.ambient_dim)
        ])
Exemple #18
0
def make_normal_particle_array(queue, nparticles, dims, dtype, seed=15):
    from pyopencl.clrandom import PhiloxGenerator
    rng = PhiloxGenerator(queue.context, seed=seed)

    return make_obj_array([
        rng.normal(queue, nparticles, dtype=dtype)
        for i in range(dims)])
Exemple #19
0
    def matvec(self, x):
        if isinstance(x, np.ndarray):
            x = cl.array.to_device(self.queue, x)
            out_host = True
        else:
            out_host = False

        do_split = len(self.starts_and_ends) > 1
        from pytools.obj_array import make_obj_array

        if do_split:
            x = make_obj_array(
                    [x[start:end] for start, end in self.starts_and_ends])

        args = self.extra_args.copy()
        args[self.arg_name] = x
        result = self.bound_expr(self.queue, **args)

        if do_split:
            # re-join what was split
            joined_result = cl.array.empty(self.queue, self.total_dofs,
                    np.complex128)  # FIXME
            for res_i, (start, end) in zip(result, self.starts_and_ends):
                joined_result[start:end] = res_i
            result = joined_result

        if out_host:
            result = result.get()

        return result
Exemple #20
0
def _small_mat_inverse(mat):
    m, n = mat.shape
    if m != n:
        raise ValueError("inverses only make sense for square matrices")

    if m == 1:
        return make_obj_array([1/mat[0, 0]])
    elif m == 2:
        (a, b), (c, d) = mat
        return 1/(a*d-b*c) * make_obj_array([
            [d, -b],
            [-c, a],
            ])
    else:
        raise NotImplementedError(
                "inverse formula for %dx%d matrices" % (m, n))
Exemple #21
0
 def my_rhs(t, state):
     cv, tseed = state
     fluid_state = make_fluid_state(cv, gas_model, temperature_seed=tseed)
     return make_obj_array(
         [euler_operator(discr, state=fluid_state, time=t,
                         boundaries=boundaries, gas_model=gas_model),
          0*tseed])
Exemple #22
0
    def full_output_zeros(self, template_ary):
        """This includes QBX and non-QBX targets."""

        from pytools.obj_array import make_obj_array
        return make_obj_array([
                np.zeros(self.tree.ntargets, self.tree_indep.dtype)
                for k in self.tree_indep.outputs])
Exemple #23
0
    def representation(self, unknown, i_domain):
        """
        :return: a symbolic expression for the representation of the PDE solution
            in domain number *i_domain*.
        """
        unk = self._structured_unknown(unknown, with_l2_weights=False)

        result = []

        for field_kind in self.field_kinds:
            if not self.is_field_present(field_kind):
                continue

            field_result = 0
            for i_interface, (i_domain_outer, i_domain_inner, interface_id) in (
                    enumerate(self.interfaces)):
                if i_domain_outer == i_domain:
                    side = self.side_out
                elif i_domain_inner == i_domain:
                    side = self.side_in
                else:
                    continue

                my_unk = unk[side, field_kind, i_interface]
                if my_unk:
                    field_result += sym.S(
                            self.kernel,
                            my_unk,
                            source=interface_id,
                            k=self.domain_K_exprs[i_domain])

            result.append(field_result)

        from pytools.obj_array import make_obj_array
        return make_obj_array(result)
Exemple #24
0
def test_area_query_balls_outside_bbox(ctx_getter, dims, do_plot=False):
    """
    The input to the area query includes balls whose centers are not within
    the tree bounding box.
    """
    ctx = ctx_getter()
    queue = cl.CommandQueue(ctx)

    nparticles = 10**4
    dtype = np.float64

    particles = make_normal_particle_array(queue, nparticles, dims, dtype)

    if do_plot:
        import matplotlib.pyplot as pt
        pt.plot(particles[0].get(), particles[1].get(), "x")

    from boxtree import TreeBuilder
    tb = TreeBuilder(ctx)

    queue.finish()
    tree, _ = tb(queue, particles, max_particles_in_box=30, debug=True)

    nballs = 10**4
    from pyopencl.clrandom import PhiloxGenerator
    rng = PhiloxGenerator(ctx, seed=13)
    bbox_min = tree.bounding_box[0].min()
    bbox_max = tree.bounding_box[1].max()
    from pytools.obj_array import make_obj_array
    ball_centers = make_obj_array([
        rng.uniform(queue, nballs, dtype=dtype, a=bbox_min-1, b=bbox_max+1)
        for i in range(dims)])
    ball_radii = cl.array.empty(queue, nballs, dtype).fill(0.1)

    run_area_query_test(ctx, queue, tree, ball_centers, ball_radii)
Exemple #25
0
def test_norm_obj_array(actx_factory, p):
    """Test :func:`grudge.symbolic.operators.norm` for object arrays."""

    actx = actx_factory()

    dim = 2
    mesh = mgen.generate_regular_rect_mesh(a=(-0.5, ) * dim,
                                           b=(0.5, ) * dim,
                                           nelements_per_axis=(8, ) * dim,
                                           order=1)
    discr = DiscretizationCollection(actx, mesh, order=4)

    w = make_obj_array([1.0, 2.0, 3.0])[:dim]

    # {{ scalar

    sym_w = sym.var("w")
    norm = bind(discr, sym.norm(p, sym_w))(actx, w=w[0])

    norm_exact = w[0]
    logger.info("norm: %.5e %.5e", norm, norm_exact)
    assert abs(norm - norm_exact) < 1.0e-14

    # }}}

    # {{{ vector

    sym_w = sym.make_sym_array("w", dim)
    norm = bind(discr, sym.norm(p, sym_w))(actx, w=w)

    norm_exact = np.sqrt(np.sum(w**2)) if p == 2 else np.max(w)
    logger.info("norm: %.5e %.5e", norm, norm_exact)
    assert abs(norm - norm_exact) < 1.0e-14
Exemple #26
0
 def tangent(self):
     self.arguments["tangent"] = \
             lp.GlobalArg("tangent", self.geometry_dtype,
                     shape=("ntargets", self.dim), order="C")
     from pytools.obj_array import make_obj_array
     return make_obj_array(
         [parse("tangent[itgt, %d]" % i) for i in range(self.dim)])
Exemple #27
0
def test_flatten_unflatten(actx_factory):
    actx = actx_factory()

    ambient_dim = 2
    from meshmode.mesh.generation import generate_regular_rect_mesh
    mesh = generate_regular_rect_mesh(a=(-0.5, ) * ambient_dim,
                                      b=(+0.5, ) * ambient_dim,
                                      n=(3, ) * ambient_dim,
                                      order=1)
    discr = Discretization(actx, mesh, PolynomialWarpAndBlendGroupFactory(3))
    a = np.random.randn(discr.ndofs)

    from meshmode.dof_array import flatten, unflatten
    a_round_trip = actx.to_numpy(
        flatten(unflatten(actx, discr, actx.from_numpy(a))))
    assert np.array_equal(a, a_round_trip)

    from meshmode.dof_array import flatten_to_numpy, unflatten_from_numpy
    a_round_trip = flatten_to_numpy(actx, unflatten_from_numpy(actx, discr, a))
    assert np.array_equal(a, a_round_trip)

    x = thaw(discr.nodes(), actx)
    avg_mass = DOFArray(
        actx,
        tuple([(np.pi + actx.zeros((grp.nelements, 1), a.dtype))
               for grp in discr.groups]))

    c = MyContainer(name="flatten",
                    mass=avg_mass,
                    momentum=make_obj_array([x, x, x]),
                    enthalpy=x)

    from meshmode.dof_array import unflatten_like
    c_round_trip = unflatten_like(actx, flatten(c), c)
    assert flat_norm(c - c_round_trip) < 1.0e-8
Exemple #28
0
 def map_nodes(self, expr):
     discr = self.discr_dict[expr.where]
     from pytools.obj_array import make_obj_array
     return MultiVector(
             make_obj_array([
                 prim.NodeCoordinateComponent(i, expr.where)
                 for i in range(discr.ambient_dim)]))
Exemple #29
0
    def get_boundaries(discr, actx, t):
        nodes = thaw(actx, discr.nodes())

        def sym_eval(expr):
            return sym.EvaluationMapper({"x": nodes, "t": t})(expr)

        exact_u = sym_eval(sym_u)
        exact_grad_u = make_obj_array(sym_eval(sym.grad(dim, sym_u)))

        boundaries = {}

        for i in range(dim - 1):
            lower_btag = DTAG_BOUNDARY("-" + str(i))
            upper_btag = DTAG_BOUNDARY("+" + str(i))
            upper_grad_u = discr.project("vol", upper_btag, exact_grad_u)
            normal = thaw(actx, discr.normal(upper_btag))
            upper_grad_u_dot_n = np.dot(upper_grad_u, normal)
            boundaries[lower_btag] = NeumannDiffusionBoundary(0.)
            boundaries[upper_btag] = NeumannDiffusionBoundary(
                upper_grad_u_dot_n)

        lower_btag = DTAG_BOUNDARY("-" + str(dim - 1))
        upper_btag = DTAG_BOUNDARY("+" + str(dim - 1))
        upper_u = discr.project("vol", upper_btag, exact_u)
        boundaries[lower_btag] = DirichletDiffusionBoundary(0.)
        boundaries[upper_btag] = DirichletDiffusionBoundary(upper_u)

        return boundaries
Exemple #30
0
    def map_int_g_ds(self, expr):
        dsource = self.rec(expr.dsource)

        ambient_dim = self.ambient_dim

        from sumpy.kernel import KernelDimensionSetter
        kernel = _insert_source_derivative_into_kernel(
                KernelDimensionSetter(ambient_dim)(expr.kernel))

        from pytools.obj_array import make_obj_array
        nabla = MultiVector(make_obj_array(
            [prim.NablaComponent(axis, None)
                for axis in range(ambient_dim)]))

        kernel_arguments = dict(
                (name, self.rec(arg_expr))
                for name, arg_expr in expr.kernel_arguments.items()
                )

        def add_dir_vec_to_kernel_args(coeff):
            result = kernel_arguments.copy()
            result[_DIR_VEC_NAME] = _get_dir_vec(coeff, ambient_dim)
            return result

        rec_operand = prim.cse(self.rec(expr.density))
        return (dsource*nabla).map(
                lambda coeff: prim.IntG(
                    kernel,
                    rec_operand, expr.qbx_forced_limit, expr.source, expr.target,
                    kernel_arguments=add_dir_vec_to_kernel_args(coeff)))
Exemple #31
0
 def map_nabla(self, expr):
     from pytools.obj_array import make_obj_array
     return MultiVector(
         make_obj_array([
             prim.NablaComponent(axis, expr.nabla_id)
             for axis in range(self.ambient_dim)
         ]))
Exemple #32
0
    def compute_short_lists(self, queue, wait_for=None):
        """balls --> overlapping leaves
        """
        mesh = self.discr.mesh
        if len(mesh.groups) > 1:
            raise NotImplementedError("Mixed elements not supported")
        melgrp = mesh.groups[0]
        ball_centers_host = (np.max(melgrp.nodes, axis=2) +
                             np.min(melgrp.nodes, axis=2)) / 2
        ball_radii_host = np.max(
            np.max(melgrp.nodes, axis=2) - np.min(melgrp.nodes, axis=2),
            axis=0) / 2

        ball_centers = make_obj_array([
            cl.array.to_device(queue, center_coord_comp)
            for center_coord_comp in ball_centers_host
        ])
        ball_radii = cl.array.to_device(queue, ball_radii_host)

        area_query_result, evt = self.area_query_builder(queue,
                                                         self.tree,
                                                         ball_centers,
                                                         ball_radii,
                                                         peer_lists=None,
                                                         wait_for=wait_for)
        return area_query_result, evt
Exemple #33
0
    def __init__(self,
                 *,
                 dim=1,
                 nspecies=0,
                 rho0=1.0,
                 p0=1.0,
                 center=None,
                 velocity=None,
                 spec_y0s=None,
                 spec_amplitudes=None,
                 spec_centers=None):
        r"""Initialize MulticomponentLump parameters.

        Parameters
        ----------
        dim: int
            specify the number of dimensions for the lump
        rho0: float
            specifies the value of $\rho_0$
        p0: float
            specifies the value of $p_0$
        center: numpy.ndarray
            center of lump, shape ``(dim,)``
        velocity: numpy.ndarray
            fixed flow velocity used for exact solution at t != 0,
            shape ``(dim,)``
        """
        if center is None:
            center = np.zeros(shape=(dim, ))
        if velocity is None:
            velocity = np.zeros(shape=(dim, ))
        if center.shape != (dim, ) or velocity.shape != (dim, ):
            raise ValueError(f"Expected {dim}-dimensional vector inputs.")

        if nspecies > 0:
            if spec_y0s is None:
                spec_y0s = np.ones(shape=(nspecies, ))
            if spec_centers is None:
                spec_centers = make_obj_array(
                    [np.zeros(shape=dim, ) for i in range(nspecies)])
            if spec_amplitudes is None:
                spec_amplitudes = np.ones(shape=(nspecies, ))
            if len(spec_y0s) != nspecies or\
               len(spec_amplitudes) != nspecies or\
                   len(spec_centers) != nspecies:
                raise ValueError(f"Expected nspecies={nspecies} inputs.")
            for i in range(nspecies):
                if len(spec_centers[i]) != dim:
                    raise ValueError(f"Expected {dim}-dimensional "
                                     f"inputs for spec_centers.")

        self._nspecies = nspecies
        self._dim = dim
        self._velocity = velocity
        self._center = center
        self._p0 = p0
        self._rho0 = rho0
        self._spec_y0s = spec_y0s
        self._spec_centers = spec_centers
        self._spec_amplitudes = spec_amplitudes
Exemple #34
0
def sym_wave(dim, sym_phi):
    """Return symbolic expressions for the wave equation system given a desired
    solution. (Note: In order to support manufactured solutions, we modify the wave
    equation to add a source term (f). If the solution is exact, this term should
    be 0.)
    """

    sym_c = pmbl.var("c")
    sym_coords = prim.make_sym_vector("x", dim)
    sym_t = pmbl.var("t")

    # f = phi_tt - c^2 * div(grad(phi))
    sym_f = sym.diff(sym_t)(sym.diff(sym_t)(sym_phi)) - sym_c**2\
                * sym.div(sym.grad(dim, sym_phi))

    # u = phi_t
    sym_u = sym.diff(sym_t)(sym_phi)

    # v = c*grad(phi)
    sym_v = [sym_c * sym.diff(sym_coords[i])(sym_phi) for i in range(dim)]

    # rhs(u part) = c*div(v) + f
    # rhs(v part) = c*grad(u)
    sym_rhs = flat_obj_array(sym_c * sym.div(sym_v) + sym_f,
                             make_obj_array([sym_c]) * sym.grad(dim, sym_u))

    return sym_u, sym_v, sym_f, sym_rhs
Exemple #35
0
    def matvec(self, x):
        if isinstance(x, np.ndarray):
            x = cl.array.to_device(self.queue, x)
            out_host = True
        else:
            out_host = False

        do_split = len(self.starts_and_ends) > 1
        from pytools.obj_array import make_obj_array

        if do_split:
            x = make_obj_array(
                [x[start:end] for start, end in self.starts_and_ends])

        args = self.extra_args.copy()
        args[self.arg_name] = x
        result = self.bound_expr(self.queue, **args)

        if do_split:
            # re-join what was split
            joined_result = cl.array.empty(self.queue, self.total_dofs,
                                           self.dtype)
            for res_i, (start, end) in zip(result, self.starts_and_ends):
                joined_result[start:end] = res_i
            result = joined_result

        if out_host:
            result = result.get()

        return result
Exemple #36
0
def make_normal_particle_array(queue, nparticles, dims, dtype, seed=15):
    from pyopencl.clrandom import PhiloxGenerator
    rng = PhiloxGenerator(queue.context, seed=seed)

    return make_obj_array([
        rng.normal(queue, nparticles, dtype=dtype)
        for i in range(dims)])
Exemple #37
0
def test_container_norm(actx_factory, ord):
    actx = actx_factory()

    ary_dof, ary_of_dofs, mat_of_dofs, dc_of_dofs = _get_test_containers(actx)

    from pytools.obj_array import make_obj_array
    c = MyContainer(name="hey",
                    mass=1,
                    momentum=make_obj_array([2, 3]),
                    enthalpy=5)
    n1 = actx.np.linalg.norm(make_obj_array([c, c]), ord)
    n2 = np.linalg.norm([1, 2, 3, 5] * 2, ord)

    assert abs(n1 - n2) < 1e-12
    assert abs(flat_norm(ary_dof, ord) -
               actx.np.linalg.norm(ary_dof, ord)) < 1e-12
Exemple #38
0
    def representation(self, unknown, i_domain):
        """
        :return: a symbolic expression for the representation of the PDE solution
            in domain number *i_domain*.
        """
        unk = self._structured_unknown(unknown, with_l2_weights=False)

        result = []

        for field_kind in self.field_kinds:
            if not self.is_field_present(field_kind):
                continue

            field_result = 0
            for i_interface, (i_domain_outer, i_domain_inner,
                              interface_id) in (enumerate(self.interfaces)):
                if i_domain_outer == i_domain:
                    side = self.side_out
                elif i_domain_inner == i_domain:
                    side = self.side_in
                else:
                    continue

                my_unk = unk[side, field_kind, i_interface]
                if my_unk:
                    field_result += sym.S(self.kernel,
                                          my_unk,
                                          source=interface_id,
                                          k=self.domain_K_exprs[i_domain])

            result.append(field_result)

        from pytools.obj_array import make_obj_array
        return make_obj_array(result)
Exemple #39
0
    def __call__(self, arg):
        if isinstance(arg, int) and arg == 0:
            return 0
        from pytools.obj_array import make_obj_array
        from hedge.optemplate.primitives import OperatorBinding

        return make_obj_array([OperatorBinding(FluxOperator(f), arg) for f in self.fluxes])
Exemple #40
0
    def add_div_bcs(self, tgt, bc_getter, dirichlet_tags, neumann_tags,
            stab_term, adjust_flux, flux_v, flux_arg_int,
            grad_flux_arg_count):
        from pytools.obj_array import make_obj_array, join_fields
        n_times = tgt.normal_times_flux

        def unwrap_cse(expr):
            from pymbolic.primitives import CommonSubexpression
            if isinstance(expr, CommonSubexpression):
                return expr.child
            else:
                return expr

        for tag in dirichlet_tags:
            dir_bc_w = join_fields(
                    [0]*grad_flux_arg_count,
                    [bc_getter(tag, unwrap_cse(vol_expr)) for vol_expr in
                        flux_arg_int[grad_flux_arg_count:]])
            tgt.add_boundary_flux(
                    adjust_flux(n_times(flux_v.int-stab_term)),
                    flux_arg_int, dir_bc_w, tag)

        loc_bc_vec = make_obj_array([0]*len(flux_arg_int))

        for tag in neumann_tags:
            neu_bc_w = join_fields(
                    NeumannBCGenerator(tag, bc_getter(tag, None))(tgt.operand),
                    [0]*len(flux_arg_int))

            tgt.add_boundary_flux(
                    adjust_flux(n_times(flux_v.ext)),
                    loc_bc_vec, neu_bc_w, tag)
Exemple #41
0
    def add_div_bcs(self, tgt, bc_getter, dirichlet_tags, neumann_tags,
                    stab_term, adjust_flux, flux_v, flux_arg_int,
                    grad_flux_arg_count):
        from pytools.obj_array import make_obj_array, join_fields
        n_times = tgt.normal_times_flux

        def unwrap_cse(expr):
            from pymbolic.primitives import CommonSubexpression
            if isinstance(expr, CommonSubexpression):
                return expr.child
            else:
                return expr

        for tag in dirichlet_tags:
            dir_bc_w = join_fields([0] * grad_flux_arg_count, [
                bc_getter(tag, unwrap_cse(vol_expr))
                for vol_expr in flux_arg_int[grad_flux_arg_count:]
            ])
            tgt.add_boundary_flux(adjust_flux(n_times(flux_v.int - stab_term)),
                                  flux_arg_int, dir_bc_w, tag)

        loc_bc_vec = make_obj_array([0] * len(flux_arg_int))

        for tag in neumann_tags:
            neu_bc_w = join_fields(
                NeumannBCGenerator(tag, bc_getter(tag, None))(tgt.operand),
                [0] * len(flux_arg_int))

            tgt.add_boundary_flux(adjust_flux(n_times(flux_v.ext)), loc_bc_vec,
                                  neu_bc_w, tag)
Exemple #42
0
    def full_output_zeros(self):
        """This includes QBX and non-QBX targets."""

        from pytools.obj_array import make_obj_array
        return make_obj_array([
                np.zeros(self.tree.ntargets, self.dtype)
                for k in self.outputs])
Exemple #43
0
def test_function_symbol_array(ctx_factory, array_type):
    ctx = ctx_factory()
    queue = cl.CommandQueue(ctx)
    actx = PyOpenCLArrayContext(queue)

    from meshmode.mesh.generation import generate_regular_rect_mesh
    dim = 2
    mesh = generate_regular_rect_mesh(a=(-0.5, ) * dim,
                                      b=(0.5, ) * dim,
                                      n=(8, ) * dim,
                                      order=4)
    discr = DGDiscretizationWithBoundaries(actx, mesh, order=4)
    volume_discr = discr.discr_from_dd(sym.DD_VOLUME)
    ndofs = sum(grp.ndofs for grp in volume_discr.groups)

    import pyopencl.clrandom  # noqa: F401
    if array_type == "scalar":
        sym_x = sym.var("x")
        x = unflatten(actx, volume_discr,
                      cl.clrandom.rand(queue, ndofs, dtype=np.float))
    elif array_type == "vector":
        sym_x = sym.make_sym_array("x", dim)
        x = make_obj_array([
            unflatten(actx, volume_discr,
                      cl.clrandom.rand(queue, ndofs, dtype=np.float))
            for _ in range(dim)
        ])
    else:
        raise ValueError("unknown array type")

    norm = bind(discr, sym.norm(2, sym_x))(x=x)
    assert isinstance(norm, float)
    def get_operator(self, ambient_dim, qbx_forced_limit="avg"):
        knl = self.knl_class(ambient_dim)
        kwargs = self.knl_sym_kwargs.copy()
        kwargs["qbx_forced_limit"] = qbx_forced_limit

        if self.op_type == "scalar":
            sym_u = sym.var("u")
            sym_op = sym.S(knl, sym_u, **kwargs)
        elif self.op_type == "scalar_mixed":
            sym_u = sym.var("u")
            sym_op = sym.S(knl, 0.3 * sym_u, **kwargs) \
                    + sym.D(knl, 0.5 * sym_u, **kwargs)
        elif self.op_type == "vector":
            sym_u = sym.make_sym_vector("u", ambient_dim)

            sym_op = make_obj_array([
                sym.Sp(knl, sym_u[0], **kwargs) +
                sym.D(knl, sym_u[1], **kwargs),
                sym.S(knl, 0.4 * sym_u[0], **kwargs) +
                0.3 * sym.D(knl, sym_u[0], **kwargs)
            ])
        else:
            raise ValueError(f"unknown operator type: '{self.op_type}'")

        sym_op = 0.5 * sym_u + sym_op
        return sym_u, sym_op
Exemple #45
0
 def tangent(self):
     self.arguments["tangent"] = \
             lp.GlobalArg("tangent", self.geometry_dtype,
                     shape=("ntargets", self.dim), order="C")
     from pytools.obj_array import make_obj_array
     return make_obj_array([
         parse("tangent[itgt, %d]" % i)
         for i in range(self.dim)])
Exemple #46
0
 def potential_zeros(self):
     from pytools.obj_array import make_obj_array
     return make_obj_array([
             cl.array.zeros(
                 self.queue,
                 self.tree.ntargets,
                 dtype=self.dtype)
             for k in self.code.out_kernels])
Exemple #47
0
def curl(vec):
    from pytools import levi_civita
    from pytools.obj_array import make_obj_array

    return make_obj_array([
        sum(
            levi_civita((l, m, n)) * dd_axis(m, 3, vec[n])
            for m in range(3) for n in range(3))
        for l in range(3)])
Exemple #48
0
def nodes(ambient_dim, where=None):
    """Return a :class:`pymbolic.geometric_algebra.MultiVector` of node
    locations.
    """

    return MultiVector(
            make_obj_array([
                NodeCoordinateComponent(i, where)
                for i in range(ambient_dim)]))
Exemple #49
0
def curl_S_volume(kernel, arg):
    from pytools import levi_civita
    from pytools.obj_array import make_obj_array

    return make_obj_array([
        sum(
            levi_civita((l, m, n)) * IntGdTarget(kernel, arg[n], m)
            for m in range(3) for n in range(3))
        for l in range(3)])
Exemple #50
0
 def src_derivative_dir(self):
     self.arguments["src_derivative_dir"] = \
             lp.GlobalArg("src_derivative_dir",
                     self.geometry_dtype, shape=("ntargets", self.dim),
                     order="C")
     from pytools.obj_array import make_obj_array
     return make_obj_array([
         parse("src_derivative_dir[itgt, %d]" % i)
         for i in range(self.dim)])
Exemple #51
0
def cross(vec_a, vec_b):
    assert len(vec_a) == len(vec_b) == 3

    from pytools import levi_civita
    from pytools.obj_array import make_obj_array
    return make_obj_array([
        sum(
            levi_civita((i, j, k)) * vec_a[j] * vec_b[k]
            for j in range(3) for k in range(3))
        for i in range(3)])
Exemple #52
0
def n_cross(vec, which=None):
    nrm = normal(3, which)

    from pytools import levi_civita
    from pytools.obj_array import make_obj_array
    return make_obj_array([
        sum(
            levi_civita((i, j, k)) * nrm[j] * vec[k]
            for j in range(3) for k in range(3))
        for i in range(3)])
Exemple #53
0
        def make_artificial_diffusion():
            if self.artificial_viscosity_mode not in ["diffusion"]:
                return 0

            dq = self.grad_of_state()

            return make_obj_array([
                self.div(
                    to_vol_quad(self.sensor())*to_vol_quad(dq[i]),
                    to_int_face_quad(self.sensor())*to_int_face_quad(dq[i])) 
                for i in range(dq.shape[0])])
Exemple #54
0
    def apply_diff(self, nabla, operand):
        from pytools.obj_array import make_obj_array, is_obj_array
        if is_obj_array(operand):
            if len(operand) != self.dimensions:
                raise ValueError("operand of apply_diff must have %d dimensions"
                        % self.dimensions)

            return sum(nabla[i](operand[i]) for i in range(self.dimensions))
        else:
            return make_obj_array(
                [nabla[i](operand) for i in range(self.dimensions)])
Exemple #55
0
    def collision_update(self, f_bar):
        from hedge.optemplate.primitives import make_common_subexpression as cse
        rho = cse(self.rho(f_bar), "rho")
        rho_u = self.rho_u(f_bar)
        u = cse(rho_u/rho, "u")

        f_eq_func = self.method.f_equilibrium
        f_eq = make_obj_array([
            f_eq_func(rho, alpha, u) for alpha in range(len(self.method))])

        return f_bar - 1/(self.tau+1/2)*(f_bar - f_eq)
Exemple #56
0
    def output_zeros(self):
        """This ought to be called ``non_qbx_output_zeros``, but since
        it has to override the superclass's behavior to integrate seamlessly,
        it needs to be called just :meth:`output_zeros`.
        """

        nqbtl = self.geo_data.non_qbx_box_target_lists()

        from pytools.obj_array import make_obj_array
        return make_obj_array([
                np.zeros(nqbtl.nfiltered_targets, self.dtype)
                for k in self.outputs])
Exemple #57
0
    def centers(self):
        """ Return an object array of (interleaved) center coordinates.

        ``coord_t [ambient_dim][ncenters]``
        """

        with cl.CommandQueue(self.cl_context) as queue:
            from pytential.qbx.utils import get_interleaved_centers
            from pytools.obj_array import make_obj_array
            return make_obj_array([
                ccomp.with_queue(None)
                for ccomp in get_interleaved_centers(queue, self.lpot_source)])
Exemple #58
0
    def curl(self, arg):
        """Take the curl of the vector quantity *arg*.

        :arg arg: an object array of shape ``(3,)`` containing
            :class:`numpy.ndarrays` with shape ``(npoints_total,)``.
        """
        from pytools import levi_civita
        from pytools.obj_array import make_obj_array
        return make_obj_array([
            sum(
                levi_civita((l, m, n)) * self.diff(m, arg[n])
                for m in range(3) for n in range(3))
            for l in range(3)])
Exemple #59
0
def plot_traversal(ctx_getter, do_plot=False, well_sep_is_n_away=1):
    ctx = ctx_getter()
    queue = cl.CommandQueue(ctx)

    #for dims in [2, 3]:
    for dims in [2]:
        nparticles = 10**4
        dtype = np.float64

        from pyopencl.clrandom import PhiloxGenerator
        rng = PhiloxGenerator(queue.context, seed=15)

        from pytools.obj_array import make_obj_array
        particles = make_obj_array([
            rng.normal(queue, nparticles, dtype=dtype)
            for i in range(dims)])

        # if do_plot:
        #     pt.plot(particles[0].get(), particles[1].get(), "x")

        from boxtree import TreeBuilder
        tb = TreeBuilder(ctx)

        queue.finish()
        tree, _ = tb(queue, particles, max_particles_in_box=30, debug=True)

        from boxtree.traversal import FMMTraversalBuilder
        tg = FMMTraversalBuilder(ctx, well_sep_is_n_away=well_sep_is_n_away)
        trav, _ = tg(queue, tree)

        tree = tree.get(queue=queue)
        trav = trav.get(queue=queue)

        from boxtree.visualization import TreePlotter
        plotter = TreePlotter(tree)
        plotter.draw_tree(fill=False, edgecolor="black")
        #plotter.draw_box_numbers()
        plotter.set_bounding_box()

        from random import randrange, seed  # noqa
        seed(7)

        from boxtree.visualization import draw_box_lists

        #draw_box_lists(randrange(tree.nboxes))
        draw_box_lists(plotter, trav, 320)
        #plotter.draw_box_numbers()

        import matplotlib.pyplot as pt
        pt.show()
Exemple #60
0
                def func_on_scalar_or_vector(func, arg_fields):
                    # No CSE necessary here--the compiler CSE's these
                    # automatically.

                    from hedge.tools import is_obj_array, make_obj_array
                    if is_obj_array(arg_fields):
                        # arg_fields (as an object array) isn't hashable
                        # --make it so by turning it into a tuple
                        arg_fields = tuple(arg_fields)

                        return make_obj_array([
                            func(i, arg_fields)
                            for i in range(len(arg_fields))])
                    else:
                        return func(0, (arg_fields,))