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

1from __future__ import with_statement 

2from builtins import zip 

3from builtins import range 

4import unittest 

5import os 

6import numpy as np 

7import lsst.utils.tests 

8from lsst.utils import getPackageDir 

9 

10from lsst.sims.photUtils import Bandpass, Sed, SedList 

11 

12 

13def setup_module(module): 

14 lsst.utils.tests.init() 

15 

16 

17class SedListTest(unittest.TestCase): 

18 

19 def setUp(self): 

20 self.rng = np.random.RandomState(18233) 

21 self.sedDir = os.path.join(getPackageDir('sims_photUtils'), 

22 'tests/cartoonSedTestData/galaxySed/') 

23 self.sedPossibilities = os.listdir(self.sedDir) 

24 

25 def getListOfSedNames(self, nNames): 

26 return [self.sedPossibilities[ii].replace('.gz', '') 

27 for ii in 

28 self.rng.randint(0, len(self.sedPossibilities)-1, nNames)] 

29 

30 def testExceptions(self): 

31 """ 

32 Test that exceptions are raised when they should be 

33 """ 

34 nSed = 10 

35 sedNameList = self.getListOfSedNames(nSed) 

36 magNormList = self.rng.random_sample(nSed)*5.0 + 15.0 

37 internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1 

38 redshiftList = self.rng.random_sample(nSed)*5.0 

39 galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1 

40 wavelen_match = np.arange(300.0, 1500.0, 10.0) 

41 testList = SedList(sedNameList, magNormList, 

42 fileDir=self.sedDir, 

43 internalAvList=internalAvList, 

44 redshiftList=redshiftList, 

45 galacticAvList=galacticAvList, 

46 wavelenMatch=wavelen_match) 

47 

48 with self.assertRaises(AttributeError) as context: 

49 testList.wavelenMatch = np.arange(10.0, 1000.0, 1000.0) 

50 

51 with self.assertRaises(AttributeError) as context: 

52 testList.cosmologicalDimming = False 

53 

54 with self.assertRaises(AttributeError) as context: 

55 testList.redshiftList = [1.8] 

56 

57 with self.assertRaises(AttributeError) as context: 

58 testList.internalAvList = [2.5] 

59 

60 with self.assertRaises(AttributeError) as context: 

61 testList.galacticAvList = [1.9] 

62 

63 testList = SedList(sedNameList, magNormList, fileDir=self.sedDir) 

64 

65 with self.assertRaises(RuntimeError) as context: 

66 testList.loadSedsFromList(sedNameList, magNormList, internalAvList=internalAvList) 

67 self.assertIn('does not contain internalAvList', context.exception.args[0]) 

68 

69 with self.assertRaises(RuntimeError) as context: 

70 testList.loadSedsFromList(sedNameList, magNormList, galacticAvList=galacticAvList) 

71 self.assertIn('does not contain galacticAvList', context.exception.args[0]) 

72 

73 with self.assertRaises(RuntimeError) as context: 

74 testList.loadSedsFromList(sedNameList, magNormList, redshiftList=redshiftList) 

75 self.assertIn('does not contain redshiftList', context.exception.args[0]) 

76 

77 def testSetUp(self): 

78 """ 

79 Test the SedList can be successfully initialized 

80 """ 

81 

82 ############## Try just reading in an normalizing some SEDs 

83 nSed = 10 

84 sedNameList = self.getListOfSedNames(nSed) 

85 magNormList = self.rng.random_sample(nSed)*5.0 + 15.0 

86 testList = SedList(sedNameList, magNormList, fileDir=self.sedDir) 

87 self.assertEqual(len(testList), nSed) 

88 self.assertIsNone(testList.internalAvList) 

89 self.assertIsNone(testList.galacticAvList) 

90 self.assertIsNone(testList.redshiftList) 

91 self.assertIsNone(testList.wavelenMatch) 

92 self.assertTrue(testList.cosmologicalDimming) 

93 

94 imsimBand = Bandpass() 

95 imsimBand.imsimBandpass() 

96 

97 for name, norm, sedTest in zip(sedNameList, magNormList, testList): 

