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 unittest 

2import lsst.utils.tests 

3import numpy as np 

4import copy 

5import numbers 

6 

7from lsst.sims.catUtils.mixins import StellarVariabilityModels 

8from lsst.sims.catUtils.mixins import ExtraGalacticVariabilityModels 

9 

10 

11def applyAmcvn_original(valid_dexes, params, expmjd_in): 

12 """ 

13 Copied from VariabilityMixin.py before attempt was made 

14 to make applyAmcvn handle vectors of MJD. We will use 

15 this method to verify that we have not broken the logic 

16 inside of applyAmcvn. 

17 """ 

18 

19 if not isinstance(expmjd_in, numbers.Number): 

20 raise RuntimeError("cannot pass multiple MJD to " 

21 "applyAmcvn_original") 

22 

23 if len(params) == 0: 

24 return np.array([[],[],[],[],[],[]]) 

25 

26 n_obj = len(params[list(params.keys())[0]]) 

27 

28 maxyears = 10. 

29 dMag = np.zeros((6, n_obj)) 

30 epoch = expmjd_in 

31 

32 amplitude = params['amplitude'].astype(float)[valid_dexes] 

33 t0 = params['t0'].astype(float)[valid_dexes] 

34 period = params['period'].astype(float)[valid_dexes] 

35 burst_freq = params['burst_freq'].astype(float)[valid_dexes] 

36 burst_scale = params['burst_scale'].astype(float)[valid_dexes] 

37 amp_burst = params['amp_burst'].astype(float)[valid_dexes] 

38 color_excess = params['color_excess_during_burst'].astype(float)[valid_dexes] 

39 does_burst = params['does_burst'][valid_dexes] 

40 

41 # get the light curve of the typical variability 

42 uLc = amplitude*np.cos((epoch - t0)/period) 

43 gLc = copy.deepcopy(uLc) 

44 rLc = copy.deepcopy(uLc) 

45 iLc = copy.deepcopy(uLc) 

46 zLc = copy.deepcopy(uLc) 

47 yLc = copy.deepcopy(uLc) 

48 

49 # add in the flux from any bursting 

50 local_bursting_dexes = np.where(does_burst==1) 

51 for i_burst in local_bursting_dexes[0]: 

52 adds = 0.0 

53 for o in np.linspace(t0[i_burst] + burst_freq[i_burst],\ 

54 t0[i_burst] + maxyears*365.25, \ 

55 np.ceil(maxyears*365.25/burst_freq[i_burst]).astype(np.int64)): 

56 tmp = np.exp( -1*(epoch - o)/burst_scale[i_burst])/np.exp(-1.) 

57 adds -= amp_burst[i_burst]*tmp*(tmp < 1.0) ## kill the contribution 

58 ## add some blue excess during the outburst 

59 uLc[i_burst] += adds + 2.0*color_excess[i_burst] 

60 gLc[i_burst] += adds + color_excess[i_burst] 

61 rLc[i_burst] += adds + 0.5*color_excess[i_burst] 

62 iLc[i_burst] += adds 

63 zLc[i_burst] += adds 

64 yLc[i_burst] += adds 

65 

66 dMag[0][valid_dexes] += uLc 

67 dMag[1][valid_dexes] += gLc 

68 dMag[2][valid_dexes] += rLc 

69 dMag[3][valid_dexes] += iLc 

70 dMag[4][valid_dexes] += zLc 

71 dMag[5][valid_dexes] += yLc 

72 return dMag 

73 

74 

75 

76def setup_module(module): 

77 lsst.utils.tests.init() 

78 

79class StellarVariability_at_many_times_case(unittest.TestCase): 

80 """ 

81 This test case will verify that all of the stellar variability 

82 models in CatSim deal correctly with receiving a vector 

83 of time values. 

84 """ 

85 

86 longMessage = True 

87 

88 def setUp(self): 

89 self.star_var = StellarVariabilityModels() 

