Hide keyboard shortcuts

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 

4 

5from lsst.sims.catUtils.mixins import VariabilityAGN 

6 

7 

8def setup_module(module): 

9 lsst.utils.tests.init() 

10 

11 

12class AgnModelTestCase(unittest.TestCase): 

13 

14 longMessage = True 

15 

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 """ 

22 

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 

33 

34 redshift = np.zeros(n_obj, dtype=float) 

35 dmag_arr = agn_obj.applyAgn([range(n_obj)], agn_params, mjd_grid, 

36 redshift=redshift) 

37 

38 self.assertEqual(dmag_arr.shape, (6, n_obj, len(mjd_grid))) 

39 

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] 

46 

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): 

51 

52 delta_t = d_mjd*delta_i_t 

53 

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)) 

57 

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)) 

61 

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)) 

66 

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) 

70 

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 """ 

77 

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 

88 

89 redshift = np.zeros(n_obj, dtype=float) 

90 dmag_arr = agn_obj.applyAgn([range(n_obj)], agn_params, mjd_grid, 

91 redshift=redshift) 

92 

93 self.assertEqual(dmag_arr.shape, (6, n_obj, len(mjd_grid))) 

94 

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] 

101 

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) 

109 

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) 

122 

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) 

128 

129 This test is done for the case of non-zero redshift 

130 """ 

131 

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 

142 

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) 

146 

147 self.assertEqual(dmag_arr.shape, (6, n_obj, len(mjd_grid))) 

148 

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] 

156 

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): 

161 

162 delta_t = d_mjd*delta_i_t/time_dilation 

163 

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)) 

167 

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)) 

171 

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)) 

176 

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) 

180 

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 

186 

187 This test is done in the case of non-zero redshift 

188 """ 

189 

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 

200 

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) 

204 

205 self.assertEqual(dmag_arr.shape, (6, n_obj, len(mjd_grid))) 

206 

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] 

214 

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) 

222 

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) 

234 

235 self.assertGreater(ct_lags, 10) 

236 

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) 

246 

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) 

258 

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) 

262 

263 dmag_threaded = agn_obj_2.applyAgn([np.arange(n_agn, dtype=int)], 

264 agn_params, mjd, redshift=redshift) 

265 

266 np.testing.assert_array_equal(dmag_control, dmag_threaded) 

267 

268 ##### now test it on a numpy array of mjd 

269 

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) 

273 

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) 

277 

278 dmag_threaded = agn_obj_2.applyAgn([np.arange(n_agn, dtype=int)], 

279 agn_params, mjd, redshift=redshift) 

280 

281 np.testing.assert_array_equal(dmag_control, dmag_threaded) 

282 

283 

284class MemoryTestClass(lsst.utils.tests.MemoryTestCase): 

285 pass 

286 

287 

288 

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()