98 sedControl = Sed() 

99 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

100 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

101 sedControl.multiplyFluxNorm(fnorm) 

102 

103 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

104 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

105 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

106 

107 ################# now add an internalAv 

108 sedNameList = self.getListOfSedNames(nSed) 

109 magNormList = self.rng.random_sample(nSed)*5.0 + 15.0 

110 internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1 

111 testList = SedList(sedNameList, magNormList, 

112 fileDir=self.sedDir, 

113 internalAvList=internalAvList) 

114 self.assertIsNone(testList.galacticAvList) 

115 self.assertIsNone(testList.redshiftList) 

116 self.assertIsNone(testList.wavelenMatch) 

117 self.assertTrue(testList.cosmologicalDimming) 

118 for avControl, avTest in zip(internalAvList, testList.internalAvList): 

119 self.assertAlmostEqual(avControl, avTest, 10) 

120 

121 for name, norm, av, sedTest in zip(sedNameList, magNormList, internalAvList, testList): 

122 sedControl = Sed() 

123 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

124 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

125 sedControl.multiplyFluxNorm(fnorm) 

126 

127 a_coeff, b_coeff = sedControl.setupCCM_ab() 

128 sedControl.addDust(a_coeff, b_coeff, A_v=av) 

129 

130 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

131 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

132 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

133 

134 ################ now add redshift 

135 sedNameList = self.getListOfSedNames(nSed) 

136 magNormList = self.rng.random_sample(nSed)*5.0 + 15.0 

137 internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1 

138 redshiftList = self.rng.random_sample(nSed)*5.0 

139 testList = SedList(sedNameList, magNormList, 

140 fileDir=self.sedDir, 

141 internalAvList=internalAvList, 

142 redshiftList=redshiftList) 

143 self.assertIsNone(testList.galacticAvList) 

144 self.assertIsNone(testList.wavelenMatch) 

145 self.assertTrue(testList.cosmologicalDimming) 

146 for avControl, avTest in zip(internalAvList, testList.internalAvList): 

147 self.assertAlmostEqual(avControl, avTest, 10) 

148 

149 for zControl, zTest in zip(redshiftList, testList.redshiftList): 

150 self.assertAlmostEqual(zControl, zTest, 10) 

151 

152 for name, norm, av, zz, sedTest in \ 

153 zip(sedNameList, magNormList, internalAvList, redshiftList, testList): 

154 

155 sedControl = Sed() 

156 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

157 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

158 sedControl.multiplyFluxNorm(fnorm) 

159 

160 a_coeff, b_coeff = sedControl.setupCCM_ab() 

161 sedControl.addDust(a_coeff, b_coeff, A_v=av) 

162 

163 sedControl.redshiftSED(zz, dimming=True) 

164 

165 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

166 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

167 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

168 

169 ################# without cosmological dimming 

170 sedNameList = self.getListOfSedNames(nSed) 

171 magNormList = self.rng.random_sample(nSed)*5.0 + 15.0 

172 internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1 

173 redshiftList = self.rng.random_sample(nSed)*5.0 

174 testList = SedList(sedNameList, magNormList, 

175 fileDir=self.sedDir, 

176 internalAvList=internalAvList, 

177 redshiftList=redshiftList, cosmologicalDimming=False) 

178 self.assertIsNone(testList.galacticAvList) 

179 self.assertIsNone(testList.wavelenMatch) 

180 self.assertFalse(testList.cosmologicalDimming) 

181 for avControl, avTest in zip(internalAvList, testList.internalAvList): 

182 self.assertAlmostEqual(avControl, avTest, 10) 

183 

184 for zControl, zTest in zip(redshiftList, testList.redshiftList): 

185 self.assertAlmostEqual(zControl, zTest, 10) 

186 

187 for name, norm, av, zz, sedTest in \ 

188 zip(sedNameList, magNormList, internalAvList, redshiftList, testList): 

189 

190 sedControl = Sed() 

191 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

192 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

193 sedControl.multiplyFluxNorm(fnorm) 

194 

195 a_coeff, b_coeff = sedControl.setupCCM_ab() 

