Beispiel #1
0
    def coarsen_multipoles(self, level_start_source_parent_box_nrs,
            source_parent_boxes, mpoles):
        tree = self.tree
        rscale = 1  # FIXME

        from pyfmmlib import h2dmpmp_vec

        # 2 is the last relevant source_level.
        # 1 is the last relevant target_level.
        # (Nobody needs a multipole on level 0, i.e. for the root box.)
        for source_level in range(tree.nlevels-1, 1, -1):
            start, stop = level_start_source_parent_box_nrs[
                            source_level:source_level+2]
            for ibox in source_parent_boxes[start:stop]:
                parent_center = tree.box_centers[:, ibox]
                for child in tree.box_child_ids[:, ibox]:
                    if child:
                        child_center = tree.box_centers[:, child]

                        new_mp = h2dmpmp_vec(
                                self.helmholtz_k,
                                rscale, child_center, mpoles[child],
                                rscale, parent_center, self.nterms)

                        mpoles[ibox] += new_mp[:, 0]
    def coarsen_multipoles(self, parent_boxes, mpoles):
        tree = self.tree
        rscale = 1  # FIXME

        from pyfmmlib import h2dmpmp_vec

        for ibox in parent_boxes:
            parent_center = tree.box_centers[:, ibox]
            for child in tree.box_child_ids[:, ibox]:
                if child:
                    child_center = tree.box_centers[:, child]

                    new_mp = h2dmpmp_vec(self.helmholtz_k, rscale,
                                         child_center, mpoles[child], rscale,
                                         parent_center, self.nterms)

                    mpoles[ibox] += new_mp[:, 0]
    def coarsen_multipoles(self, parent_boxes, mpoles):
        tree = self.tree
        rscale = 1  # FIXME

        from pyfmmlib import h2dmpmp_vec

        for ibox in parent_boxes:
            parent_center = tree.box_centers[:, ibox]
            for child in tree.box_child_ids[:, ibox]:
                if child:
                    child_center = tree.box_centers[:, child]

                    new_mp = h2dmpmp_vec(
                            self.helmholtz_k,
                            rscale, child_center, mpoles[child],
                            rscale, parent_center, self.nterms)

                    mpoles[ibox] += new_mp[:, 0]
Beispiel #4
0
def test_translations():
    nterms = 15
    zk = 3
    rscale = 1

    n = 40
    # centered at the origin, extent [-.5,.5]
    sources = np.random.uniform(size=(n, 2)) - 0.5
    charges = np.random.uniform(size=n)

    targets_center = np.array([10, 0])
    targets = np.random.uniform(size=(n, 2)) - 0.5 + targets_center

    from pyfmmlib import (h2dformmp, h2dmpmp_vec, h2dmploc_vec, h2dlocloc_vec,
                          h2dtaeval_vec, hpotgrad2dall_vec, h2dmpeval_vec)

    ref_value, _, _ = hpotgrad2dall_vec(ifgrad=False,
                                        ifhess=False,
                                        sources=sources.T,
                                        charge=charges,
                                        targets=targets.T,
                                        zk=zk)

    # {{{ multipole 1

    mp1_center = np.array([0, 0])
    ier, mp1 = h2dformmp(zk, rscale, sources.T, charges, mp1_center, nterms)
    assert ier == 0

    mp1_value, _, _ = h2dmpeval_vec(zk,
                                    rscale,
                                    mp1_center,
                                    mp1,
                                    ztarg=targets.T,
                                    ifgrad=False,
                                    ifhess=False)

    assert la.norm(mp1_value - ref_value) / la.norm(ref_value) < 1e-12

    # }}}

    # {{{ multipole 2

    mp2_center = np.array([2, 0])
    mp2 = h2dmpmp_vec(zk, rscale, mp1_center, mp1, rscale, mp2_center, nterms)

    mp2_value, _, _ = h2dmpeval_vec(zk,
                                    rscale,
                                    mp2_center,
                                    mp2,
                                    ztarg=targets.T,
                                    ifgrad=False,
                                    ifhess=False)

    assert la.norm(mp2_value - ref_value) / la.norm(ref_value) < 3e-5

    # }}}

    # {{{ local 1

    loc1_center = targets_center - np.array([1, 0])
    loc1 = h2dmploc_vec(zk, rscale, mp2_center, mp2, rscale, loc1_center,
                        nterms)

    loc1_value, _, _ = h2dtaeval_vec(zk,
                                     rscale,
                                     loc1_center,
                                     loc1,
                                     ztarg=targets.T,
                                     ifgrad=False,
                                     ifhess=False)

    assert la.norm(loc1_value - ref_value) / la.norm(ref_value) < 3e-5

    # }}}

    # {{{ local 2

    loc2_center = targets_center
    loc2 = h2dlocloc_vec(zk, rscale, loc1_center, loc1, rscale, loc2_center,
                         nterms)

    loc2_value, _, _ = h2dtaeval_vec(zk,
                                     rscale,
                                     loc2_center,
                                     loc2,
                                     ztarg=targets.T,
                                     ifgrad=False,
                                     ifhess=False)

    assert la.norm(loc2_value - ref_value) / la.norm(ref_value) < 1e-4