90 self.star_var.initializeVariability() 

91 

92 def test_RRLy_many(self): 

93 rng = np.random.RandomState(42) 

94 params = {} 

95 params['filename'] = ['rrly_lc/RRc/959802_per.txt', 

96 'rrly_lc/RRc/1078860_per.txt', 

97 'rrly_lc/RRab/98874_per.txt', 

98 'rrly_lc/RRab/3879827_per.txt'] 

99 

100 n_obj = len(params['filename']) 

101 

102 params['tStartMjd'] = rng.random_sample(n_obj)*1000.0+40000.0 

103 

104 mjd_arr = rng.random_sample(10)*3653.3+59580.0 

105 

106 n_time = len(mjd_arr) 

107 

108 dmag_vector = self.star_var.applyRRly([np.arange(n_obj, dtype=int)], 

109 params, 

110 mjd_arr) 

111 

112 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

113 

114 for i_time, mjd in enumerate(mjd_arr): 

115 dmag_test = self.star_var.applyRRly([np.arange(n_obj,dtype=int)], 

116 params, 

117 mjd) 

118 

119 for i_star in range(n_obj): 

120 for i_band in range(6): 

121 self.assertEqual(dmag_vector[i_band][i_star][i_time], 

122 dmag_test[i_band][i_star]) 

123 

124 def test_RRLy_many_some_invalid(self): 

125 """ 

126 Test that the correct thing happens when some of the objects 

127 do not use the variability model. 

128 """ 

129 rng = np.random.RandomState(42) 

130 params = {} 

131 params['filename'] = ['rrly_lc/RRc/959802_per.txt', 

132 'rrly_lc/RRc/1078860_per.txt', 

133 'rrly_lc/RRab/98874_per.txt', 

134 'rrly_lc/RRab/3879827_per.txt'] 

135 

136 n_obj = len(params['filename']) 

137 

138 params['tStartMjd'] = rng.random_sample(n_obj)*1000.0+40000.0 

139 

140 mjd_arr = rng.random_sample(10)*3653.3+59580.0 

141 

142 n_time = len(mjd_arr) 

143 valid_dexes = [np.array([1,3])] 

144 

145 dmag_vector = self.star_var.applyRRly(valid_dexes, 

146 params, 

147 mjd_arr) 

148 

149 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

150 

151 for i_time, mjd in enumerate(mjd_arr): 

152 dmag_test = self.star_var.applyRRly(valid_dexes, 

153 params, 

154 mjd) 

155 

156 for i_star in range(n_obj): 

157 if i_star in (0, 2): 

158 for i_band in range(6): 

159 self.assertEqual(dmag_test[i_band][i_star], 0.0, 

160 msg='failed on obj %d; band %d; time %d' % (i_star, i_band, i_time)) 

161 for i_band in range(6): 

162 self.assertEqual(dmag_vector[i_band][i_star][i_time], 

163 dmag_test[i_band][i_star], 

164 msg='failed on obj %d; band %d; time %d' % (i_star, i_band, i_time)) 

165 

166 

167 def test_Cepeheid_many(self): 

168 rng = np.random.RandomState(8123) 

169 params = {} 

170 params['lcfile'] = ['cepheid_lc/classical_longPer_specfile', 

171 'cepheid_lc/classical_medPer_specfile', 

172 'cepheid_lc/classical_shortPer_specfile', 

173 'cepheid_lc/classical_shortPer_specfile', 

174 'cepheid_lc/popII_longPer_specfile', 

175 'cepheid_lc/popII_shortPer_specfile'] 

176 

177 n_obj = len(params['lcfile']) 

178 

179 params['t0'] = rng.random_sample(n_obj)*1000.0+40000.0 

180 

181 mjd_arr = rng.random_sample(10)*3653.3 + 59580.0 

182 

183 n_time = len(mjd_arr) 

184 

185 valid_dexes = [np.arange(n_obj, dtype=int)] 

186 

