tests.py 10.9 KB
Newer Older
1
2
3
import unittest
import numpy as np
import os
Gregory Ashton's avatar
Gregory Ashton committed
4
5
6
import shutil
import pyfstat

7

Gregory Ashton's avatar
Gregory Ashton committed
8
9
10
11
class Test(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        pass
12

Gregory Ashton's avatar
Gregory Ashton committed
13
14
15
16
17
18
19
    @classmethod
    def tearDownClass(cls):
        pass


class TestWriter(Test):
    label = "Test"
20
21

    def test_make_cff(self):
Gregory Ashton's avatar
Gregory Ashton committed
22
        Writer = pyfstat.Writer(self.label, outdir=outdir)
23
24
25
26
        Writer.make_cff()
        self.assertTrue(os.path.isfile('./TestData/Test.cff'))

    def test_run_makefakedata(self):
Gregory Ashton's avatar
Gregory Ashton committed
27
        Writer = pyfstat.Writer(self.label, outdir=outdir)
28
29
30
31
32
33
        Writer.make_cff()
        Writer.run_makefakedata()
        self.assertTrue(os.path.isfile(
            './TestData/H-4800_H1_1800SFT_Test-700000000-8640000.sft'))

    def test_makefakedata_usecached(self):
Gregory Ashton's avatar
Gregory Ashton committed
34
        Writer = pyfstat.Writer(self.label, outdir=outdir)
35
36
        if os.path.isfile(Writer.sftfilepath):
            os.remove(Writer.sftfilepath)
37
        Writer.run_makefakedata()
38
        time_first = os.path.getmtime(Writer.sftfilepath)
39
        Writer.run_makefakedata()
40
        time_second = os.path.getmtime(Writer.sftfilepath)
41
42
43
        self.assertTrue(time_first == time_second)
        os.system('touch {}'.format(Writer.config_file_name))
        Writer.run_makefakedata()
44
        time_third = os.path.getmtime(Writer.sftfilepath)
45
46
47
        self.assertFalse(time_first == time_third)


Gregory Ashton's avatar
Gregory Ashton committed
48
class TestBaseSearchClass(Test):
49
50
51
    def test_shift_matrix(self):
        BSC = pyfstat.BaseSearchClass()
        dT = 10
52
        a = BSC._shift_matrix(4, dT)
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
        b = np.array([[1, 2*np.pi*dT, 2*np.pi*dT**2/2.0, 2*np.pi*dT**3/6.0],
                      [0, 1, dT, dT**2/2.0],
                      [0, 0, 1, dT],
                      [0, 0, 0, 1]])
        self.assertTrue(np.array_equal(a, b))

    def test_shift_coefficients(self):
        BSC = pyfstat.BaseSearchClass()
        thetaA = np.array([10., 1e2, 10., 1e2])
        dT = 100

        # Calculate the 'long' way
        thetaB = np.zeros(len(thetaA))
        thetaB[3] = thetaA[3]
        thetaB[2] = thetaA[2] + thetaA[3]*dT
        thetaB[1] = thetaA[1] + thetaA[2]*dT + .5*thetaA[3]*dT**2
        thetaB[0] = thetaA[0] + 2*np.pi*(thetaA[1]*dT + .5*thetaA[2]*dT**2
                                         + thetaA[3]*dT**3 / 6.0)

        self.assertTrue(
            np.array_equal(
74
                thetaB, BSC._shift_coefficients(thetaA, dT)))
75
76
77
78
79

    def test_shift_coefficients_loop(self):
        BSC = pyfstat.BaseSearchClass()
        thetaA = np.array([10., 1e2, 10., 1e2])
        dT = 1e1
80
        thetaB = BSC._shift_coefficients(thetaA, dT)
81
82
        self.assertTrue(
            np.allclose(
83
                thetaA, BSC._shift_coefficients(thetaB, -dT),
84
85
86
                rtol=1e-9, atol=1e-9))


Gregory Ashton's avatar
Gregory Ashton committed
87
class TestComputeFstat(Test):
88
89
90
    label = "Test"

    def test_run_computefstatistic_single_point(self):
Gregory Ashton's avatar
Gregory Ashton committed
91
        Writer = pyfstat.Writer(self.label, outdir=outdir)
92
93
94
        Writer.make_data()
        predicted_FS = Writer.predict_fstat()

95
96
97
        search = pyfstat.ComputeFstat(
            tref=Writer.tref,
            sftfilepath='{}/*{}*sft'.format(Writer.outdir, Writer.label))
98
        FS = search.run_computefstatistic_single_point(Writer.tstart,
Gregory Ashton's avatar
Gregory Ashton committed
99
                                                       Writer.tend,
100
101
102
103
104
105
                                                       Writer.F0,
                                                       Writer.F1,
                                                       Writer.F2,
                                                       Writer.Alpha,
                                                       Writer.Delta)
        print predicted_FS, FS
Gregory Ashton's avatar
Gregory Ashton committed
106
        self.assertTrue(np.abs(predicted_FS-FS)/FS < 0.2)
107

108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
    def run_computefstatistic_single_point_no_noise(self):
        Writer = pyfstat.Writer(self.label, outdir=outdir, add_noise=False)
        Writer.make_data()
        predicted_FS = Writer.predict_fstat()

        search = pyfstat.ComputeFstat(
            tref=Writer.tref, assumeSqrtSX=1,
            sftfilepath='{}/*{}*sft'.format(Writer.outdir, Writer.label))
        FS = search.run_computefstatistic_single_point(Writer.tstart,
                                                       Writer.tend,
                                                       Writer.F0,
                                                       Writer.F1,
                                                       Writer.F2,
                                                       Writer.Alpha,
                                                       Writer.Delta)
        print predicted_FS, FS
        self.assertTrue(np.abs(predicted_FS-FS)/FS < 0.2)
Gregory Ashton's avatar
Gregory Ashton committed
125

126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
    def test_injectSources_from_file(self):
        Writer = pyfstat.Writer(self.label, outdir=outdir, add_noise=False)
        Writer.make_cff()
        injectSources = Writer.config_file_name

        search = pyfstat.ComputeFstat(
            tref=Writer.tref, assumeSqrtSX=1, injectSources=injectSources,
            minCoverFreq=28, maxCoverFreq=32, minStartTime=Writer.tstart,
            maxStartTime=Writer.tstart+Writer.duration,
            detectors=Writer.detectors)
        FS = search.run_computefstatistic_single_point(Writer.tstart,
                                                       Writer.tend,
                                                       Writer.F0,
                                                       Writer.F1,
                                                       Writer.F2,
                                                       Writer.Alpha,
                                                       Writer.Delta)
        Writer.make_data()
        predicted_FS = Writer.predict_fstat()
        print predicted_FS, FS
        self.assertTrue(np.abs(predicted_FS-FS)/FS < 0.2)


Gregory Ashton's avatar
Gregory Ashton committed
149
class TestSemiCoherentGlitchSearch(Test):
Gregory Ashton's avatar
Gregory Ashton committed
150
151
    label = "Test"

152
153
    def test_compute_nglitch_fstat(self):
        duration = 100*86400
154
        dtglitch = .5*100*86400
155
        delta_F0 = 0
Gregory Ashton's avatar
Gregory Ashton committed
156
        Writer = pyfstat.Writer(self.label, outdir=outdir,
157
158
159
160
161
162
                                duration=duration, dtglitch=dtglitch,
                                delta_F0=delta_F0)

        Writer.make_data()

        search = pyfstat.SemiCoherentGlitchSearch(
163
164
            label=self.label, outdir=outdir,
            sftfilepath='{}/*{}*sft'.format(Writer.outdir, Writer.label),
165
166
            tref=Writer.tref, minStartTime=Writer.tstart,
            maxStartTime=Writer.tend, nglitch=1)
167
168
169
170

        FS = search.compute_nglitch_fstat(Writer.F0, Writer.F1, Writer.F2,
                                          Writer.Alpha, Writer.Delta,
                                          Writer.delta_F0, Writer.delta_F1,
171
                                          search.minStartTime+dtglitch)
172
173

        # Compute the predicted semi-coherent glitch Fstat
174
175
        minStartTime = Writer.tstart
        maxStartTime = Writer.tend
176

177
        Writer.maxStartTime = minStartTime + dtglitch
178
179
        FSA = Writer.predict_fstat()

180
181
        Writer.tstart = minStartTime + dtglitch
        Writer.tend = maxStartTime
182
183
        FSB = Writer.predict_fstat()

184
        print FSA, FSB
185
186
187
        predicted_FS = (FSA + FSB)

        print(predicted_FS, FS)
Gregory Ashton's avatar
Gregory Ashton committed
188
        self.assertTrue(np.abs((FS - predicted_FS))/predicted_FS < 0.3)
189
190


Gregory Ashton's avatar
Gregory Ashton committed
191
192
class TestMCMCSearch(Test):
    label = "Test"
193
194

    def test_fully_coherent(self):
195
        h0 = 5e-24
196
197
198
199
        sqrtSX = 1e-22
        F0 = 30
        F1 = -1e-10
        F2 = 0
200
        minStartTime = 700000000
201
        duration = 100 * 86400
202
        maxStartTime = minStartTime + duration
203
204
        Alpha = 5e-3
        Delta = 1.2
205
        tref = minStartTime
206
207
208
        delta_F0 = 0
        Writer = pyfstat.Writer(F0=F0, F1=F1, F2=F2, label=self.label,
                                h0=h0, sqrtSX=sqrtSX,
209
                                outdir=outdir, tstart=minStartTime,
210
                                Alpha=Alpha, Delta=Delta, tref=tref,
211
                                duration=duration,
212
213
214
215
216
                                delta_F0=delta_F0, Band=4)

        Writer.make_data()
        predicted_FS = Writer.predict_fstat()

217
218
        theta = {'F0': {'type': 'norm', 'loc': F0, 'scale': np.abs(1e-9*F0)},
                 'F1': {'type': 'norm', 'loc': F1, 'scale': np.abs(1e-9*F1)},
219
220
                 'F2': F2, 'Alpha': Alpha, 'Delta': Delta}

Gregory Ashton's avatar
Gregory Ashton committed
221
        search = pyfstat.MCMCSearch(
Gregory Ashton's avatar
Gregory Ashton committed
222
            label=self.label, outdir=outdir, theta_prior=theta, tref=tref,
223
            sftfilepath='{}/*{}*sft'.format(Writer.outdir, Writer.label),
224
            minStartTime=minStartTime, maxStartTime=maxStartTime,
225
            nsteps=[100, 100], nwalkers=100, ntemps=2, log10temperature_min=-1)
226
        search.setup_convergence_testing()
227
        search.run(create_plots=False)
228
229
230
231
        _, FS = search.get_max_twoF()

        print('Predicted twoF is {} while recovered is {}'.format(
                predicted_FS, FS))
Gregory Ashton's avatar
Gregory Ashton committed
232
233
        self.assertTrue(
            FS > predicted_FS or np.abs((FS-predicted_FS))/predicted_FS < 0.3)
234

235
    def test_multi_stage(self):
236
        Writer = pyfstat.Writer(F0=10)
237
238
239
240
241
242
243
244
245
246
247
248
249
        Writer.make_cff()

        theta = {'F0': {'type': 'norm', 'loc': 10, 'scale': 1e-2},
                 'F1': 0, 'F2': 0, 'Alpha': 0, 'Delta': 0}

        search = pyfstat.MCMCSearch(
            label=self.label, outdir=outdir, theta_prior=theta,
            tref=Writer.tref, injectSources=Writer.config_file_name,
            minStartTime=Writer.minStartTime, maxStartTime=Writer.maxStartTime,
            nsteps=[5, 5], nwalkers=20, ntemps=1, detectors='H1',
            minCoverFreq=9, maxCoverFreq=11)
        search.run(create_plots=False)

250

251
252
253
254
255
256
257
258
259
class TestAuxillaryFunctions(Test):
    nsegs = 10
    minStartTime = 1e9
    maxStartTime = minStartTime + 100 * 86400
    tref = .5*(minStartTime + maxStartTime)
    DeltaOmega = 1e-2
    DeltaFs = [1e-4, 1e-14]
    fiducial_freq = 100
    detector_names = ['H1', 'L1']
260
    earth_ephem, sun_ephem = pyfstat.helper_functions.set_up_ephemeris_configuration()
261
262
263

    def test_get_V_estimate_sky_F0_F1(self):

Gregory Ashton's avatar
Gregory Ashton committed
264
        out = pyfstat.optimal_setup_functions.get_V_estimate(
265
266
267
268
269
270
271
272
            self.nsegs, self.tref, self.minStartTime, self.maxStartTime,
            self.DeltaOmega, self.DeltaFs, self.fiducial_freq,
            self.detector_names, self.earth_ephem, self.sun_ephem)
        V, Vsky, Vpe = out
        self.assertTrue(V == Vsky * Vpe)
        self.__class__.Vpe_COMPUTED_WITH_SKY = Vpe

    def test_get_V_estimate_F0_F1(self):
Gregory Ashton's avatar
Gregory Ashton committed
273
        out = pyfstat.optimal_setup_functions.get_V_estimate(
274
275
276
277
278
279
280
281
282
283
284
285
            self.nsegs, self.tref, self.minStartTime, self.maxStartTime,
            self.DeltaOmega, self.DeltaFs, self.fiducial_freq,
            self.detector_names, self.earth_ephem, self.sun_ephem)
        V, Vsky, Vpe = out
        self.assertTrue(V == Vsky * Vpe)
        self.__class__.Vpe_COMPUTED_WITHOUT_SKY = Vpe

    def test_the_equivalence_of_Vpe(self):
        """Tests if the Vpe computed with and without the sky are equal """
        self.assertEqual(self.__class__.Vpe_COMPUTED_WITHOUT_SKY,
                         self.__class__.Vpe_COMPUTED_WITH_SKY)

286
if __name__ == '__main__':
Gregory Ashton's avatar
Gregory Ashton committed
287
288
289
    outdir = 'TestData'
    if os.path.isdir(outdir):
        shutil.rmtree(outdir)
290
    unittest.main()
Gregory Ashton's avatar
Gregory Ashton committed
291
292
293
    if os.path.isdir(outdir):
        shutil.rmtree(outdir)