196 sedControl.addDust(a_coeff, b_coeff, A_v=av) 

197 

198 sedControl.redshiftSED(zz, dimming=False) 

199 

200 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

201 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

202 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

203 

204 ################ now add galacticAv 

205 sedNameList = self.getListOfSedNames(nSed) 

206 magNormList = self.rng.random_sample(nSed)*5.0 + 15.0 

207 internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1 

208 redshiftList = self.rng.random_sample(nSed)*5.0 

209 galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1 

210 testList = SedList(sedNameList, magNormList, 

211 fileDir=self.sedDir, 

212 internalAvList=internalAvList, 

213 redshiftList=redshiftList, galacticAvList=galacticAvList) 

214 self.assertIsNone(testList.wavelenMatch) 

215 self.assertTrue(testList.cosmologicalDimming) 

216 for avControl, avTest in zip(internalAvList, testList.internalAvList): 

217 self.assertAlmostEqual(avControl, avTest, 10) 

218 

219 for zControl, zTest in zip(redshiftList, testList.redshiftList): 

220 self.assertAlmostEqual(zControl, zTest, 10) 

221 

222 for avControl, avTest in zip(galacticAvList, testList.galacticAvList): 

223 self.assertAlmostEqual(avControl, avTest, 10) 

224 

225 for name, norm, av, zz, gav, sedTest in \ 

226 zip(sedNameList, magNormList, internalAvList, 

227 redshiftList, galacticAvList, testList): 

228 

229 sedControl = Sed() 

230 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

231 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

232 sedControl.multiplyFluxNorm(fnorm) 

233 

234 a_coeff, b_coeff = sedControl.setupCCM_ab() 

235 sedControl.addDust(a_coeff, b_coeff, A_v=av) 

236 

237 sedControl.redshiftSED(zz, dimming=True) 

238 

239 a_coeff, b_coeff = sedControl.setupCCM_ab() 

240 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

241 

242 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

243 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

244 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

245 

246 ################ now use a wavelen_match 

247 sedNameList = self.getListOfSedNames(nSed) 

248 magNormList = self.rng.random_sample(nSed)*5.0 + 15.0 

249 internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1 

250 redshiftList = self.rng.random_sample(nSed)*5.0 

251 galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1 

252 wavelen_match = np.arange(300.0, 1500.0, 10.0) 

253 testList = SedList(sedNameList, magNormList, 

254 fileDir=self.sedDir, 

255 internalAvList=internalAvList, 

256 redshiftList=redshiftList, galacticAvList=galacticAvList, 

257 wavelenMatch=wavelen_match) 

258 

259 self.assertTrue(testList.cosmologicalDimming) 

260 for avControl, avTest in zip(internalAvList, testList.internalAvList): 

261 self.assertAlmostEqual(avControl, avTest, 10) 

262 

263 for zControl, zTest in zip(redshiftList, testList.redshiftList): 

264 self.assertAlmostEqual(zControl, zTest, 10) 

265 

266 for avControl, avTest in zip(galacticAvList, testList.galacticAvList): 

267 self.assertAlmostEqual(avControl, avTest, 10) 

268 

269 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch) 

270 

271 for name, norm, av, zz, gav, sedTest in \ 

272 zip(sedNameList, magNormList, internalAvList, 

273 redshiftList, galacticAvList, testList): 

274 

275 sedControl = Sed() 

276 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

277 

278 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

279 sedControl.multiplyFluxNorm(fnorm) 

280 

281 a_coeff, b_coeff = sedControl.setupCCM_ab() 

282 sedControl.addDust(a_coeff, b_coeff, A_v=av) 

283 

284 sedControl.redshiftSED(zz, dimming=True) 

285 sedControl.resampleSED(wavelen_match=wavelen_match) 

286 

287 a_coeff, b_coeff = sedControl.setupCCM_ab() 

288 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

289 

290 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

291 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

292 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

293 

294 def testAddingToList(self): 

295 """ 

296 Test that we can add Seds to an already instantiated SedList 

297 """ 

298 imsimBand = Bandpass() 

299 imsimBand.imsimBandpass() 