187 dmag_vector = self.star_var.applyCepheid(valid_dexes, params, mjd_arr) 

188 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

189 

190 for i_time, mjd in enumerate(mjd_arr): 

191 dmag_test = self.star_var.applyCepheid(valid_dexes, params, mjd) 

192 for i_band in range(6): 

193 for i_obj in range(n_obj): 

194 self.assertEqual(dmag_test[i_band][i_obj], 

195 dmag_vector[i_band][i_obj][i_time]) 

196 

197 def test_Cepeheid_many_some_invalid(self): 

198 """ 

199 Test that the correct thing happens when some of the objects 

200 do not use the variability model. 

201 """ 

202 rng = np.random.RandomState(8123) 

203 params = {} 

204 params['lcfile'] = ['cepheid_lc/classical_longPer_specfile', 

205 'cepheid_lc/classical_medPer_specfile', 

206 'cepheid_lc/classical_shortPer_specfile', 

207 'cepheid_lc/classical_shortPer_specfile', 

208 'cepheid_lc/popII_longPer_specfile', 

209 'cepheid_lc/popII_shortPer_specfile'] 

210 

211 n_obj = len(params['lcfile']) 

212 

213 params['t0'] = rng.random_sample(n_obj)*1000.0+40000.0 

214 

215 mjd_arr = rng.random_sample(10)*3653.3 + 59580.0 

216 

217 n_time = len(mjd_arr) 

218 

219 valid_dexes = [np.array([1,3])] 

220 

221 dmag_vector = self.star_var.applyCepheid(valid_dexes, params, mjd_arr) 

222 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

223 

224 for i_time, mjd in enumerate(mjd_arr): 

225 dmag_test = self.star_var.applyCepheid(valid_dexes, params, mjd) 

226 for i_band in range(6): 

227 for i_obj in range(n_obj): 

228 if i_obj not in (1, 3): 

229 self.assertEqual(dmag_test[i_band][i_obj], 0.0) 

230 self.assertEqual(dmag_test[i_band][i_obj], 

231 dmag_vector[i_band][i_obj][i_time]) 

232 

233 

234 def test_Eb_many(self): 

235 rng = np.random.RandomState(814512) 

236 params = {} 

237 params['lcfile'] = ['eb_lc/EB.2294.inp', 

238 'eb_lc/EB.1540.inp', 

239 'eb_lc/EB.2801.inp'] 

240 

241 n_obj = len(params['lcfile']) 

242 params['t0'] = rng.random_sample(n_obj)*20000.0+30000.0 

243 valid_dexes = [np.arange(n_obj, dtype=int)] 

244 mjd_arr = rng.random_sample(19)*3653.3+59580.0 

245 n_time = len(mjd_arr) 

246 dmag_vector = self.star_var.applyEb(valid_dexes, params, mjd_arr) 

247 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

248 

249 for i_time, mjd in enumerate(mjd_arr): 

250 dmag_test = self.star_var.applyEb(valid_dexes, params, mjd) 

251 for i_band in range(6): 

252 for i_obj in range(n_obj): 

253 self.assertEqual(dmag_test[i_band][i_obj], 

254 dmag_vector[i_band][i_obj][i_time]) 

255 

256 def test_Eb_many_some_invalid(self): 

257 """ 

258 Test that the correct thing happens when some of the objects 

259 do not use the variability model. 

260 """ 

261 rng = np.random.RandomState(814512) 

262 params = {} 

263 params['lcfile'] = ['eb_lc/EB.2294.inp', 

264 'eb_lc/EB.1540.inp', 

265 'eb_lc/EB.2801.inp'] 

266 

267 n_obj = len(params['lcfile']) 

268 params['t0'] = rng.random_sample(n_obj)*20000.0+30000.0 

269 valid_dexes = [np.array([0,2])] 

270 mjd_arr = rng.random_sample(19)*3653.3+59580.0 

271 n_time = len(mjd_arr) 