Beispiel #5
0
def test_translations():
    nterms = 15
    zk = 3
    rscale = 1

    n = 40
    # centered at the origin, extent [-.5,.5]
    sources = np.random.uniform(size=(n, 2)) - 0.5
    charges = np.random.uniform(size=n)

    targets_center = np.array([10, 0])
    targets = np.random.uniform(size=(n, 2)) - 0.5 + targets_center

    from pyfmmlib import (h2dformmp, h2dmpmp_vec, h2dmploc_vec,
            h2dlocloc_vec, h2dtaeval_vec, hpotgrad2dall_vec, h2dmpeval_vec)

    ref_value, _, _ = hpotgrad2dall_vec(ifgrad=False, ifhess=False,
            sources=sources.T, charge=charges,
            targets=targets.T, zk=zk)

    # {{{ multipole 1

    mp1_center = np.array([0, 0])
    ier, mp1 = h2dformmp(zk, rscale, sources.T, charges, mp1_center, nterms)
    assert ier == 0

    mp1_value, _, _ = h2dmpeval_vec(zk, rscale, mp1_center, mp1, ztarg=targets.T,
            ifgrad=False, ifhess=False)

    assert la.norm(mp1_value - ref_value) / la.norm(ref_value) < 1e-12

    # }}}

    # {{{ multipole 2

    mp2_center = np.array([2, 0])
    mp2 = h2dmpmp_vec(zk, rscale, mp1_center, mp1, rscale, mp2_center, nterms)

    mp2_value, _, _ = h2dmpeval_vec(zk, rscale, mp2_center, mp2, ztarg=targets.T,
            ifgrad=False, ifhess=False)

    assert la.norm(mp2_value - ref_value) / la.norm(ref_value) < 3e-5

    # }}}

    # {{{ local 1

    loc1_center = targets_center - np.array([1, 0])
    loc1 = h2dmploc_vec(zk, rscale, mp2_center, mp2, rscale, loc1_center, nterms)

    loc1_value, _, _ = h2dtaeval_vec(zk, rscale, loc1_center, loc1,
            ztarg=targets.T, ifgrad=False, ifhess=False)

    assert la.norm(loc1_value - ref_value) / la.norm(ref_value) < 3e-5

    # }}}

    # {{{ local 2

    loc2_center = targets_center
    loc2 = h2dlocloc_vec(zk, rscale, loc1_center, loc1, rscale, loc2_center, nterms)

    loc2_value, _, _ = h2dtaeval_vec(zk, rscale, loc2_center, loc2, ztarg=targets.T,
            ifgrad=False, ifhess=False)

    assert la.norm(loc2_value - ref_value) / la.norm(ref_value) < 1e-4