300 nSed = 10 

301 sedNameList_0 = self.getListOfSedNames(nSed) 

302 magNormList_0 = self.rng.random_sample(nSed)*5.0 + 15.0 

303 internalAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1 

304 redshiftList_0 = self.rng.random_sample(nSed)*5.0 

305 galacticAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1 

306 wavelen_match = np.arange(300.0, 1500.0, 10.0) 

307 testList = SedList(sedNameList_0, magNormList_0, 

308 fileDir=self.sedDir, 

309 internalAvList=internalAvList_0, 

310 redshiftList=redshiftList_0, galacticAvList=galacticAvList_0, 

311 wavelenMatch=wavelen_match) 

312 

313 # experiment with adding different combinations of physical parameter lists 

314 # as None and not None 

315 for addIav in [True, False]: 

316 for addRedshift in [True, False]: 

317 for addGav in [True, False]: 

318 

319 testList = SedList(sedNameList_0, magNormList_0, 

320 fileDir=self.sedDir, 

321 internalAvList=internalAvList_0, 

322 redshiftList=redshiftList_0, galacticAvList=galacticAvList_0, 

323 wavelenMatch=wavelen_match) 

324 

325 sedNameList_1 = self.getListOfSedNames(nSed) 

326 magNormList_1 = self.rng.random_sample(nSed)*5.0 + 15.0 

327 

328 if addIav: 

329 internalAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1 

330 else: 

331 internalAvList_1 = None 

332 

333 if addRedshift: 

334 redshiftList_1 = self.rng.random_sample(nSed)*5.0 

335 else: 

336 redshiftList_1 = None 

337 

338 if addGav: 

339 galacticAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1 

340 else: 

341 galacticAvList_1 = None 

342 

343 testList.loadSedsFromList(sedNameList_1, magNormList_1, 

344 internalAvList=internalAvList_1, 

345 galacticAvList=galacticAvList_1, 

346 redshiftList=redshiftList_1) 

347 

348 self.assertEqual(len(testList), 2*nSed) 

349 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch) 

350 

351 for ix in range(len(sedNameList_0)): 

352 self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10) 

353 self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10) 

354 self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10) 

355 

356 for ix in range(len(sedNameList_1)): 

357 if addIav: 

358 self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10) 

359 else: 

360 self.assertIsNone(testList.internalAvList[ix+nSed]) 

361 

362 if addGav: 

363 self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10) 

364 else: 

365 self.assertIsNone(testList.galacticAvList[ix+nSed]) 

366 

367 if addRedshift: 

368 self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10) 

369 else: 

370 self.assertIsNone(testList.redshiftList[ix+nSed]) 

371 

372 for ix, (name, norm, iav, gav, zz) in \ 

373 enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, 

374 galacticAvList_0, redshiftList_0)): 

375 

376 sedControl = Sed() 

377 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

378 

379 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

380 sedControl.multiplyFluxNorm(fnorm) 

381 

382 a_coeff, b_coeff = sedControl.setupCCM_ab() 

383 sedControl.addDust(a_coeff, b_coeff, A_v=iav) 

384 

385 sedControl.redshiftSED(zz, dimming=True) 

386 sedControl.resampleSED(wavelen_match=wavelen_match) 

387 

388 a_coeff, b_coeff = sedControl.setupCCM_ab() 

389 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

390 

391 sedTest = testList[ix] 

392 

393 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

394 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

395 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

396 

397 if not addIav: 

398 internalAvList_1 = [None] * nSed 

399 

400 if not addRedshift: 

401 redshiftList_1 = [None] * nSed 

402 

403 if not addGav: 

404 galacticAvList_1 = [None] * nSed 

405 

406 for ix, (name, norm, iav, gav, zz) in \ 

407 enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, 

408 galacticAvList_1, redshiftList_1)): 

409 

410 sedControl = Sed() 

411 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

412 

413 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

414 sedControl.multiplyFluxNorm(fnorm) 

415 

416 if addIav: 

417 a_coeff, b_coeff = sedControl.setupCCM_ab() 

418 sedControl.addDust(a_coeff, b_coeff, A_v=iav) 