272 dmag_vector = self.star_var.applyEb(valid_dexes, params, mjd_arr) 

273 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

274 

275 for i_time, mjd in enumerate(mjd_arr): 

276 dmag_test = self.star_var.applyEb(valid_dexes, params, mjd) 

277 for i_band in range(6): 

278 for i_obj in range(n_obj): 

279 if i_obj not in (0, 2): 

280 self.assertEqual(dmag_test[i_band][i_obj], 0.0) 

281 self.assertEqual(dmag_test[i_band][i_obj], 

282 dmag_vector[i_band][i_obj][i_time]) 

283 

284 

285 def test_MicroLens_many(self): 

286 rng = np.random.RandomState(65123) 

287 n_obj = 5 

288 that = rng.random_sample(n_obj)*40.0+40.0 

289 umin = rng.random_sample(n_obj) 

290 mjDisplacement = rng.random_sample(n_obj)*50.0 

291 params = {} 

292 params['that'] = that 

293 params['umin'] = umin 

294 params['t0'] = mjDisplacement+51580.0 

295 

296 mjd_arr = rng.random_sample(17)*3653.3+59580.0 

297 n_time = len(mjd_arr) 

298 valid_dexes = [np.arange(n_obj, dtype=int)] 

299 dmag_vector = self.star_var.applyMicrolens(valid_dexes, params, mjd_arr) 

300 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

301 

302 for i_time, mjd in enumerate(mjd_arr): 

303 dmag_test = self.star_var.applyMicrolens(valid_dexes, params, mjd) 

304 self.assertEqual(dmag_test.shape, (6, n_obj)) 

305 for i_band in range(6): 

306 for i_obj in range(n_obj): 

307 self.assertEqual(dmag_test[i_band][i_obj], 

308 dmag_vector[i_band][i_obj][i_time]) 

309 

310 def test_MicroLens_many_some_invalid(self): 

311 """ 

312 Test that the correct thing happens when some of the objects 

313 do not use the variability model. 

314 """ 

315 rng = np.random.RandomState(65123) 

316 n_obj = 5 

317 that = rng.random_sample(n_obj)*40.0+40.0 

318 umin = rng.random_sample(n_obj) 

319 mjDisplacement = rng.random_sample(n_obj)*50.0 

320 params = {} 

321 params['that'] = that 

322 params['umin'] = umin 

323 params['t0'] = mjDisplacement+51580.0 

324 

325 mjd_arr = rng.random_sample(17)*3653.3+59580.0 

326 n_time = len(mjd_arr) 

327 valid_dexes = [np.array([1,3])] 

328 dmag_vector = self.star_var.applyMicrolens(valid_dexes, params, mjd_arr) 

329 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

330 

331 for i_time, mjd in enumerate(mjd_arr): 

332 dmag_test = self.star_var.applyMicrolens(valid_dexes, params, mjd) 

333 self.assertEqual(dmag_test.shape, (6, n_obj)) 

334 for i_band in range(6): 

335 for i_obj in range(n_obj): 

336 if i_obj not in (1,3): 

337 self.assertEqual(dmag_test[i_band][i_obj], 0.0) 

338 self.assertEqual(dmag_test[i_band][i_obj], 

339 dmag_vector[i_band][i_obj][i_time]) 

340 

341 

342 def test_Amcvn_many(self): 

343 rng = np.random.RandomState(71242) 

344 n_obj = 20 

345 doesBurst = rng.randint(0, 2, size=n_obj) 

346 burst_freq = rng.randint(10, 150, size=n_obj) 

347 burst_scale = np.array([1500.0]*n_obj) 

348 amp_burst = rng.random_sample(n_obj)*8.0 

349 color_excess_during_burst = rng.random_sample(n_obj)*0.2-0.4 

350 amplitude = rng.random_sample(n_obj)*0.2 

351 period = rng.random_sample(n_obj)*200.0 

352 mjDisplacement = rng.random_sample(n_obj)*500.0 

