Coverage for tests/test_agn_model.py : 8%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1import numpy as np
2import unittest
3import lsst.utils.tests
5from lsst.sims.catUtils.mixins import VariabilityAGN
8def setup_module(module):
9 lsst.utils.tests.init()
12class AgnModelTestCase(unittest.TestCase):
14 longMessage = True
16 def test_agn_structure_function(self):
17 """
18 Test that the structure_function of the delta_magnitudes
19 resulting from our AGN variability model is consistent with
20 equation 3 of MacLeod et al. 2010 (ApJ 721, 1014)
21 """
23 agn_obj = VariabilityAGN()
24 n_obj = 10
25 d_mjd = 1.0
26 rng = np.random.RandomState(88)
27 mjd_grid = np.arange(61000.0, 237000.0, d_mjd)
28 agn_params = {}
29 agn_params['seed'] = rng.randint(10, high=1000, size=n_obj)
30 agn_params['agn_tau'] = rng.random_sample(n_obj)*25.0+75.0
31 for bp in ('u', 'g', 'r', 'i', 'z', 'y'):
32 agn_params['agn_sf%s' % bp] = rng.random_sample(n_obj)*100.0+5.0
34 redshift = np.zeros(n_obj, dtype=float)
35 dmag_arr = agn_obj.applyAgn([range(n_obj)], agn_params, mjd_grid,
36 redshift=redshift)
38 self.assertEqual(dmag_arr.shape, (6, n_obj, len(mjd_grid)))
40 max_dev = -1.0
41 for i_obj in range(n_obj):
42 tau = agn_params['agn_tau'][i_obj]
43 seed = agn_params['seed'][i_obj]
44 for i_bp, bp in enumerate(('u', 'g', 'r', 'i', 'z', 'y')):
45 sf_inf = agn_params['agn_sf%s' % bp][i_obj]
47 # loop over different time lags, calculating the structure
48 # function of the light curves and comparing to the
49 # expected value of the structure function
50 for delta_i_t in range(5,len(mjd_grid)//2, len(mjd_grid)//20):
52 delta_t = d_mjd*delta_i_t
54 dmag_0 = dmag_arr[i_bp][i_obj][:-delta_i_t]
55 dmag_1 = dmag_arr[i_bp][i_obj][delta_i_t:]
56 self.assertEqual(len(dmag_0), len(dmag_1))
58 # expected structure funciton value taken from
59 # equation 3 of MacLeod et al
60 sf_th = sf_inf*np.sqrt(1.0-np.exp(-delta_t/tau))
62 # use definition of structure function from
63 # section 2.1 of Hughes et al. 1992
64 # (ApJ 396, 469)
65 sf_test = np.sqrt(np.mean((dmag_1-dmag_0)**2))
67 # verify that the structure function is within 10%
68 # of the expected value
69 self.assertLess(np.abs(1.0-sf_test/sf_th), 0.1)
71 def test_agn_mean(self):
72 """
73 Test that the mean of time lagged AGN light curves approaches
74 delta_magnitude = 0 as the time lag gets larger than
75 the AGN variability time scale
76 """
78 agn_obj = VariabilityAGN()
79 n_obj = 10
80 d_mjd = 1.0
81 rng = np.random.RandomState(11273)
82 mjd_grid = np.arange(61000.0, 237000.0, d_mjd)
83 agn_params = {}
84 agn_params['seed'] = rng.randint(10, high=1000, size=n_obj)
85 agn_params['agn_tau'] = rng.random_sample(n_obj)*25.0+75.0
86 for bp in ('u', 'g', 'r', 'i', 'z', 'y'):
87 agn_params['agn_sf%s' % bp] = rng.random_sample(n_obj)*100.0+5.0
89 redshift = np.zeros(n_obj, dtype=float)
90 dmag_arr = agn_obj.applyAgn([range(n_obj)], agn_params, mjd_grid,
91 redshift=redshift)
93 self.assertEqual(dmag_arr.shape, (6, n_obj, len(mjd_grid)))
95 max_dev = -1.0
96 for i_obj in range(n_obj):
97 tau = agn_params['agn_tau'][i_obj]
98 seed = agn_params['seed'][i_obj]
99 for i_bp, bp in enumerate(('u', 'g', 'r', 'i', 'z', 'y')):
100 sf_inf = agn_params['agn_sf%s' % bp][i_obj]
102 # loop over different time lags, calculating the mean
103 # of the light curve taken at those time lags; make
104 # sure delta_mag is within 1-sigma of zero
105 #
106 # only consider lags that are greater than 5*tau
107 delta_i_t_min = int(np.round(tau/d_mjd))
108 self.assertLess(5*delta_i_t_min, len(mjd_grid)//20)
110 ct_lags = 0
111 for delta_i_t in range(5*delta_i_t_min, len(mjd_grid)//20, 100):
112 ct_lags += 1
113 t_dexes = range(delta_i_t+rng.randint(0,high=10), len(mjd_grid), delta_i_t)
114 dmag_subset = dmag_arr[i_bp][i_obj][t_dexes]
115 self.assertGreater(len(dmag_subset), 19)
116 dmag_mean = np.mean(dmag_subset)
117 dmag_stdev = np.std(dmag_subset)
118 msg = 'failed with %d samples' % len(dmag_subset)
119 self.assertLess(np.abs(dmag_mean)/dmag_stdev, 1.0,
120 msg=msg)
121 self.assertGreater(ct_lags, 10)
123 def test_agn_structure_function_with_redshift(self):
124 """
125 Test that the structure_function of the delta_magnitudes
126 resulting from our AGN variability model is consistent with
127 equation 3 of MacLeod et al. 2010 (ApJ 721, 1014)
129 This test is done for the case of non-zero redshift
130 """
132 agn_obj = VariabilityAGN()
133 n_obj = 10
134 d_mjd = 1.0
135 rng = np.random.RandomState(443)
136 mjd_grid = np.arange(61000.0, 237000.0, d_mjd)
137 agn_params = {}
138 agn_params['seed'] = rng.randint(10, high=1000, size=n_obj)
139 agn_params['agn_tau'] = rng.random_sample(n_obj)*25.0+75.0
140 for bp in ('u', 'g', 'r', 'i', 'z', 'y'):
141 agn_params['agn_sf%s' % bp] = rng.random_sample(n_obj)*100.0+5.0
143 redshift = rng.random_sample(n_obj)*2.0+0.1
144 dmag_arr = agn_obj.applyAgn([range(n_obj)], agn_params, mjd_grid,
145 redshift=redshift)
147 self.assertEqual(dmag_arr.shape, (6, n_obj, len(mjd_grid)))
149 max_dev = -1.0
150 for i_obj in range(n_obj):
151 tau = agn_params['agn_tau'][i_obj]
152 seed = agn_params['seed'][i_obj]
153 time_dilation = 1.0+redshift[i_obj]
154 for i_bp, bp in enumerate(('u', 'g', 'r', 'i', 'z', 'y')):
155 sf_inf = agn_params['agn_sf%s' % bp][i_obj]
157 # loop over different time lags, calculating the structure
158 # function of the light curves and comparing to the
159 # expected value of the structure function
160 for delta_i_t in range(5,len(mjd_grid)//2, len(mjd_grid)//20):
162 delta_t = d_mjd*delta_i_t/time_dilation
164 dmag_0 = dmag_arr[i_bp][i_obj][:-delta_i_t]
165 dmag_1 = dmag_arr[i_bp][i_obj][delta_i_t:]
166 self.assertEqual(len(dmag_0), len(dmag_1))
168 # expected structure funciton value taken from
169 # equation 3 of MacLeod et al
170 sf_th = sf_inf*np.sqrt(1.0-np.exp(-delta_t/tau))
172 # use definition of structure function from
173 # section 2.1 of Hughes et al. 1992
174 # (ApJ 396, 469)
175 sf_test = np.sqrt(np.mean((dmag_1-dmag_0)**2))
177 # verify that the structure function is within 10%
178 # of the expected value
179 self.assertLess(np.abs(1.0-sf_test/sf_th), 0.1)
181 def test_agn_mean_with_redshift(self):
182 """
183 Test that the mean of time lagged AGN light curves approaches
184 delta_magnitude = 0 as the time lag gets larger than
185 the AGN variability time scale
187 This test is done in the case of non-zero redshift
188 """
190 agn_obj = VariabilityAGN()
191 n_obj = 10
192 d_mjd = 1.0
193 rng = np.random.RandomState(2273)
194 mjd_grid = np.arange(61000.0, 237000.0, d_mjd)
195 agn_params = {}
196 agn_params['seed'] = rng.randint(10, high=1000, size=n_obj)
197 agn_params['agn_tau'] = rng.random_sample(n_obj)*25.0+75.0
198 for bp in ('u', 'g', 'r', 'i', 'z', 'y'):
199 agn_params['agn_sf%s' % bp] = rng.random_sample(n_obj)*100.0+5.0
201 redshift = rng.random_sample(n_obj)*2.0+0.1
202 dmag_arr = agn_obj.applyAgn([range(n_obj)], agn_params, mjd_grid,
203 redshift=redshift)
205 self.assertEqual(dmag_arr.shape, (6, n_obj, len(mjd_grid)))
207 max_dev = -1.0
208 for i_obj in range(n_obj):
209 tau = agn_params['agn_tau'][i_obj]
210 seed = agn_params['seed'][i_obj]
211 time_dilation = 1.0+redshift[i_obj]
212 for i_bp, bp in enumerate(('u', 'g', 'r', 'i', 'z', 'y')):
213 sf_inf = agn_params['agn_sf%s' % bp][i_obj]
215 # loop over different time lags, calculating the mean
216 # of the light curve taken at those time lags; make
217 # sure delta_mag is within 1-sigma of zero
218 #
219 # only consider lags that are greater than 5*tau
220 delta_i_t_min = int(np.round(tau/(time_dilation*d_mjd)))
221 self.assertLess(5*delta_i_t_min, len(mjd_grid)//20)
223 ct_lags = 0
224 for delta_i_t in range(5*delta_i_t_min, len(mjd_grid)//20, 100):
225 ct_lags += 1
226 t_dexes = range(delta_i_t+rng.randint(0,high=10), len(mjd_grid), delta_i_t)
227 dmag_subset = dmag_arr[i_bp][i_obj][t_dexes]
228 self.assertGreater(len(dmag_subset), 19)
229 dmag_mean = np.mean(dmag_subset)
230 dmag_stdev = np.std(dmag_subset)
231 msg = 'failed with %d samples' % len(dmag_subset)
232 self.assertLess(np.abs(dmag_mean)/dmag_stdev, 1.0,
233 msg=msg)
235 self.assertGreater(ct_lags, 10)
237 def test_threading(self):
238 """
239 Test that running applyAgn with multithreading does not change the answers
240 """
241 agn_obj = VariabilityAGN()
242 agn_obj_2 = VariabilityAGN()
243 agn_obj_2._agn_threads = 4
244 self.assertEqual(agn_obj._agn_threads, 1)
245 self.assertNotEqual(agn_obj._agn_threads, agn_obj_2._agn_threads)
247 rng = np.random.RandomState(61422)
248 n_agn = 11
249 redshift = rng.random_sample(n_agn)*2.0+1.1
250 agn_params = {}
251 agn_params['agn_tau'] = rng.random_sample(n_agn)*10.0+1.0
252 for bp in 'ugrizy':
253 agn_params['agn_sf%s' % bp] = rng.random_sample(n_agn)*2.0+0.1
254 agn_params['seed'] = rng.randint(2, high=100, size=n_agn)
255 mjd = 61923.5
256 dmag_control = agn_obj.applyAgn([np.arange(n_agn, dtype=int)],
257 agn_params, mjd, redshift=redshift)
259 self.assertEqual(dmag_control.shape, (6,n_agn))
260 n_zero = np.where(np.abs(dmag_control.flatten())<1.0e-10)
261 self.assertEqual(len(n_zero[0]), 0)
263 dmag_threaded = agn_obj_2.applyAgn([np.arange(n_agn, dtype=int)],
264 agn_params, mjd, redshift=redshift)
266 np.testing.assert_array_equal(dmag_control, dmag_threaded)
268 ##### now test it on a numpy array of mjd
270 mjd = 59580.0+rng.random_sample(13)*2000.0
271 dmag_control = agn_obj.applyAgn([np.arange(n_agn, dtype=int)],
272 agn_params, mjd, redshift=redshift)
274 self.assertEqual(dmag_control.shape, (6,n_agn, len(mjd)))
275 n_zero = np.where(np.abs(dmag_control.flatten())<1.0e-10)
276 self.assertEqual(len(n_zero[0]), 0)
278 dmag_threaded = agn_obj_2.applyAgn([np.arange(n_agn, dtype=int)],
279 agn_params, mjd, redshift=redshift)
281 np.testing.assert_array_equal(dmag_control, dmag_threaded)
284class MemoryTestClass(lsst.utils.tests.MemoryTestCase):
285 pass
289if __name__ == "__main__": 289 ↛ 290line 289 didn't jump to line 290, because the condition on line 289 was never true
290 lsst.utils.tests.init()
291 unittest.main()