419 

420 if addRedshift: 

421 sedControl.redshiftSED(zz, dimming=True) 

422 

423 sedControl.resampleSED(wavelen_match=wavelen_match) 

424 

425 if addGav: 

426 a_coeff, b_coeff = sedControl.setupCCM_ab() 

427 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

428 

429 sedTest = testList[ix+nSed] 

430 

431 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

432 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

433 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

434 

435 def testAddingNonesToList(self): 

436 """ 

437 Test what happens if you add SEDs to an SedList that have None for 

438 one or more of the physical parameters (i.e. galacticAv, internalAv, or redshift) 

439 """ 

440 imsimBand = Bandpass() 

441 imsimBand.imsimBandpass() 

442 nSed = 10 

443 sedNameList_0 = self.getListOfSedNames(nSed) 

444 magNormList_0 = self.rng.random_sample(nSed)*5.0 + 15.0 

445 internalAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1 

446 redshiftList_0 = self.rng.random_sample(nSed)*5.0 

447 galacticAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1 

448 wavelen_match = np.arange(300.0, 1500.0, 10.0) 

449 testList = SedList(sedNameList_0, magNormList_0, 

450 fileDir=self.sedDir, 

451 internalAvList=internalAvList_0, 

452 redshiftList=redshiftList_0, galacticAvList=galacticAvList_0, 

453 wavelenMatch=wavelen_match) 

454 

455 sedNameList_1 = self.getListOfSedNames(nSed) 

456 magNormList_1 = list(self.rng.random_sample(nSed)*5.0 + 15.0) 

457 internalAvList_1 = list(self.rng.random_sample(nSed)*0.3 + 0.1) 

458 redshiftList_1 = list(self.rng.random_sample(nSed)*5.0) 

459 galacticAvList_1 = list(self.rng.random_sample(nSed)*0.3 + 0.1) 

460 

461 internalAvList_1[0] = None 

462 redshiftList_1[1] = None 

463 galacticAvList_1[2] = None 

464 

465 internalAvList_1[3] = None 

466 redshiftList_1[3] = None 

467 

468 internalAvList_1[4] = None 

469 galacticAvList_1[4] = None 

470 

471 redshiftList_1[5] = None 

472 galacticAvList_1[5] = None 

473 

474 internalAvList_1[6] = None 

475 redshiftList_1[6] = None 

476 galacticAvList_1[6] = None 

477 

478 testList.loadSedsFromList(sedNameList_1, magNormList_1, 

479 internalAvList=internalAvList_1, 

480 galacticAvList=galacticAvList_1, 

481 redshiftList=redshiftList_1) 

482 

483 self.assertEqual(len(testList), 2*nSed) 

484 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch) 

485 

486 for ix in range(len(sedNameList_0)): 

487 self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10) 

488 self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10) 

489 self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10) 

490 

491 for ix in range(len(sedNameList_1)): 

492 self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10) 

493 self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10) 

494 self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10) 

495 

496 for ix, (name, norm, iav, gav, zz) in \ 

497 enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, 

498 galacticAvList_0, redshiftList_0)): 

499 

500 sedControl = Sed() 

501 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

502 

503 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

504 sedControl.multiplyFluxNorm(fnorm) 

505 

506 a_coeff, b_coeff = sedControl.setupCCM_ab() 

507 sedControl.addDust(a_coeff, b_coeff, A_v=iav) 

508 

509 sedControl.redshiftSED(zz, dimming=True) 

510 sedControl.resampleSED(wavelen_match=wavelen_match) 

511 

512 a_coeff, b_coeff = sedControl.setupCCM_ab() 

513 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

514 

515 sedTest = testList[ix] 

516 

517 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

518 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

519 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

520 

521 for ix, (name, norm, iav, gav, zz) in \ 

522 enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, 

523 galacticAvList_1, redshiftList_1)): 

524 

525 sedControl = Sed() 

526 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

527 

528 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

529 sedControl.multiplyFluxNorm(fnorm) 

530 

531 if iav is not None: 

532 a_coeff, b_coeff = sedControl.setupCCM_ab() 