353 params = {} 

354 params['does_burst'] = doesBurst 

355 params['burst_freq'] = burst_freq 

356 params['burst_scale'] = burst_scale 

357 params['amp_burst'] = amp_burst 

358 params['color_excess_during_burst'] = color_excess_during_burst 

359 params['amplitude'] = amplitude 

360 params['period'] = period 

361 params['t0'] = 51500.0-mjDisplacement 

362 

363 mjd_arr = rng.random_sample(100)*3653.3+59580.0 

364 n_time = len(mjd_arr) 

365 

366 valid_dexes = [np.arange(n_obj, dtype=int)] 

367 

368 dmag_vector = self.star_var.applyAmcvn(valid_dexes, params, mjd_arr) 

369 

370 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

371 for i_time, mjd in enumerate(mjd_arr): 

372 dmag_test = self.star_var.applyAmcvn(valid_dexes, params, mjd) 

373 self.assertEqual(dmag_test.shape, (6, n_obj)) 

374 dmag_old = applyAmcvn_original(valid_dexes, params,mjd) 

375 for i_obj in range(n_obj): 

376 for i_band in range(6): 

377 self.assertEqual(dmag_test[i_band][i_obj], 

378 dmag_old[i_band][i_obj]) 

379 self.assertEqual(dmag_test[i_band][i_obj], 

380 dmag_vector[i_band][i_obj][i_time]) 

381 

382 def test_Amcvn_many_some_invalid(self): 

383 """ 

384 Test that the correct thing happens when some of the objects 

385 do not use the variability model. 

386 """ 

387 rng = np.random.RandomState(71242) 

388 n_obj = 20 

389 doesBurst = rng.randint(0, 2, size=n_obj) 

390 burst_freq = rng.randint(10, 150, size=n_obj) 

391 burst_scale = np.array([1500.0]*n_obj) 

392 amp_burst = rng.random_sample(n_obj)*8.0 

393 color_excess_during_burst = rng.random_sample(n_obj)*0.2-0.4 

394 amplitude = rng.random_sample(n_obj)*0.2 

395 period = rng.random_sample(n_obj)*200.0 

396 mjDisplacement = rng.random_sample(n_obj)*500.0 

397 params = {} 

398 params['does_burst'] = doesBurst 

399 params['burst_freq'] = burst_freq 

400 params['burst_scale'] = burst_scale 

401 params['amp_burst'] = amp_burst 

402 params['color_excess_during_burst'] = color_excess_during_burst 

403 params['amplitude'] = amplitude 

404 params['period'] = period 

405 params['t0'] = 51500.0-mjDisplacement 

406 

407 mjd_arr = rng.random_sample(100)*3653.3+59580.0 

408 n_time = len(mjd_arr) 

409 

410 valid_dexes = [np.array([1,5,6])] 

411 

412 dmag_vector = self.star_var.applyAmcvn(valid_dexes, params, mjd_arr) 

413 

414 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

415 for i_time, mjd in enumerate(mjd_arr): 

416 dmag_test = self.star_var.applyAmcvn(valid_dexes, params, mjd) 

417 self.assertEqual(dmag_test.shape, (6, n_obj)) 

418 dmag_old = applyAmcvn_original(valid_dexes, params,mjd) 

419 for i_obj in range(n_obj): 

420 for i_band in range(6): 

421 if i_obj not in(1,5,6): 

422 self.assertEqual(dmag_test[i_band][i_obj], 0.0) 

423 self.assertEqual(dmag_test[i_band][i_obj], 

424 dmag_old[i_band][i_obj]) 

425 self.assertEqual(dmag_test[i_band][i_obj], 

426 dmag_vector[i_band][i_obj][i_time]) 

427 

428 

429 def test_BHMicrolens_many(self): 

430 rng = np.random.RandomState(5132) 

431 params = {} 

