test_adjoint.py 10.3 KB
Newer Older
Martin Reinecke's avatar
Martin Reinecke committed
1
2
3
4
5
6
7
8
9
10
11
12
13
# 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/>.
#
14
# Copyright(C) 2013-2018 Max-Planck-Society
Martin Reinecke's avatar
Martin Reinecke committed
15
16
17
18
#
# NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik
# and financially supported by the Studienstiftung des deutschen Volkes.

19
20
21
22
import unittest
from itertools import product
from test.common import expand

23
24
import nifty5 as ift
import numpy as np
25

26
27
28
_h_RG_spaces = [ift.RGSpace(7, distances=0.2, harmonic=True),
                ift.RGSpace((12, 46), distances=(.2, .3), harmonic=True)]
_h_spaces = _h_RG_spaces + [ift.LMSpace(17)]
Martin Reinecke's avatar
Martin Reinecke committed
29

30
31
32
_p_RG_spaces = [ift.RGSpace(19, distances=0.7),
                ift.RGSpace((1, 2, 3, 6), distances=(0.2, 0.25, 0.34, .8))]
_p_spaces = _p_RG_spaces + [ift.HPSpace(17), ift.GLSpace(8, 13)]
33

34
35
_pow_spaces = [ift.PowerSpace(ift.RGSpace((17, 38), harmonic=True))]

Martin Reinecke's avatar
Martin Reinecke committed
36

37
class Consistency_Tests(unittest.TestCase):
38
39
40
41
42
43
44
45
46
47
48
49
50
51
    @expand(product(_h_spaces + _p_spaces + _pow_spaces,
                    [np.float64, np.complex128]))
    def testOperatorCombinations(self, sp, dtype):
        a = ift.DiagonalOperator(ift.Field.from_random("normal", sp,
                                                        dtype=dtype))
        b = ift.DiagonalOperator(ift.Field.from_random("normal", sp,
                                                        dtype=dtype))
        op = ift.SandwichOperator.make(a, b)
        ift.extra.consistency_check(op, dtype, dtype)
        op = a*b
        ift.extra.consistency_check(op, dtype, dtype)
        op = a+b
        ift.extra.consistency_check(op, dtype, dtype)

52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
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
    @expand(product([(ift.RGSpace(10, harmonic=True), 4, 0),
                     (ift.RGSpace((24, 31), distances=(0.4, 2.34),
                                  harmonic=True), 3, 0),
                     (ift.LMSpace(4), 10, 0)],
                    [np.float64, np.complex128]))
    def testSlopeOperator(self, args, dtype):
        tmp = ift.ExpTransform(ift.PowerSpace(args[0]), args[1], args[2])
        tgt = tmp.domain[0]
        sig = np.array([0.3, 0.13])
        dom = ift.UnstructuredDomain(2)
        op = ift.SlopeOperator(dom, tgt, sig)
        ift.extra.consistency_check(op, dtype, dtype)

    @expand(product(_h_spaces + _p_spaces + _pow_spaces,
                    _h_spaces + _p_spaces + _pow_spaces,
                    [np.float64, np.complex128]))
    def testSelectionOperator(self, sp1, sp2, dtype):
        mdom = ift.MultiDomain.make({'a':sp1, 'b':sp2})
        op = ift.SelectionOperator(mdom, 'a')
        ift.extra.consistency_check(op, dtype, dtype)

    @expand(product(_h_spaces + _p_spaces + _pow_spaces,
                    [np.float64, np.complex128]))
    def testOperatorAdaptor(self, sp, dtype):
        op = ift.DiagonalOperator(ift.Field.from_random("normal", sp,
                                                        dtype=dtype))
        ift.extra.consistency_check(op.adjoint, dtype, dtype)
        ift.extra.consistency_check(op.inverse, dtype, dtype)
        ift.extra.consistency_check(op.inverse.adjoint, dtype, dtype)
        ift.extra.consistency_check(op.adjoint.inverse, dtype, dtype)

    @expand(product(_h_spaces + _p_spaces + _pow_spaces,
                    _h_spaces + _p_spaces + _pow_spaces,
                    [np.float64, np.complex128]))
    def testNullOperator(self, sp1, sp2, dtype):
        op = ift.NullOperator(sp1, sp2)
        ift.extra.consistency_check(op, dtype, dtype)
        mdom1 = ift.MultiDomain.make({'a':sp1})
        mdom2 = ift.MultiDomain.make({'b':sp2})
        op = ift.NullOperator(mdom1, mdom2)
        ift.extra.consistency_check(op, dtype, dtype)
        op = ift.NullOperator(sp1, mdom2)
        ift.extra.consistency_check(op, dtype, dtype)
        op = ift.NullOperator(mdom1, sp2)
        ift.extra.consistency_check(op, dtype, dtype)
        
    @expand(product(_h_spaces + _p_spaces
                        + _pow_spaces,
                    [np.float64, np.complex128]))
    def testMultiAdaptor(self, sp, dtype):
        mdom = ift.MultiDomain.make({'a':sp})
        op = ift.MultiAdaptor(mdom)
        ift.extra.consistency_check(op, dtype, dtype)

    @expand(product(_p_RG_spaces,
                    [np.float64, np.complex128]))
    def testHarmonicSmoothingOperator(self, sp, dtype):
        op = ift.HarmonicSmoothingOperator(sp, 0.1)
        ift.extra.consistency_check(op, dtype, dtype)

    @expand(product(_h_spaces + _p_spaces
Reimar H Leike's avatar
Reimar H Leike committed
113
114
115
                        + _pow_spaces,
                    [np.float64, np.complex128]))
    def testDOFDistributor(self, sp, dtype):
