test_field.py 5.03 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
Theo Steininger's avatar
Theo Steininger committed
13 14 15 16 17
#
# Copyright(C) 2013-2017 Max-Planck-Society
#
# NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik
# and financially supported by the Studienstiftung des deutschen Volkes.
18 19 20 21 22

import unittest

import numpy as np
from numpy.testing import assert_,\
23 24
                          assert_almost_equal,\
                          assert_allclose
25

26
from itertools import product
27 28

from nifty import Field,\
29 30 31
                  RGSpace,\
                  LMSpace,\
                  PowerSpace
32

33
from d2o import distributed_data_object
34

Jait Dixit's avatar
Jait Dixit committed
35
from test.common import expand
36 37


Martin Reinecke's avatar
Martin Reinecke committed
38
SPACES = [RGSpace((4,)), RGSpace((5))]
Theo Steininger's avatar
Theo Steininger committed
39
SPACE_COMBINATIONS = [(), SPACES[0], SPACES[1], SPACES]
40 41 42


class Test_Interface(unittest.TestCase):
43
    @expand(product(SPACE_COMBINATIONS,
Martin Reinecke's avatar
Martin Reinecke committed
44
                    [['distribution_strategy', str],
45 46 47 48 49 50 51 52 53 54
                     ['domain', tuple],
                     ['domain_axes', tuple],
                     ['val', distributed_data_object],
                     ['shape', tuple],
                     ['dim', np.int],
                     ['dof', np.int],
                     ['total_volume', np.float]]))
    def test_return_types(self, domain, attribute_desired_type):
        attribute = attribute_desired_type[0]
        desired_type = attribute_desired_type[1]
55
        f = Field(domain=domain)
56 57
        assert_(isinstance(getattr(f, attribute), desired_type))

Martin Reinecke's avatar
Martin Reinecke committed
58

59 60 61 62 63 64 65 66 67 68
class Test_Functionality(unittest.TestCase):
    @expand(product([True, False], [True, False],
                    [True, False], [True, False],
                    [(1,), (4,), (5,)], [(1,), (6,), (7,)]))
    def test_hermitian_decomposition(self, z1, z2, preserve, complexdata,
                                     s1, s2):
        np.random.seed(123)
        r1 = RGSpace(s1, harmonic=True, zerocenter=(z1,))
        r2 = RGSpace(s2, harmonic=True, zerocenter=(z2,))
        ra = RGSpace(s1+s2, harmonic=True, zerocenter=(z1, z2))
Martin Reinecke's avatar
Martin Reinecke committed
69

Martin Reinecke's avatar
Martin Reinecke committed
70 71
        if preserve:
            complexdata=True
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
        v = np.random.random(s1+s2)
        if complexdata:
            v = v + 1j*np.random.random(s1+s2)
        f1 = Field(ra, val=v, copy=True)
        f2 = Field((r1, r2), val=v, copy=True)
        h1, a1 = Field._hermitian_decomposition((ra,), f1.val, (0,),
                                                ((0, 1,),), preserve)
        h2, a2 = Field._hermitian_decomposition((r1, r2), f2.val, (0, 1),
                                                ((0,), (1,)), preserve)
        h3, a3 = Field._hermitian_decomposition((r1, r2), f2.val, (1, 0),
                                                ((0,), (1,)), preserve)

        assert_almost_equal(h1.get_full_data(), h2.get_full_data())
        assert_almost_equal(a1.get_full_data(), a2.get_full_data())
        assert_almost_equal(h1.get_full_data(), h3.get_full_data())
        assert_almost_equal(a1.get_full_data(), a3.get_full_data())
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123

    @expand(product([RGSpace((8,), harmonic=True,
                             zerocenter=False),
                     RGSpace((8, 8), harmonic=True, distances=0.123,
                             zerocenter=True)],
                    [RGSpace((8,), harmonic=True,
                             zerocenter=False),
                     LMSpace(12)]))
    def test_power_synthesize_analyze(self, space1, space2):
        p1 = PowerSpace(space1)
        spec1 = lambda k: 42/(1+k)**2
        fp1 = Field(p1, val=spec1)

        p2 = PowerSpace(space2)
        spec2 = lambda k: 42/(1+k)**3
        fp2 = Field(p2, val=spec2)

        outer = np.outer(fp1.val.get_full_data(), fp2.val.get_full_data())
        fp = Field((p1, p2), val=outer)

        samples = 1000
        ps1 = 0.
        ps2 = 0.
        for ii in xrange(samples):
            sk = fp.power_synthesize(spaces=(0, 1), real_signal=True)

            sp = sk.power_analyze(spaces=(0, 1), keep_phase_information=False)
            ps1 += sp.sum(spaces=1)/fp2.sum()
            ps2 += sp.sum(spaces=0)/fp1.sum()

        assert_allclose(ps1.val.get_full_data()/samples,
                        fp1.val.get_full_data(),
                        rtol=0.1)
        assert_allclose(ps2.val.get_full_data()/samples,
                        fp2.val.get_full_data(),
                        rtol=0.1)
Martin Reinecke's avatar
Martin Reinecke committed
124 125 126 127 128 129 130 131 132

    def test_vdot(self):
        s=RGSpace((10,))
        f1=Field.from_random("normal",domain=s,dtype=np.complex128)
        f2=Field.from_random("normal",domain=s,dtype=np.complex128)
        assert_allclose(f1.vdot(f2),f1.vdot(f2,spaces=0))
        assert_allclose(f1.vdot(f2),np.conj(f2.vdot(f1)))