432 params['filename'] = ['microlens/bh_binary_source/lc_14_25_75_8000_0_0.05_316', 

433 'microlens/bh_binary_source/lc_14_25_4000_8000_0_phi1.09_0.005_100', 

434 'microlens/bh_binary_source/lc_14_25_75_8000_0_tets2.09_0.005_316'] 

435 

436 n_obj = len(params['filename']) 

437 params['t0'] = rng.random_sample(n_obj)*10.0+59580.0 

438 

439 mjd_arr = rng.random_sample(12)*4.0+59590.0 

440 n_time = len(mjd_arr) 

441 valid_dexes = [np.arange(n_obj, dtype=int)] 

442 

443 dmag_vector = self.star_var.applyBHMicrolens(valid_dexes, params, mjd_arr) 

444 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

445 

446 for i_time, mjd in enumerate(mjd_arr): 

447 dmag_test = self.star_var.applyBHMicrolens(valid_dexes, params, mjd) 

448 self.assertEqual(dmag_test.shape, (6, n_obj)) 

449 for i_band in range(6): 

450 for i_obj in range(n_obj): 

451 self.assertTrue(isinstance(dmag_test[i_band][i_obj], numbers.Number)) 

452 self.assertEqual(dmag_test[i_band][i_obj], 

453 dmag_vector[i_band][i_obj][i_time]) 

454 

455 def test_BHMicrolens_many_some_invalid(self): 

456 """ 

457 Test that the correct thing happens when some of the objects 

458 do not use the variability model. 

459 """ 

460 rng = np.random.RandomState(5132) 

461 params = {} 

462 params['filename'] = ['microlens/bh_binary_source/lc_14_25_75_8000_0_0.05_316', 

463 'microlens/bh_binary_source/lc_14_25_4000_8000_0_phi1.09_0.005_100', 

464 'microlens/bh_binary_source/lc_14_25_75_8000_0_tets2.09_0.005_316'] 

465 

466 n_obj = len(params['filename']) 

467 params['t0'] = rng.random_sample(n_obj)*10.0+59580.0 

468 

469 mjd_arr = rng.random_sample(12)*4.0+59590.0 

470 n_time = len(mjd_arr) 

471 valid_dexes = [np.array([1])] 

472 

473 dmag_vector = self.star_var.applyBHMicrolens(valid_dexes, params, mjd_arr) 

474 self.assertEqual(dmag_vector.shape, (6, n_obj, n_time)) 

475 

476 for i_time, mjd in enumerate(mjd_arr): 

477 dmag_test = self.star_var.applyBHMicrolens(valid_dexes, params, mjd) 

478 self.assertEqual(dmag_test.shape, (6, n_obj)) 

479 for i_band in range(6): 

480 for i_obj in range(n_obj): 

481 if i_obj != 1: 

482 self.assertEqual(dmag_test[i_band][i_obj], 0.0) 

483 self.assertTrue(isinstance(dmag_test[i_band][i_obj], numbers.Number)) 

484 self.assertEqual(dmag_test[i_band][i_obj], 

485 dmag_vector[i_band][i_obj][i_time]) 

486 

487 

488class AgnVariability_at_many_times_case(unittest.TestCase): 

489 """ 

490 This test case will verify that the AGN variability 

491 model in CatSim deals correctly with receiving a vector 

492 of time values. 

493 """ 

494 

495 longMessage = True 

496 

497 def test_agn_many(self): 

498 agn_model = ExtraGalacticVariabilityModels() 

499 rng = np.random.RandomState(7153) 

500 params = {} 

501 n_obj = 5 

502 params['agn_tau'] = rng.random_sample(n_obj)*100.0+100.0 

503 params['agn_sfu'] = rng.random_sample(n_obj)*2.0 

504 params['agn_sfg'] = rng.random_sample(n_obj)*2.0 

505 params['agn_sfr'] = rng.random_sample(n_obj)*2.0 

506 params['agn_sfi'] = rng.random_sample(n_obj)*2.0 

