test_adjoint.py 11.1 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
    @expand(product(_p_RG_spaces, [np.float64, np.complex128]))
    def testLOSResponse(self, sp, dtype):
        starts = np.random.randn(len(sp.shape), 10)
        ends = np.random.randn(len(sp.shape), 10)
        sigma_low = 1e-4*np.random.randn(10)
        sigma_ups = 1e-5*np.random.randn(10)
        op = ift.LOSResponse(sp, starts, ends, sigma_low, sigma_ups)
        ift.extra.consistency_check(op, dtype, dtype)

47
48
49
50
    @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,
Martin Reinecke's avatar
Martin Reinecke committed
51
                                                       dtype=dtype))
52
        b = ift.DiagonalOperator(ift.Field.from_random("normal", sp,
Martin Reinecke's avatar
Martin Reinecke committed
53
                                                       dtype=dtype))
54
55
56
57
58
59
60
        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)

61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
    @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):
Martin Reinecke's avatar
Martin Reinecke committed
78
        mdom = ift.MultiDomain.make({'a': sp1, 'b': sp2})
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
        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)
Martin Reinecke's avatar
Martin Reinecke committed
98
99
        mdom1 = ift.MultiDomain.make({'a': sp1})
        mdom2 = ift.MultiDomain.make({'b': sp2})
100
101
102
103
104
105
        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)
Martin Reinecke's avatar
Martin Reinecke committed
106
107

    @expand(product(_h_spaces + _p_spaces + _pow_spaces,
108
109
                    [np.float64, np.complex128]))
    def testMultiAdaptor(self, sp, dtype):
Martin Reinecke's avatar
Martin Reinecke committed
110
        mdom = ift.MultiDomain.make({'a': sp})
111
112
113
114
115
116
117
118
119
        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)

Martin Reinecke's avatar
Martin Reinecke committed
120
    @expand(product(_h_spaces + _p_spaces + _pow_spaces,
Reimar H Leike's avatar
Reimar H Leike committed
121
122
                    [np.float64, np.complex128]))
    def testDOFDistributor(self, sp, dtype):
Martin Reinecke's avatar
Martin Reinecke committed
123
        # TODO: Test for DomainTuple
Reimar H Leike's avatar
Reimar H Leike committed
124
125
        if sp.size < 4:
            return
Martin Reinecke's avatar
Martin Reinecke committed
126
        dofdex = np.arange(sp.size).reshape(sp.shape) % 3
127
128
129
        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
130

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

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

Martin Reinecke's avatar
Martin Reinecke committed
152
153
154
155
156
157
158
159
    @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)

160
161
162
    @expand(product(_h_spaces, [np.float64, np.complex128]))
    def testHarmonic(self, sp, dtype):
        op = ift.HarmonicTransformOperator(sp)
163
164
        ift.extra.consistency_check(op, dtype, dtype)

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

176
177
178
179
180
    @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
181
182
183
184
185

    @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
186
187
188
189
190

    @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
191
192
193
194
195
196

    @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)
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

    @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
215
        dom = (ift.RGSpace(10), ift.UnstructuredDomain(13), ift.RGSpace(7, 12),
216
               ift.HPSpace(4))
217
218
        newshape = [factor*l for l in dom[space].shape]
        op = ift.FieldZeroPadder(dom, newshape, space)
219
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
220

Martin Reinecke's avatar
Martin Reinecke committed
221
222
223
224
225
226
227
228
    @expand(product([0, 2], [2, 2.7], [np.float64, np.complex128]))
    def testZeroPadder2(self, space, factor, dtype):
        dom = (ift.RGSpace(10), ift.UnstructuredDomain(13), ift.RGSpace(7, 12),
               ift.HPSpace(4))
        newshape = [factor*l for l in dom[space].shape]
        op = ift.CentralZeroPadder(dom, newshape, space)
        ift.extra.consistency_check(op, dtype, dtype)

Martin Reinecke's avatar
Martin Reinecke committed
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
    @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
248
249
        tgt = ift.DomainTuple.make(args[0])
        op = ift.QHTOperator(tgt, args[1])
Martin Reinecke's avatar
Martin Reinecke committed
250
        ift.extra.consistency_check(op, dtype, dtype)