tests.py 9.2 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
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
    def test_shift_matrix(self):
        BSC = pyfstat.BaseSearchClass()
        dT = 10
        a = BSC.shift_matrix(4, dT)
        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(
                thetaB, BSC.shift_coefficients(thetaA, dT)))

    def test_shift_coefficients_loop(self):
        BSC = pyfstat.BaseSearchClass()
        thetaA = np.array([10., 1e2, 10., 1e2])
        dT = 1e1
        thetaB = BSC.shift_coefficients(thetaA, dT)
        self.assertTrue(
            np.allclose(
                thetaA, BSC.shift_coefficients(thetaB, -dT),
                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

Gregory Ashton's avatar
Gregory Ashton committed
126
class TestSemiCoherentGlitchSearch(Test):
Gregory Ashton's avatar
Gregory Ashton committed
127
128
    label = "Test"

129
130
    def test_compute_nglitch_fstat(self):
        duration = 100*86400
131
        dtglitch = .5*100*86400
132
        delta_F0 = 0
Gregory Ashton's avatar
Gregory Ashton committed
133
        Writer = pyfstat.Writer(self.label, outdir=outdir,
134
135
136
137
138
139
                                duration=duration, dtglitch=dtglitch,
                                delta_F0=delta_F0)

        Writer.make_data()

        search = pyfstat.SemiCoherentGlitchSearch(
140
141
            label=self.label, outdir=outdir,
            sftfilepath='{}/*{}*sft'.format(Writer.outdir, Writer.label),
142
143
            tref=Writer.tref, minStartTime=Writer.tstart,
            maxStartTime=Writer.tend, nglitch=1)
144
145
146
147

        FS = search.compute_nglitch_fstat(Writer.F0, Writer.F1, Writer.F2,
                                          Writer.Alpha, Writer.Delta,
                                          Writer.delta_F0, Writer.delta_F1,
148
                                          search.minStartTime+dtglitch)
149
150

        # Compute the predicted semi-coherent glitch Fstat
151
152
        minStartTime = Writer.tstart
        maxStartTime = Writer.tend
153

154
        Writer.maxStartTime = minStartTime + dtglitch
155
156
        FSA = Writer.predict_fstat()

157
158
        Writer.tstart = minStartTime + dtglitch
        Writer.tend = maxStartTime
159
160
        FSB = Writer.predict_fstat()

161
        print FSA, FSB
162
163
164
        predicted_FS = (FSA + FSB)

        print(predicted_FS, FS)
Gregory Ashton's avatar
Gregory Ashton committed
165
        self.assertTrue(np.abs((FS - predicted_FS))/predicted_FS < 0.3)
166
167


Gregory Ashton's avatar
Gregory Ashton committed
168
169
class TestMCMCSearch(Test):
    label = "Test"
170
171
172
173
174
175
176

    def test_fully_coherent(self):
        h0 = 1e-24
        sqrtSX = 1e-22
        F0 = 30
        F1 = -1e-10
        F2 = 0
177
        minStartTime = 700000000
178
        duration = 100 * 86400
179
        maxStartTime = minStartTime + duration
180
181
        Alpha = 5e-3
        Delta = 1.2
182
        tref = minStartTime
183
        dtglitch = None
184
185
186
        delta_F0 = 0
        Writer = pyfstat.Writer(F0=F0, F1=F1, F2=F2, label=self.label,
                                h0=h0, sqrtSX=sqrtSX,
187
                                outdir=outdir, tstart=minStartTime,
188
189
190
191
192
193
194
                                Alpha=Alpha, Delta=Delta, tref=tref,
                                duration=duration, dtglitch=dtglitch,
                                delta_F0=delta_F0, Band=4)

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

Gregory Ashton's avatar
Gregory Ashton committed
195
        theta = {'F0': {'type': 'norm', 'loc': F0, 'scale': np.abs(1e-9*F0)},
196
197
198
                 'F1': {'type': 'norm', 'loc': F1, 'scale': np.abs(1e-9*F1)},
                 'F2': F2, 'Alpha': Alpha, 'Delta': Delta}

Gregory Ashton's avatar
Gregory Ashton committed
199
        search = pyfstat.MCMCSearch(
Gregory Ashton's avatar
Gregory Ashton committed
200
            label=self.label, outdir=outdir, theta_prior=theta, tref=tref,
201
            sftfilepath='{}/*{}*sft'.format(Writer.outdir, Writer.label),
202
203
            minStartTime=minStartTime, maxStartTime=maxStartTime,
            nsteps=[100, 100], nwalkers=100, ntemps=1)
204
205
206
207
208
209
        search.run()
        search.plot_corner(add_prior=True)
        _, FS = search.get_max_twoF()

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


214
215
216
217
218
219
220
221
222
223
224
225
226
227
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']
    earth_ephem = pyfstat.earth_ephem
    sun_ephem = pyfstat.sun_ephem

    def test_get_V_estimate_sky_F0_F1(self):

Gregory Ashton's avatar
Gregory Ashton committed
228
        out = pyfstat.optimal_setup_functions.get_V_estimate(
229
230
231
232
233
234
235
236
            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
237
        out = pyfstat.optimal_setup_functions.get_V_estimate(
238
239
240
241
242
243
244
245
246
247
248
249
            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)

250
if __name__ == '__main__':
Gregory Ashton's avatar
Gregory Ashton committed
251
252
253
    outdir = 'TestData'
    if os.path.isdir(outdir):
        shutil.rmtree(outdir)
254
    unittest.main()
Gregory Ashton's avatar
Gregory Ashton committed
255
256
257
    if os.path.isdir(outdir):
        shutil.rmtree(outdir)