116
        #TODO: Test for DomainTuple
Reimar H Leike's avatar
Reimar H Leike committed
117
118
        if sp.size < 4:
            return
119
120
121
122
        dofdex = np.arange(sp.size).reshape(sp.shape)%3
        dofdex = ift.Field.from_global_data(sp, dofdex)
        op = ift.DOFDistributor(dofdex)
        ift.extra.consistency_check(op, dtype, dtype)
Reimar H Leike's avatar
bugfic    
Reimar H Leike committed
123

Reimar H Leike's avatar
Reimar H Leike committed
124

125
    @expand(product(_h_spaces, [np.float64, np.complex128]))
126
    def testPPO(self, sp, dtype):
Martin Reinecke's avatar
Martin Reinecke committed
127
        op = ift.PowerDistributor(target=sp)
128
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
129
130
        ps = ift.PowerSpace(
            sp, ift.PowerSpace.useful_binbounds(sp, logarithmic=False, nbin=3))
Martin Reinecke's avatar
Martin Reinecke committed
131
        op = ift.PowerDistributor(target=sp, power_space=ps)
132
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
133
134
        ps = ift.PowerSpace(
            sp, ift.PowerSpace.useful_binbounds(sp, logarithmic=True, nbin=3))
Martin Reinecke's avatar
Martin Reinecke committed
135
        op = ift.PowerDistributor(target=sp, power_space=ps)
136
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
137

138
    @expand(product(_h_RG_spaces+_p_RG_spaces,
Martin Reinecke's avatar
Martin Reinecke committed
139
                    [np.float64, np.complex128]))
Martin Reinecke's avatar
Martin Reinecke committed
140
141
    def testFFT(self, sp, dtype):
        op = ift.FFTOperator(sp)
142
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
143
        op = ift.FFTOperator(sp.get_default_codomain())
144
        ift.extra.consistency_check(op, dtype, dtype)
145

Martin Reinecke's avatar
Martin Reinecke committed
146
147
148
149
150
151
152
153
    @expand(product(_h_RG_spaces+_p_RG_spaces,
                    [np.float64, np.complex128]))
    def testHartley(self, sp, dtype):
        op = ift.HartleyOperator(sp)
        ift.extra.consistency_check(op, dtype, dtype)
        op = ift.HartleyOperator(sp.get_default_codomain())
        ift.extra.consistency_check(op, dtype, dtype)

154
155
156
    @expand(product(_h_spaces, [np.float64, np.complex128]))
    def testHarmonic(self, sp, dtype):
        op = ift.HarmonicTransformOperator(sp)
157
158
        ift.extra.consistency_check(op, dtype, dtype)

Philipp Arras's avatar
Philipp Arras committed
159
160
161
    @expand(product(_p_spaces, [np.float64, np.complex128]))
    def testMask(self, sp, dtype):
        # Create mask
Philipp Arras's avatar
Philipp Arras committed
162
        f = ift.from_random('normal', sp).to_global_data()
