Coverage for tests/testSedList.py : 4%

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
10from lsst.sims.photUtils import Bandpass, Sed, SedList
13def setup_module(module):
14 lsst.utils.tests.init()
17class SedListTest(unittest.TestCase):
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)
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)]
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)
48 with self.assertRaises(AttributeError) as context:
49 testList.wavelenMatch = np.arange(10.0, 1000.0, 1000.0)
51 with self.assertRaises(AttributeError) as context:
52 testList.cosmologicalDimming = False
54 with self.assertRaises(AttributeError) as context:
55 testList.redshiftList = [1.8]
57 with self.assertRaises(AttributeError) as context:
58 testList.internalAvList = [2.5]
60 with self.assertRaises(AttributeError) as context:
61 testList.galacticAvList = [1.9]
63 testList = SedList(sedNameList, magNormList, fileDir=self.sedDir)
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])
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])
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])
77 def testSetUp(self):
78 """
79 Test the SedList can be successfully initialized
80 """
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)
94 imsimBand = Bandpass()
95 imsimBand.imsimBandpass()
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)
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)
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)
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)
127 a_coeff, b_coeff = sedControl.setupCCM_ab()
128 sedControl.addDust(a_coeff, b_coeff, A_v=av)
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)
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)
149 for zControl, zTest in zip(redshiftList, testList.redshiftList):
150 self.assertAlmostEqual(zControl, zTest, 10)
152 for name, norm, av, zz, sedTest in \
153 zip(sedNameList, magNormList, internalAvList, redshiftList, testList):
155 sedControl = Sed()
156 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
157 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
158 sedControl.multiplyFluxNorm(fnorm)
160 a_coeff, b_coeff = sedControl.setupCCM_ab()
161 sedControl.addDust(a_coeff, b_coeff, A_v=av)
163 sedControl.redshiftSED(zz, dimming=True)
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)
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)
184 for zControl, zTest in zip(redshiftList, testList.redshiftList):
185 self.assertAlmostEqual(zControl, zTest, 10)
187 for name, norm, av, zz, sedTest in \
188 zip(sedNameList, magNormList, internalAvList, redshiftList, testList):
190 sedControl = Sed()
191 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
192 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
193 sedControl.multiplyFluxNorm(fnorm)
195 a_coeff, b_coeff = sedControl.setupCCM_ab()
196 sedControl.addDust(a_coeff, b_coeff, A_v=av)
198 sedControl.redshiftSED(zz, dimming=False)
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)
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)
219 for zControl, zTest in zip(redshiftList, testList.redshiftList):
220 self.assertAlmostEqual(zControl, zTest, 10)
222 for avControl, avTest in zip(galacticAvList, testList.galacticAvList):
223 self.assertAlmostEqual(avControl, avTest, 10)
225 for name, norm, av, zz, gav, sedTest in \
226 zip(sedNameList, magNormList, internalAvList,
227 redshiftList, galacticAvList, testList):
229 sedControl = Sed()
230 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
231 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
232 sedControl.multiplyFluxNorm(fnorm)
234 a_coeff, b_coeff = sedControl.setupCCM_ab()
235 sedControl.addDust(a_coeff, b_coeff, A_v=av)
237 sedControl.redshiftSED(zz, dimming=True)
239 a_coeff, b_coeff = sedControl.setupCCM_ab()
240 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
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)
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)
259 self.assertTrue(testList.cosmologicalDimming)
260 for avControl, avTest in zip(internalAvList, testList.internalAvList):
261 self.assertAlmostEqual(avControl, avTest, 10)
263 for zControl, zTest in zip(redshiftList, testList.redshiftList):
264 self.assertAlmostEqual(zControl, zTest, 10)
266 for avControl, avTest in zip(galacticAvList, testList.galacticAvList):
267 self.assertAlmostEqual(avControl, avTest, 10)
269 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
271 for name, norm, av, zz, gav, sedTest in \
272 zip(sedNameList, magNormList, internalAvList,
273 redshiftList, galacticAvList, testList):
275 sedControl = Sed()
276 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
278 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
279 sedControl.multiplyFluxNorm(fnorm)
281 a_coeff, b_coeff = sedControl.setupCCM_ab()
282 sedControl.addDust(a_coeff, b_coeff, A_v=av)
284 sedControl.redshiftSED(zz, dimming=True)
285 sedControl.resampleSED(wavelen_match=wavelen_match)
287 a_coeff, b_coeff = sedControl.setupCCM_ab()
288 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
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)
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)
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]:
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)
325 sedNameList_1 = self.getListOfSedNames(nSed)
326 magNormList_1 = self.rng.random_sample(nSed)*5.0 + 15.0
328 if addIav:
329 internalAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1
330 else:
331 internalAvList_1 = None
333 if addRedshift:
334 redshiftList_1 = self.rng.random_sample(nSed)*5.0
335 else:
336 redshiftList_1 = None
338 if addGav:
339 galacticAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1
340 else:
341 galacticAvList_1 = None
343 testList.loadSedsFromList(sedNameList_1, magNormList_1,
344 internalAvList=internalAvList_1,
345 galacticAvList=galacticAvList_1,
346 redshiftList=redshiftList_1)
348 self.assertEqual(len(testList), 2*nSed)
349 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
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)
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])
362 if addGav:
363 self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
364 else:
365 self.assertIsNone(testList.galacticAvList[ix+nSed])
367 if addRedshift:
368 self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
369 else:
370 self.assertIsNone(testList.redshiftList[ix+nSed])
372 for ix, (name, norm, iav, gav, zz) in \
373 enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
374 galacticAvList_0, redshiftList_0)):
376 sedControl = Sed()
377 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
379 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
380 sedControl.multiplyFluxNorm(fnorm)
382 a_coeff, b_coeff = sedControl.setupCCM_ab()
383 sedControl.addDust(a_coeff, b_coeff, A_v=iav)
385 sedControl.redshiftSED(zz, dimming=True)
386 sedControl.resampleSED(wavelen_match=wavelen_match)
388 a_coeff, b_coeff = sedControl.setupCCM_ab()
389 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
391 sedTest = testList[ix]
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)
397 if not addIav:
398 internalAvList_1 = [None] * nSed
400 if not addRedshift:
401 redshiftList_1 = [None] * nSed
403 if not addGav:
404 galacticAvList_1 = [None] * nSed
406 for ix, (name, norm, iav, gav, zz) in \
407 enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
408 galacticAvList_1, redshiftList_1)):
410 sedControl = Sed()
411 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
413 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
414 sedControl.multiplyFluxNorm(fnorm)
416 if addIav:
417 a_coeff, b_coeff = sedControl.setupCCM_ab()
418 sedControl.addDust(a_coeff, b_coeff, A_v=iav)
420 if addRedshift:
421 sedControl.redshiftSED(zz, dimming=True)
423 sedControl.resampleSED(wavelen_match=wavelen_match)
425 if addGav:
426 a_coeff, b_coeff = sedControl.setupCCM_ab()
427 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
429 sedTest = testList[ix+nSed]
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)
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)
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)
461 internalAvList_1[0] = None
462 redshiftList_1[1] = None
463 galacticAvList_1[2] = None
465 internalAvList_1[3] = None
466 redshiftList_1[3] = None
468 internalAvList_1[4] = None
469 galacticAvList_1[4] = None
471 redshiftList_1[5] = None
472 galacticAvList_1[5] = None
474 internalAvList_1[6] = None
475 redshiftList_1[6] = None
476 galacticAvList_1[6] = None
478 testList.loadSedsFromList(sedNameList_1, magNormList_1,
479 internalAvList=internalAvList_1,
480 galacticAvList=galacticAvList_1,
481 redshiftList=redshiftList_1)
483 self.assertEqual(len(testList), 2*nSed)
484 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
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)
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)
496 for ix, (name, norm, iav, gav, zz) in \
497 enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
498 galacticAvList_0, redshiftList_0)):
500 sedControl = Sed()
501 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
503 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
504 sedControl.multiplyFluxNorm(fnorm)
506 a_coeff, b_coeff = sedControl.setupCCM_ab()
507 sedControl.addDust(a_coeff, b_coeff, A_v=iav)
509 sedControl.redshiftSED(zz, dimming=True)
510 sedControl.resampleSED(wavelen_match=wavelen_match)
512 a_coeff, b_coeff = sedControl.setupCCM_ab()
513 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
515 sedTest = testList[ix]
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)
521 for ix, (name, norm, iav, gav, zz) in \
522 enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
523 galacticAvList_1, redshiftList_1)):
525 sedControl = Sed()
526 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
528 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
529 sedControl.multiplyFluxNorm(fnorm)
531 if iav is not None:
532 a_coeff, b_coeff = sedControl.setupCCM_ab()
533 sedControl.addDust(a_coeff, b_coeff, A_v=iav)
535 if zz is not None:
536 sedControl.redshiftSED(zz, dimming=True)
538 sedControl.resampleSED(wavelen_match=wavelen_match)
540 if gav is not None:
541 a_coeff, b_coeff = sedControl.setupCCM_ab()
542 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
544 sedTest = testList[ix+nSed]
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)
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)
571 sedNameList_1 = self.getListOfSedNames(nSed)
572 magNormList_1 = self.rng.random_sample(nSed)*5.0 + 15.0
574 internalAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1
576 redshiftList_1 = self.rng.random_sample(nSed)*5.0
578 galacticAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1
580 testList.loadSedsFromList(sedNameList_1, magNormList_1,
581 internalAvList=internalAvList_1,
582 galacticAvList=galacticAvList_1,
583 redshiftList=redshiftList_1)
585 self.assertEqual(len(testList), 2*nSed)
586 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
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)
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)
598 for ix, (name, norm, iav, gav, zz) in \
599 enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
600 galacticAvList_0, redshiftList_0)):
602 sedControl = Sed()
603 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
605 fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
606 sedControl.multiplyFluxNorm(fnorm)
608 a_coeff, b_coeff = sedControl.setupCCM_ab()
609 sedControl.addDust(a_coeff, b_coeff, A_v=iav)
611 sedControl.redshiftSED(zz, dimming=True)
612 sedControl.resampleSED(wavelen_match=wavelen_match)
614 a_coeff, b_coeff = sedControl.setupCCM_ab()
615 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
617 sedTest = testList[ix]
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)
623 for ix, (name, norm, iav, gav, zz) in \
624 enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
625 galacticAvList_1, redshiftList_1)):
627 sedControl = Sed()
628 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
630 fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
631 sedControl.multiplyFluxNorm(fnorm)
633 a_coeff, b_coeff = sedControl.setupCCM_ab()
634 sedControl.addDust(a_coeff, b_coeff, A_v=iav)
636 sedControl.redshiftSED(zz, dimming=True)
638 sedControl.resampleSED(wavelen_match=wavelen_match)
640 a_coeff, b_coeff = sedControl.setupCCM_ab()
641 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
643 sedTest = testList[ix+nSed]
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)
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)
668 self.assertEqual(len(testList), nSed)
669 np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
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)
676 for ix, (name, norm, iav, gav, zz) in \
677 enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
678 galacticAvList_0, redshiftList_0)):
680 sedControl = Sed()
681 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
683 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
684 sedControl.multiplyFluxNorm(fnorm)
686 a_coeff, b_coeff = sedControl.setupCCM_ab()
687 sedControl.addDust(a_coeff, b_coeff, A_v=iav)
689 sedControl.redshiftSED(zz, dimming=True)
690 sedControl.resampleSED(wavelen_match=wavelen_match)
692 a_coeff, b_coeff = sedControl.setupCCM_ab()
693 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
695 sedTest = testList[ix]
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)
701 testList.flush()
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
709 testList.loadSedsFromList(sedNameList_1, magNormList_1,
710 internalAvList=internalAvList_1,
711 galacticAvList=galacticAvList_1,
712 redshiftList=redshiftList_1)
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)
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)
725 for ix, (name, norm, iav, gav, zz) in \
726 enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
727 galacticAvList_1, redshiftList_1)):
729 sedControl = Sed()
730 sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
732 fnorm = sedControl.calcFluxNorm(norm, imsimBand)
733 sedControl.multiplyFluxNorm(fnorm)
735 a_coeff, b_coeff = sedControl.setupCCM_ab()
736 sedControl.addDust(a_coeff, b_coeff, A_v=iav)
738 sedControl.redshiftSED(zz, dimming=True)
739 sedControl.resampleSED(wavelen_match=wavelen_match)
741 a_coeff, b_coeff = sedControl.setupCCM_ab()
742 sedControl.addDust(a_coeff, b_coeff, A_v=gav)
744 sedTest = testList[ix]
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)
751class MemoryTestClass(lsst.utils.tests.MemoryTestCase):
752 pass
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()