507 params['agn_sfz'] = rng.random_sample(n_obj)*2.0 

508 params['agn_sfy'] = rng.random_sample(n_obj)*2.0 

509 params['t0_mjd'] = 48000.0+rng.random_sample(n_obj)*5.0 

510 params['seed'] = rng.randint(0, 20000, size=n_obj) 

511 redshift_arr = rng.random_sample(n_obj)*5.0 

512 

513 mjd_arr = np.sort(rng.random_sample(6)*3653.3+59580.0) 

514 n_time = len(mjd_arr) 

515 

516 valid_dexes = [np.arange(n_obj, dtype=int)] 

517 dmag_vector = agn_model.applyAgn(valid_dexes, params, mjd_arr, 

518 redshift=redshift_arr) 

519 self.assertEqual(dmag_vector.shape, (6, n_obj,n_time)) 

520 

521 for i_time, mjd in enumerate(mjd_arr): 

522 dmag_test = agn_model.applyAgn(valid_dexes, params, mjd, 

523 redshift=redshift_arr) 

524 self.assertEqual(dmag_test.shape, (6, n_obj)) 

525 for i_band in range(6): 

526 for i_obj in range(n_obj): 

527 self.assertAlmostEqual(dmag_vector[i_band][i_obj][i_time], 

528 dmag_test[i_band][i_obj], 6, 

529 msg='failed on band %d obj %d time %d' % (i_band, i_obj, i_time)) 

530 

531 def test_agn_many_some_invalid(self): 

532 """ 

533 Test that the correct thing happens when some of the objects 

534 do not use the variability model. 

535 """ 

536 agn_model = ExtraGalacticVariabilityModels() 

537 rng = np.random.RandomState(7153) 

538 params = {} 

539 n_obj = 5 

540 params['agn_tau'] = rng.random_sample(n_obj)*100.0+100.0 

541 params['agn_sfu'] = rng.random_sample(n_obj)*2.0 

542 params['agn_sfg'] = rng.random_sample(n_obj)*2.0 

543 params['agn_sfr'] = rng.random_sample(n_obj)*2.0 

544 params['agn_sfi'] = rng.random_sample(n_obj)*2.0 

545 params['agn_sfz'] = rng.random_sample(n_obj)*2.0 

546 params['agn_sfy'] = rng.random_sample(n_obj)*2.0 

547 params['t0_mjd'] = 48000.0+rng.random_sample(n_obj)*5.0 

548 params['seed'] = rng.randint(0, 20000, size=n_obj) 

549 redshift_arr = rng.random_sample(n_obj)*5.0 

550 

551 mjd_arr = np.sort(rng.random_sample(6)*3653.3+59580.0) 

552 n_time = len(mjd_arr) 

553 

554 valid_dexes = [np.array([1,2,4])] 

555 dmag_vector = agn_model.applyAgn(valid_dexes, params, mjd_arr, 

556 redshift=redshift_arr) 

557 self.assertEqual(dmag_vector.shape, (6, n_obj,n_time)) 

558 

559 for i_time, mjd in enumerate(mjd_arr): 

560 dmag_test = agn_model.applyAgn(valid_dexes, params, mjd, 

561 redshift=redshift_arr) 

562 self.assertEqual(dmag_test.shape, (6, n_obj)) 

563 for i_band in range(6): 

564 for i_obj in range(n_obj): 

565 if i_obj not in (1,2,4): 

566 self.assertEqual(dmag_test[i_band][i_obj], 0.0) 

567 self.assertAlmostEqual(dmag_vector[i_band][i_obj][i_time], 

568 dmag_test[i_band][i_obj], 6, 

569 msg='failed on band %d obj %d time %d' % (i_band, i_obj, i_time)) 

570 

571 

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

573 pass 

574 

575if __name__ == "__main__": 575 ↛ 576line 575 didn't jump to line 576, because the condition on line 575 was never true

576 lsst.utils.tests.init() 

577 unittest.main()