Exemplo n.º 1
0
    def multipole_to_local(self,
            level_start_target_or_target_parent_box_nrs,
            target_or_target_parent_boxes,
            starts, lists, mpole_exps):
        tree = self.tree
        local_exps = self.local_expansion_zeros()

        rscale = 1

        from pyfmmlib import h2dmploc_vec

        for itgt_box, tgt_ibox in enumerate(target_or_target_parent_boxes):
            start, end = starts[itgt_box:itgt_box+2]
            tgt_center = tree.box_centers[:, tgt_ibox]

            #print tgt_ibox, "<-", lists[start:end]
            tgt_loc = 0

            for src_ibox in lists[start:end]:
                src_center = tree.box_centers[:, src_ibox]

                tgt_loc = tgt_loc + h2dmploc_vec(
                        self.helmholtz_k,
                        rscale, src_center, mpole_exps[src_ibox],
                        rscale, tgt_center, self.nterms)[:, 0]

            local_exps[tgt_ibox] += tgt_loc

        return local_exps
Exemplo n.º 2
0
    def multipole_to_local(self, target_or_target_parent_boxes, starts, lists,
                           mpole_exps):
        tree = self.tree
        local_exps = self.local_expansion_zeros()

        rscale = 1

        from pyfmmlib import h2dmploc_vec

        for itgt_box, tgt_ibox in enumerate(target_or_target_parent_boxes):
            start, end = starts[itgt_box:itgt_box + 2]
            tgt_center = tree.box_centers[:, tgt_ibox]

            #print tgt_ibox, "<-", lists[start:end]
            tgt_loc = 0

            for src_ibox in lists[start:end]:
                src_center = tree.box_centers[:, src_ibox]

                tgt_loc = tgt_loc + h2dmploc_vec(
                    self.helmholtz_k, rscale, src_center, mpole_exps[src_ibox],
                    rscale, tgt_center, self.nterms)[:, 0]

            local_exps[tgt_ibox] += tgt_loc

        return local_exps
Exemplo n.º 3
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
Exemplo n.º 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