533 sedControl.addDust(a_coeff, b_coeff, A_v=iav) 

534 

535 if zz is not None: 

536 sedControl.redshiftSED(zz, dimming=True) 

537 

538 sedControl.resampleSED(wavelen_match=wavelen_match) 

539 

540 if gav is not None: 

541 a_coeff, b_coeff = sedControl.setupCCM_ab() 

542 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

543 

544 sedTest = testList[ix+nSed] 

545 

546 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

547 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

548 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

549 

550 def testAlternateNormalizingBandpass(self): 

551 """ 

552 A reiteration of testAddingToList, but testing with a non-imsimBandpass 

553 normalizing bandpass 

554 """ 

555 normalizingBand = Bandpass() 

556 normalizingBand.readThroughput(os.path.join(getPackageDir('throughputs'), 'baseline', 'total_r.dat')) 

557 nSed = 10 

558 sedNameList_0 = self.getListOfSedNames(nSed) 

559 magNormList_0 = self.rng.random_sample(nSed)*5.0 + 15.0 

560 internalAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1 

561 redshiftList_0 = self.rng.random_sample(nSed)*5.0 

562 galacticAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1 

563 wavelen_match = np.arange(300.0, 1500.0, 10.0) 

564 testList = SedList(sedNameList_0, magNormList_0, 

565 fileDir=self.sedDir, 

566 normalizingBandpass=normalizingBand, 

567 internalAvList=internalAvList_0, 

568 redshiftList=redshiftList_0, galacticAvList=galacticAvList_0, 

569 wavelenMatch=wavelen_match) 

570 

571 sedNameList_1 = self.getListOfSedNames(nSed) 

572 magNormList_1 = self.rng.random_sample(nSed)*5.0 + 15.0 

573 

574 internalAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1 

575 

576 redshiftList_1 = self.rng.random_sample(nSed)*5.0 

577 

578 galacticAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1 

579 

580 testList.loadSedsFromList(sedNameList_1, magNormList_1, 

581 internalAvList=internalAvList_1, 

582 galacticAvList=galacticAvList_1, 

583 redshiftList=redshiftList_1) 

584 

585 self.assertEqual(len(testList), 2*nSed) 

586 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch) 

587 

588 for ix in range(len(sedNameList_0)): 

589 self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10) 

590 self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10) 

591 self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10) 

592 

593 for ix in range(len(sedNameList_1)): 

594 self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10) 

595 self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10) 

596 self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10) 

597 

598 for ix, (name, norm, iav, gav, zz) in \ 

599 enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, 

600 galacticAvList_0, redshiftList_0)): 

601 

602 sedControl = Sed() 

603 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

604 

605 fnorm = sedControl.calcFluxNorm(norm, normalizingBand) 

606 sedControl.multiplyFluxNorm(fnorm) 

607 

608 a_coeff, b_coeff = sedControl.setupCCM_ab() 

609 sedControl.addDust(a_coeff, b_coeff, A_v=iav) 

610 

611 sedControl.redshiftSED(zz, dimming=True) 

612 sedControl.resampleSED(wavelen_match=wavelen_match) 

613 

614 a_coeff, b_coeff = sedControl.setupCCM_ab() 

615 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

616 

617 sedTest = testList[ix] 

618 

619 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

620 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

621 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

622 

623 for ix, (name, norm, iav, gav, zz) in \ 

624 enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, 

625 galacticAvList_1, redshiftList_1)): 

626 

627 sedControl = Sed() 

628 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

629 

630 fnorm = sedControl.calcFluxNorm(norm, normalizingBand) 

631 sedControl.multiplyFluxNorm(fnorm) 

632 

633 a_coeff, b_coeff = sedControl.setupCCM_ab() 

634 sedControl.addDust(a_coeff, b_coeff, A_v=iav) 

635 

636 sedControl.redshiftSED(zz, dimming=True) 

637 

638 sedControl.resampleSED(wavelen_match=wavelen_match) 

639 

640 a_coeff, b_coeff = sedControl.setupCCM_ab() 

641 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

642 

643 sedTest = testList[ix+nSed] 

644 

