test_adjoint.py 11.8 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
        op = ift.SandwichOperator.make(a, b)
        ift.extra.consistency_check(op, dtype, dtype)
Martin Reinecke's avatar
Martin Reinecke committed
56
        op = a(b)
57
58
59
60
        ift.extra.consistency_check(op, dtype, dtype)
        op = a+b
        ift.extra.consistency_check(op, dtype, dtype)

Martin Reinecke's avatar
Martin Reinecke committed
61
62
63
64
65
66
67
    @expand(product(_h_spaces + _p_spaces + _pow_spaces,
                    [np.float64, np.complex128]))
    def testVdotOperator(self, sp, dtype):
        op = ift.VdotOperator(ift.Field.from_random("normal", sp,
                                                    dtype=dtype))
        ift.extra.consistency_check(op, dtype, dtype)

Martin Reinecke's avatar
Martin Reinecke committed
68
69
70
71
72
73
    @expand(product(_h_spaces + _p_spaces + _pow_spaces,
                    [np.float64, np.complex128]))
    def testSumReductionOperator(self, sp, dtype):
        op = ift.SumReductionOperator(sp)
        ift.extra.consistency_check(op, dtype, dtype)

74
75
76
77
78
79
80
81
82
    @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])
83
        op = ift.SlopeOperator(tgt, sig)
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
        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
102
103
        mdom1 = ift.MultiDomain.make({'a': sp1})
        mdom2 = ift.MultiDomain.make({'b': sp2})
104
105
106
107
108
109
        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
110

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

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

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

Martin Reinecke's avatar
Martin Reinecke committed
149
150
151
152
153
154
155
156
    @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)

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

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

173
174
175
176
177
    @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
178
179
180
181
182

    @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
183
184
185
186
187

    @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
188
189
190
191
192
193

    @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)
194
195
196

    @expand(product([0, 1, 2, 3, (0, 1), (0, 2), (0, 1, 2), (0, 2, 3), (1, 3)],
                    [np.float64, np.complex128]))
197
    def testContractionOperator(self, spaces, dtype):
198
199
        dom = (ift.RGSpace(10), ift.UnstructuredDomain(13), ift.GLSpace(5),
               ift.HPSpace(4))
200
        op = ift.ContractionOperator(dom, spaces)
201
202
        ift.extra.consistency_check(op, dtype, dtype)

203
    def testDomainTupleFieldInserter(self):
Philipp Arras's avatar
Philipp Arras committed
204
205
206
        domain = ift.DomainTuple.make((ift.UnstructuredDomain(12),
                                       ift.RGSpace([4, 22])))
        new_space = ift.UnstructuredDomain(7)
207
208
        pos = (5,)
        op = ift.DomainTupleFieldInserter(domain, new_space, 0, pos)
Philipp Arras's avatar
Philipp Arras committed
209
210
        ift.extra.consistency_check(op)

211
212
213
214
215
216
217
    @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)

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

Martin Reinecke's avatar
Martin Reinecke committed
227
228
229
230
    @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))
231
        newshape = [int(factor*l) for l in dom[space].shape]
Martin Reinecke's avatar
Martin Reinecke committed
232
233
234
        op = ift.CentralZeroPadder(dom, newshape, space)
        ift.extra.consistency_check(op, dtype, dtype)

Martin Reinecke's avatar
Martin Reinecke committed
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
    @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
254
255
        tgt = ift.DomainTuple.make(args[0])
        op = ift.QHTOperator(tgt, args[1])
Martin Reinecke's avatar
Martin Reinecke committed
256
        ift.extra.consistency_check(op, dtype, dtype)
Philipp Arras's avatar
Philipp Arras committed
257

Martin Reinecke's avatar
Martin Reinecke committed
258
259
260
    @expand([[ift.RGSpace((13, 52, 40)), (4, 6, 25), None],
             [ift.RGSpace((128, 128)), (45, 48), 0],
             [ift.RGSpace(13), (7,), None],
261
             [(ift.HPSpace(3), ift.RGSpace((12, 24), distances=0.3)),
Martin Reinecke's avatar
Martin Reinecke committed
262
263
264
              (12, 12), 1]])
    def testRegridding(self, domain, shape, space):
        op = ift.RegriddingOperator(domain, shape, space)
Philipp Arras's avatar
Philipp Arras committed
265
        ift.extra.consistency_check(op)