Philipp Arras's avatar
Philipp Arras committed
163
164
        mask = np.zeros_like(f)
        mask[f > 0] = 1
Philipp Arras's avatar
Philipp Arras committed
165
        mask = ift.Field.from_global_data(sp, mask)
Philipp Arras's avatar
Philipp Arras committed
166
167
168
169
        # Test MaskOperator
        op = ift.MaskOperator(mask)
        ift.extra.consistency_check(op, dtype, dtype)

170
171
172
173
174
    @expand(product(_h_spaces+_p_spaces, [np.float64, np.complex128]))
    def testDiagonal(self, sp, dtype):
        op = ift.DiagonalOperator(ift.Field.from_random("normal", sp,
                                                        dtype=dtype))
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
175
176
177
178
179

    @expand(product(_pow_spaces, [np.float64, np.complex128]))
    def testLaplace(self, sp, dtype):
        op = ift.LaplaceOperator(sp)
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
180
181
182
183
184

    @expand(product(_pow_spaces, [np.float64, np.complex128]))
    def testSmoothness(self, sp, dtype):
        op = ift.SmoothnessOperator(sp)
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
185
186
187
188
189
190

    @expand(product(_h_spaces+_p_spaces+_pow_spaces,
                    [np.float64, np.complex128]))
    def testGeometryRemover(self, sp, dtype):
        op = ift.GeometryRemover(sp)
        ift.extra.consistency_check(op, dtype, dtype)
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208

    @expand(product([0, 1, 2, 3, (0, 1), (0, 2), (0, 1, 2), (0, 2, 3), (1, 3)],
                    [np.float64, np.complex128]))
    def testDomainDistributor(self, spaces, dtype):
        dom = (ift.RGSpace(10), ift.UnstructuredDomain(13), ift.GLSpace(5),
               ift.HPSpace(4))
        op = ift.DomainDistributor(dom, spaces)
        ift.extra.consistency_check(op, dtype, dtype)

    @expand(product([0, 2], [np.float64, np.complex128]))
    def testSymmetrizingOperator(self, space, dtype):
        dom = (ift.LogRGSpace(10, [2.], [1.]), ift.UnstructuredDomain(13),
               ift.LogRGSpace((5, 27), [1., 2.7], [0., 4.]), ift.HPSpace(4))
        op = ift.SymmetrizingOperator(dom, space)
        ift.extra.consistency_check(op, dtype, dtype)

    @expand(product([0, 2], [2, 2.7], [np.float64, np.complex128]))
    def testZeroPadder(self, space, factor, dtype):
Martin Reinecke's avatar
Martin Reinecke committed
209
        dom = (ift.RGSpace(10), ift.UnstructuredDomain(13), ift.RGSpace(7, 12),
210
               ift.HPSpace(4))
211
212
        newshape = [factor*l for l in dom[space].shape]
        op = ift.FieldZeroPadder(dom, newshape, space)
213
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233

    @expand(product([(ift.RGSpace(10, harmonic=True), 4, 0),
                     (ift.RGSpace((24, 31), distances=(0.4, 2.34),
                                  harmonic=True), (4, 3), 0),
                     ((ift.HPSpace(4), ift.RGSpace(27, distances=0.3,
                                                   harmonic=True)), (10,), 1),
                     (ift.PowerSpace(ift.RGSpace(10, distances=0.3,
                                     harmonic=True)), 6, 0)],
                    [np.float64, np.complex128]))
    def testExpTransform(self, args, dtype):
        op = ift.ExpTransform(args[0], args[1], args[2])
        ift.extra.consistency_check(op, dtype, dtype)

    @expand(product([(ift.LogRGSpace([10, 17], [2., 3.], [1., 0.]), 0),
                     ((ift.LogRGSpace(10, [2.], [1.]),
                       ift.UnstructuredDomain(13)), 0),
                     ((ift.UnstructuredDomain(13),
                       ift.LogRGSpace(17, [3.], [.7])), 1)],
                    [np.float64]))
    def testQHTOperator(self, args, dtype):
Martin Reinecke's avatar
Martin Reinecke committed
234
235
        tgt = ift.DomainTuple.make(args[0])
        op = ift.QHTOperator(tgt, args[1])
Martin Reinecke's avatar
Martin Reinecke committed
236
        ift.extra.consistency_check(op, dtype, dtype)