645 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

646 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

647 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

648 

649 def testFlush(self): 

650 """ 

651 Test that the flush method of SedList behaves properly 

652 """ 

653 imsimBand = Bandpass() 

654 imsimBand.imsimBandpass() 

655 nSed = 10 

656 sedNameList_0 = self.getListOfSedNames(nSed) 

657 magNormList_0 = self.rng.random_sample(nSed)*5.0 + 15.0 

658 internalAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1 

659 redshiftList_0 = self.rng.random_sample(nSed)*5.0 

660 galacticAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1 

661 wavelen_match = np.arange(300.0, 1500.0, 10.0) 

662 testList = SedList(sedNameList_0, magNormList_0, 

663 fileDir=self.sedDir, 

664 internalAvList=internalAvList_0, 

665 redshiftList=redshiftList_0, galacticAvList=galacticAvList_0, 

666 wavelenMatch=wavelen_match) 

667 

668 self.assertEqual(len(testList), nSed) 

669 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch) 

670 

671 for ix in range(len(sedNameList_0)): 

672 self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10) 

673 self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10) 

674 self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10) 

675 

676 for ix, (name, norm, iav, gav, zz) in \ 

677 enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, 

678 galacticAvList_0, redshiftList_0)): 

679 

680 sedControl = Sed() 

681 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

682 

683 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

684 sedControl.multiplyFluxNorm(fnorm) 

685 

686 a_coeff, b_coeff = sedControl.setupCCM_ab() 

687 sedControl.addDust(a_coeff, b_coeff, A_v=iav) 

688 

689 sedControl.redshiftSED(zz, dimming=True) 

690 sedControl.resampleSED(wavelen_match=wavelen_match) 

691 

692 a_coeff, b_coeff = sedControl.setupCCM_ab() 

693 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

694 

695 sedTest = testList[ix] 

696 

697 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

698 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

699 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

700 

701 testList.flush() 

702 

703 sedNameList_1 = self.getListOfSedNames(nSed//2) 

704 magNormList_1 = self.rng.random_sample(nSed//2)*5.0 + 15.0 

705 internalAvList_1 = self.rng.random_sample(nSed//2)*0.3 + 0.1 

706 redshiftList_1 = self.rng.random_sample(nSed//2)*5.0 

707 galacticAvList_1 = self.rng.random_sample(nSed//2)*0.3 + 0.1 

708 

709 testList.loadSedsFromList(sedNameList_1, magNormList_1, 

710 internalAvList=internalAvList_1, 

711 galacticAvList=galacticAvList_1, 

712 redshiftList=redshiftList_1) 

713 

714 self.assertEqual(len(testList), nSed/2) 

715 self.assertEqual(len(testList.redshiftList), nSed/2) 

716 self.assertEqual(len(testList.internalAvList), nSed/2) 

717 self.assertEqual(len(testList.galacticAvList), nSed/2) 

718 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch) 

719 

720 for ix in range(len(sedNameList_1)): 

721 self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix], 10) 

722 self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix], 10) 

723 self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix], 10) 

724 

725 for ix, (name, norm, iav, gav, zz) in \ 

726 enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, 

727 galacticAvList_1, redshiftList_1)): 

728 

729 sedControl = Sed() 

730 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz')) 

731 

732 fnorm = sedControl.calcFluxNorm(norm, imsimBand) 

733 sedControl.multiplyFluxNorm(fnorm) 

734 

735 a_coeff, b_coeff = sedControl.setupCCM_ab() 

736 sedControl.addDust(a_coeff, b_coeff, A_v=iav) 

737 

738 sedControl.redshiftSED(zz, dimming=True) 

739 sedControl.resampleSED(wavelen_match=wavelen_match) 

740 

741 a_coeff, b_coeff = sedControl.setupCCM_ab() 

742 sedControl.addDust(a_coeff, b_coeff, A_v=gav) 

743 

744 sedTest = testList[ix] 

745 

746 np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen) 

747 np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda) 

748 np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu) 

749 

750 

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

752 pass 

753 

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

755 lsst.utils.tests.init() 

756 unittest.main()