def _loadAgnSedList(self, wavelen_match):
"""
Load a SedList of galaxy AGN Seds.
The list will be stored in the variable self._bulgeSedList.
@param [in] wavelen_match is the wavelength grid (in nm)
on which the Seds are to be sampled.
"""
sedNameList = self.column_by_name('sedFilenameAgn')
magNormList = self.column_by_name('magNormAgn')
redshiftList = self.column_by_name('redshift')
cosmologicalDimming = not self._hasCosmoDistMod()
if len(sedNameList)==0:
return numpy.ones((0))
if not hasattr(self, '_agnSedList'):
self._agnSedList = SedList(sedNameList, magNormList,
redshiftList=redshiftList,
cosmologicalDimming=cosmologicalDimming,
wavelenMatch=wavelen_match)
else:
self._agnSedList.flush()
self._agnSedList.loadSedsFromList(sedNameList, magNormList,
redshiftList=redshiftList)
def testFluxListForSedList(self):
"""
Test that fluxListForSedList calculates the correct fluxes
"""
nBandpasses = 7
bpNameList, bpList = self.getListOfBandpasses(nBandpasses)
testBpDict = BandpassDict(bpList, bpNameList)
nSed = 20
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList = self.rng.random_sample(nSed)*5.0
galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1
# first, test on an SedList without a wavelenMatch
testSedList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList)
fluxList = testBpDict.fluxListForSedList(testSedList)
self.assertEqual(fluxList.shape[0], nSed)
self.assertEqual(fluxList.shape[1], nBandpasses)
for ix, sedObj in enumerate(testSedList):
dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen),
flambda=copy.deepcopy(sedObj.flambda))
for iy, bp in enumerate(testBpDict):
flux = dummySed.calcFlux(bpList[iy])
self.assertAlmostEqual(flux/fluxList[ix][iy], 1.0, 2)
# now use wavelenMatch
testSedList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList,
wavelenMatch=testBpDict.wavelenMatch)
fluxList = testBpDict.fluxListForSedList(testSedList)
self.assertEqual(fluxList.shape[0], nSed)
self.assertEqual(fluxList.shape[1], nBandpasses)
for ix, sedObj in enumerate(testSedList):
dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen),
flambda=copy.deepcopy(sedObj.flambda))
for iy, bp in enumerate(testBpDict):
flux = dummySed.calcFlux(bpList[iy])
self.assertAlmostEqual(flux/fluxList[ix][iy], 1.0, 2)
def testMagArrayForSedList(self):
"""
Test that magArrayForSedList calculates the correct magnitude
"""
nBandpasses = 7
bpNameList, bpList = self.getListOfBandpasses(nBandpasses)
testBpDict = BandpassDict(bpList, bpNameList)
nSed = 20
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList = self.rng.random_sample(nSed)*5.0
galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1
# first, test on an SedList without a wavelenMatch
testSedList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList)
magArray = testBpDict.magArrayForSedList(testSedList)
for ix, sedObj in enumerate(testSedList):
dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen),
flambda=copy.deepcopy(sedObj.flambda))
for iy, bp in enumerate(bpNameList):
mag = dummySed.calcMag(bpList[iy])
self.assertAlmostEqual(mag, magArray[bp][ix], 2)
# now use wavelenMatch
testSedList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList,
wavelenMatch=testBpDict.wavelenMatch)
magArray = testBpDict.magArrayForSedList(testSedList)
for ix, sedObj in enumerate(testSedList):
dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen),
flambda=copy.deepcopy(sedObj.flambda))
for iy, bp in enumerate(bpNameList):
mag = dummySed.calcMag(bpList[iy])
self.assertAlmostEqual(mag, magArray[bp][ix], 2)
def testLSSTmags(self):
"""
Test that PhotometrySSM properly calculates LSST magnitudes
"""
cat = LSST_SSM_photCat(self.photDB)
dtype = np.dtype([('id', np.int), ('u', np.float), ('g', np.float),
('r', np.float), ('i', np.float), ('z', np.float),
('y', np.float)])
with lsst.utils.tests.getTempFilePath('.txt') as catName:
cat.write_catalog(catName)
testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
self.assertGreater(len(testData), 0)
controlData = np.genfromtxt(self.dbFile, dtype=self.dtype)
self.assertGreater(len(controlData), 0)
LSSTbandpasses = BandpassDict.loadTotalBandpassesFromFiles()
controlSedList = SedList(controlData['sedFilename'],
controlData['magNorm'],
wavelenMatch=LSSTbandpasses.wavelenMatch,
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
controlMags = LSSTbandpasses.magListForSedList(controlSedList)
for ii in range(len(controlMags)):
for jj, bpName in enumerate(['u', 'g', 'r', 'i', 'z', 'y']):
self.assertAlmostEqual(controlMags[ii][jj],
testData[bpName][ii], 10)
def _loadAgnSedList(self, wavelen_match):
"""
Load a SedList of galaxy AGN Seds.
The list will be stored in the variable self._bulgeSedList.
@param [in] wavelen_match is the wavelength grid (in nm)
on which the Seds are to be sampled.
"""
sedNameList = self.column_by_name('sedFilenameAgn')
magNormList = self.column_by_name('magNormAgn')
redshiftList = self.column_by_name('redshift')
cosmologicalDimming = not self._hasCosmoDistMod()
if len(sedNameList)==0:
return np.ones((0))
if not hasattr(self, '_agnSedList'):
self._agnSedList = SedList(sedNameList, magNormList,
redshiftList=redshiftList,
cosmologicalDimming=cosmologicalDimming,
wavelenMatch=wavelen_match,
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
else:
self._agnSedList.flush()
self._agnSedList.loadSedsFromList(sedNameList, magNormList,
redshiftList=redshiftList)
def _loadSedList(self, wavelen_match):
"""
Method to load the member variable self._sedList, which is a SedList.
If self._sedList does not already exist, this method sets it up.
If it does already exist, this method flushes its contents and loads a new
chunk of Seds.
"""
sedNameList = self.column_by_name('sedFilename')
magNormList = self.column_by_name('magNorm')
galacticAvList = self.column_by_name('galacticAv')
if len(sedNameList)==0:
return np.ones((0))
if not hasattr(self, '_sedList'):
self._sedList = SedList(sedNameList, magNormList,
galacticAvList=galacticAvList,
wavelenMatch=wavelen_match,
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
else:
self._sedList.flush()
self._sedList.loadSedsFromList(sedNameList, magNormList,
galacticAvList=galacticAvList)
def testLSSTmags(self):
"""
Test that PhotometrySSM properly calculates LSST magnitudes
"""
catName = os.path.join(getPackageDir('sims_catUtils'), 'tests',
'scratchSpace', 'lsstSsmPhotCat.txt')
cat = LSST_SSM_photCat(self.photDB)
cat.write_catalog(catName)
dtype = np.dtype([('id', np.int), ('u', np.float), ('g', np.float),
('r', np.float), ('i', np.float), ('z', np.float),
('y', np.float)])
testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
self.assertGreater(len(testData), 0)
controlData = np.genfromtxt(self.dbFile, dtype=self.dtype)
self.assertGreater(len(controlData), 0)
LSSTbandpasses = BandpassDict.loadTotalBandpassesFromFiles()
controlSedList = SedList(controlData['sedFilename'],
controlData['magNorm'],
wavelenMatch=LSSTbandpasses.wavelenMatch)
controlMags = LSSTbandpasses.magListForSedList(controlSedList)
for ii in range(len(controlMags)):
for jj, bpName in enumerate(['u', 'g', 'r', 'i', 'z', 'y']):
self.assertAlmostEqual(controlMags[ii][jj],
testData[bpName][ii], 10)
if os.path.exists(catName):
os.unlink(catName)
def testManyMagSystems(self):
"""
Test that the SSM photometry mixin can simultaneously calculate magnitudes
in multiple bandpass systems
"""
catName = os.path.join(getPackageDir('sims_catUtils'), 'tests',
'scratchSpace', 'compoundSsmPhotCat.txt')
cat = Compound_SSM_photCat(self.photDB)
cat.write_catalog(catName)
dtype = np.dtype([('id', np.int), ('lsst_u', np.float),
('lsst_g', np.float), ('lsst_r', np.float),
('lsst_i', np.float), ('lsst_z', np.float),
('lsst_y', np.float), ('cartoon_u', np.float),
('cartoon_g', np.float), ('cartoon_r', np.float),
('cartoon_i', np.float), ('cartoon_z', np.float)])
testData = np.genfromtxt(catName, dtype=dtype, delimiter=',')
self.assertGreater(len(testData), 0)
controlData = np.genfromtxt(self.dbFile, dtype=self.dtype)
self.assertGreater(len(controlData), 0)
LSSTbandpasses = BandpassDict.loadTotalBandpassesFromFiles()
bandpassDir = os.path.join(getPackageDir('sims_photUtils'), 'tests',
'cartoonSedTestData')
cartoonBandpasses = BandpassDict.loadTotalBandpassesFromFiles(
['u', 'g', 'r', 'i', 'z'],
bandpassDir=bandpassDir,
bandpassRoot='test_bandpass_')
controlSedList = SedList(controlData['sedFilename'],
controlData['magNorm'],
wavelenMatch=LSSTbandpasses.wavelenMatch)
controlLsstMags = LSSTbandpasses.magListForSedList(controlSedList)
controlCartoonMags = cartoonBandpasses.magListForSedList(
controlSedList)
for ii in range(len(controlLsstMags)):
for jj, bpName in enumerate(
['lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y']):
self.assertAlmostEqual(controlLsstMags[ii][jj],
testData[bpName][ii], 10)
for jj, bpName in enumerate([
'cartoon_u', 'cartoon_g', 'cartoon_r', 'cartoon_i',
'cartoon_z'
]):
self.assertAlmostEqual(controlCartoonMags[ii][jj],
testData[bpName][ii], 10)
if os.path.exists(catName):
os.unlink(catName)
def get_magnitudes(self):
"""
Example photometry getter for alternative (i.e. non-LSST) bandpasses
"""
idNames = self.column_by_name('id')
columnNames = [name for name in self.get_magnitudes._colnames]
bandpassNames = ['u', 'g', 'r', 'i', 'z']
bandpassDir = os.path.join(getPackageDir('sims_photUtils'), 'tests',
'cartoonSedTestData')
if not hasattr(self, 'cartoonBandpassDict'):
self.cartoonBandpassDict = BandpassDict.loadTotalBandpassesFromFiles(
bandpassNames,
bandpassDir=bandpassDir,
bandpassRoot='test_bandpass_')
output = self._quiescentMagnitudeGetter(self.cartoonBandpassDict,
self.get_magnitudes._colnames)
#############################################################################
#Everything below this comment exists solely for the purposes of the unit test
#if you need to write a customized getter for photometry that uses non-LSST
#bandpasses, you only need to emulate the code above this comment.
magNormList = self.column_by_name('magNorm')
sedNames = self.column_by_name('sedFilename')
av = self.column_by_name('galacticAv')
#the two variables below will allow us to get at the SED and magnitude
#data from within the unit test class, so that we can be sure
#that the mixin loaded the correct bandpasses
sublist = SedList(sedNames,
magNormList,
galacticAvList=av,
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
for ss in sublist:
self.sedMasterList.append(ss)
if len(output) > 0:
for i in range(len(output[0])):
subList = []
for j in range(len(output)):
subList.append(output[j][i])
self.magnitudeMasterList.append(subList)
return output
def _loadSedList(self, wavelen_match):
"""
Method to load the member variable self._sedList, which is a SedList.
If self._sedList does not already exist, this method sets it up.
If it does already exist, this method flushes its contents and loads a new
chunk of Seds.
"""
sedNameList = self.column_by_name('sedFilename')
magNormList = self.column_by_name('magNorm')
galacticAvList = self.column_by_name('galacticAv')
if len(sedNameList)==0:
return numpy.ones((0))
if not hasattr(self, '_sedList'):
self._sedList = SedList(sedNameList, magNormList,
galacticAvList=galacticAvList,
wavelenMatch=wavelen_match)
else:
self._sedList.flush()
self._sedList.loadSedsFromList(sedNameList, magNormList,
galacticAvList=galacticAvList)
def testAddingToList(self):
"""
Test that we can add Seds to an already instantiated SedList
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = self.rng.random_sample(nSed)*5.0
galacticAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0,
fileDir=self.sedDir,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
# experiment with adding different combinations of physical parameter lists
# as None and not None
for addIav in [True, False]:
for addRedshift in [True, False]:
for addGav in [True, False]:
testList = SedList(sedNameList_0, magNormList_0,
fileDir=self.sedDir,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = self.rng.random_sample(nSed)*5.0 + 15.0
if addIav:
internalAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1
else:
internalAvList_1 = None
if addRedshift:
redshiftList_1 = self.rng.random_sample(nSed)*5.0
else:
redshiftList_1 = None
if addGav:
galacticAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1
else:
galacticAvList_1 = None
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2*nSed)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
if addIav:
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10)
else:
self.assertIsNone(testList.internalAvList[ix+nSed])
if addGav:
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
else:
self.assertIsNone(testList.galacticAvList[ix+nSed])
if addRedshift:
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
else:
self.assertIsNone(testList.redshiftList[ix+nSed])
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
if not addIav:
internalAvList_1 = [None] * nSed
if not addRedshift:
redshiftList_1 = [None] * nSed
if not addGav:
galacticAvList_1 = [None] * nSed
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
if addIav:
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=iav)
if addRedshift:
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
if addGav:
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix+nSed]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testExceptions(self):
"""
Test that exceptions are raised when they should be
"""
nSed = 10
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList = self.rng.random_sample(nSed)*5.0
galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList,
wavelenMatch=wavelen_match)
with self.assertRaises(AttributeError) as context:
testList.wavelenMatch = np.arange(10.0, 1000.0, 1000.0)
with self.assertRaises(AttributeError) as context:
testList.cosmologicalDimming = False
with self.assertRaises(AttributeError) as context:
testList.redshiftList = [1.8]
with self.assertRaises(AttributeError) as context:
testList.internalAvList = [2.5]
with self.assertRaises(AttributeError) as context:
testList.galacticAvList = [1.9]
testList = SedList(sedNameList, magNormList, fileDir=self.sedDir)
with self.assertRaises(RuntimeError) as context:
testList.loadSedsFromList(sedNameList, magNormList, internalAvList=internalAvList)
self.assertIn('does not contain internalAvList', context.exception.args[0])
with self.assertRaises(RuntimeError) as context:
testList.loadSedsFromList(sedNameList, magNormList, galacticAvList=galacticAvList)
self.assertIn('does not contain galacticAvList', context.exception.args[0])
with self.assertRaises(RuntimeError) as context:
testList.loadSedsFromList(sedNameList, magNormList, redshiftList=redshiftList)
self.assertIn('does not contain redshiftList', context.exception.args[0])
def testAddingNonesToList(self):
"""
Test what happens if you add SEDs to an SedList that have None for
one or more of the physical parameters (i.e. galacticAv, internalAv, or redshift)
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = numpy.random.random_sample(nSed)*5.0
galacticAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0, internalAvList=internalAvList_0, \
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = list(numpy.random.random_sample(nSed)*5.0 + 15.0)
internalAvList_1 = list(numpy.random.random_sample(nSed)*0.3 + 0.1)
redshiftList_1 = list(numpy.random.random_sample(nSed)*5.0)
galacticAvList_1 = list(numpy.random.random_sample(nSed)*0.3 + 0.1)
internalAvList_1[0] = None
redshiftList_1[1] = None
galacticAvList_1[2] = None
internalAvList_1[3] = None
redshiftList_1[3] = None
internalAvList_1[4] = None
galacticAvList_1[4] = None
redshiftList_1[5] = None
galacticAvList_1[5] = None
internalAvList_1[6] = None
redshiftList_1[6] = None
galacticAvList_1[6] = None
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2*nSed)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10)
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, \
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, \
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
if iav is not None:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
if zz is not None:
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
if gav is not None:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix+nSed]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
class PhotometryStars(PhotometryBase):
"""
This mixin provides the infrastructure for doing photometry on stars
It assumes that we want LSST filters.
"""
def _loadSedList(self, wavelen_match):
"""
Method to load the member variable self._sedList, which is a SedList.
If self._sedList does not already exist, this method sets it up.
If it does already exist, this method flushes its contents and loads a new
chunk of Seds.
"""
sedNameList = self.column_by_name('sedFilename')
magNormList = self.column_by_name('magNorm')
galacticAvList = self.column_by_name('galacticAv')
if len(sedNameList)==0:
return np.ones((0))
if not hasattr(self, '_sedList'):
self._sedList = SedList(sedNameList, magNormList,
galacticAvList=galacticAvList,
wavelenMatch=wavelen_match,
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
else:
self._sedList.flush()
self._sedList.loadSedsFromList(sedNameList, magNormList,
galacticAvList=galacticAvList)
def _quiescentMagnitudeGetter(self, bandpassDict, columnNameList):
"""
This method gets the magnitudes for an InstanceCatalog, returning them
in a 2-D numpy array in which rows correspond to bandpasses and columns
correspond to astronomical objects.
@param [in] bandpassDict is a BandpassDict containing the bandpasses
whose magnitudes are to be calculated
@param [in] columnNameList is a list of the names of the magnitude columns
being calculated
@param [out] magnitudes is a 2-D numpy array of magnitudes in which
rows correspond to bandpasses in bandpassDict and columns correspond
to astronomical objects.
"""
# figure out which of these columns we are actually calculating
indices = [ii for ii, name in enumerate(columnNameList)
if name in self._actually_calculated_columns]
if len(indices) == len(columnNameList):
indices = None
self._loadSedList(bandpassDict.wavelenMatch)
if not hasattr(self, '_sedList'):
magnitudes = np.ones((len(columnNameList),0))
else:
magnitudes = bandpassDict.magListForSedList(self._sedList, indices=indices).transpose()
return magnitudes
@compound('quiescent_lsst_u', 'quiescent_lsst_g', 'quiescent_lsst_r',
'quiescent_lsst_i', 'quiescent_lsst_z', 'quiescent_lsst_y')
def get_quiescent_lsst_magnitudes(self):
if not hasattr(self, 'lsstBandpassDict'):
self.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
return self._quiescentMagnitudeGetter(self.lsstBandpassDict,
self.get_quiescent_lsst_magnitudes._colnames)
@compound('lsst_u','lsst_g','lsst_r','lsst_i','lsst_z','lsst_y')
def get_lsst_magnitudes(self):
"""
getter for LSST stellar magnitudes
"""
magnitudes = np.array([self.column_by_name('quiescent_lsst_u'),
self.column_by_name('quiescent_lsst_g'),
self.column_by_name('quiescent_lsst_r'),
self.column_by_name('quiescent_lsst_i'),
self.column_by_name('quiescent_lsst_z'),
self.column_by_name('quiescent_lsst_y')])
delta = self._variabilityGetter(self.get_lsst_magnitudes._colnames)
magnitudes += delta
return magnitudes
def testAlternateNormalizingBandpass(self):
"""
A reiteration of testAddingToList, but testing with a non-imsimBandpass
normalizing bandpass
"""
normalizingBand = Bandpass()
normalizingBand.readThroughput(os.path.join(getPackageDir('throughputs'),'baseline','total_r.dat'))
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = numpy.random.random_sample(nSed)*5.0
galacticAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0,
normalizingBandpass=normalizingBand,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_1 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_1 = numpy.random.random_sample(nSed)*5.0
galacticAvList_1 = numpy.random.random_sample(nSed)*0.3 + 0.1
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2*nSed)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10)
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, \
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, \
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix+nSed]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
class PhotometryGalaxies(PhotometryBase):
"""
This mixin provides the code necessary for calculating the component magnitudes associated with
galaxies. It assumes that we want LSST filters.
"""
def _hasCosmoDistMod(self):
"""
Determine whether or not this InstanceCatalog has a column
specifically devoted to the cosmological distance modulus.
"""
if 'cosmologicalDistanceModulus' in self._all_available_columns:
return True
return False
def _loadBulgeSedList(self, wavelen_match):
"""
Load a SedList of galaxy bulge Seds.
The list will be stored in the variable self._bulgeSedList.
@param [in] wavelen_match is the wavelength grid (in nm)
on which the Seds are to be sampled.
"""
sedNameList = self.column_by_name('sedFilenameBulge')
magNormList = self.column_by_name('magNormBulge')
redshiftList = self.column_by_name('redshift')
internalAvList = self.column_by_name('internalAvBulge')
cosmologicalDimming = not self._hasCosmoDistMod()
if len(sedNameList)==0:
return numpy.ones((0))
if not hasattr(self, '_bulgeSedList'):
self._bulgeSedList = SedList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList,
cosmologicalDimming=cosmologicalDimming,
wavelenMatch=wavelen_match)
else:
self._bulgeSedList.flush()
self._bulgeSedList.loadSedsFromList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList)
def _loadDiskSedList(self, wavelen_match):
"""
Load a SedList of galaxy disk Seds.
The list will be stored in the variable self._bulgeSedList.
@param [in] wavelen_match is the wavelength grid (in nm)
on which the Seds are to be sampled.
"""
sedNameList = self.column_by_name('sedFilenameDisk')
magNormList = self.column_by_name('magNormDisk')
redshiftList = self.column_by_name('redshift')
internalAvList = self.column_by_name('internalAvDisk')
cosmologicalDimming = not self._hasCosmoDistMod()
if len(sedNameList)==0:
return numpy.ones((0))
if not hasattr(self, '_diskSedList'):
self._diskSedList = SedList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList,
cosmologicalDimming=cosmologicalDimming,
wavelenMatch=wavelen_match)
else:
self._diskSedList.flush()
self._diskSedList.loadSedsFromList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList)
def _loadAgnSedList(self, wavelen_match):
"""
Load a SedList of galaxy AGN Seds.
The list will be stored in the variable self._bulgeSedList.
@param [in] wavelen_match is the wavelength grid (in nm)
on which the Seds are to be sampled.
"""
sedNameList = self.column_by_name('sedFilenameAgn')
magNormList = self.column_by_name('magNormAgn')
redshiftList = self.column_by_name('redshift')
cosmologicalDimming = not self._hasCosmoDistMod()
if len(sedNameList)==0:
return numpy.ones((0))
if not hasattr(self, '_agnSedList'):
self._agnSedList = SedList(sedNameList, magNormList,
redshiftList=redshiftList,
cosmologicalDimming=cosmologicalDimming,
wavelenMatch=wavelen_match)
else:
self._agnSedList.flush()
self._agnSedList.loadSedsFromList(sedNameList, magNormList,
redshiftList=redshiftList)
def sum_magnitudes(self, disk = None, bulge = None, agn = None):
"""
Sum the component magnitudes of a galaxy and return the answer
@param [in] disk is the disk magnitude must be a numpy array or a float
@param [in] bulge is the bulge magnitude must be a numpy array or a float
@param [in] agn is the agn magnitude must be a numpy array or a float
@param [out] outMag is the total magnitude of the galaxy
"""
baselineType = type(None)
if not isinstance(disk, type(None)):
baselineType = type(disk)
if baselineType == numpy.ndarray:
elements=len(disk)
if not isinstance(bulge, type(None)):
if baselineType == type(None):
baselineType = type(bulge)
if baselineType == numpy.ndarray:
elements = len(bulge)
elif not isinstance(bulge, baselineType):
raise RuntimeError("All non-None arguments of sum_magnitudes need to be " +
"of the same type (float or numpy array)")
elif not isinstance(agn, type(None)):
if baseLineType == type(None):
baselineType = type(agn)
if baselineType == numpy.ndarray:
elements = len(agn)
elif not isinstance(agn, baselineType):
raise RuntimeError("All non-None arguments of sum_magnitudes need to be " +
"of the same type (float or numpy array)")
if baselineType is not float and \
baselineType is not numpy.ndarray and \
baselineType is not numpy.float and \
baselineType is not numpy.float64:
raise RuntimeError("Arguments of sum_magnitudes need to be " +
"either floats or numpy arrays; you appear to have passed %s " % baselineType)
mm_0 = 22.
tol = 1.0e-30
if baselineType == numpy.ndarray:
nn = numpy.zeros(elements)
else:
nn = 0.0
if disk is not None:
nn += numpy.where(numpy.isnan(disk), 0.0, numpy.power(10, -0.4*(disk - mm_0)))
if bulge is not None:
nn += numpy.where(numpy.isnan(bulge), 0.0, numpy.power(10, -0.4*(bulge - mm_0)))
if agn is not None:
nn += numpy.where(numpy.isnan(agn), 0.0, numpy.power(10, -0.4*(agn - mm_0)))
if baselineType == numpy.ndarray:
# according to this link
# http://stackoverflow.com/questions/25087769/runtimewarning-divide-by-zero-error-how-to-avoid-python-numpy
# we will still get a divide by zero error from log10, but numpy.where will be
# circumventing the offending value, so it is probably okay
return numpy.where(nn>tol, -2.5*numpy.log10(nn) + mm_0, numpy.NaN)
else:
if nn>tol:
return -2.5*numpy.log10(nn) + mm_0
else:
return numpy.NaN
def _quiescentMagnitudeGetter(self, componentName, bandpassDict, columnNameList):
"""
A generic getter for quiescent magnitudes of galaxy components.
@param [in] componentName is either 'bulge', 'disk', or 'agn'
@param [in] bandpassDict is a BandpassDict of the bandpasses
in which to calculate the magnitudes
@param [in] columnNameList is a list of the columns corresponding to
these magnitudes (for purposes of applying variability).
@param [out] magnitudes is a 2-D numpy array of magnitudes in which
rows correspond to bandpasses and columns correspond to astronomical
objects.
"""
# figure out which of these columns we are actually calculating
indices = [ii for ii, name in enumerate(columnNameList)
if name in self._actually_calculated_columns]
if len(indices) == len(columnNameList):
indices = None
if componentName == 'bulge':
self._loadBulgeSedList(bandpassDict.wavelenMatch)
if not hasattr(self, '_bulgeSedList'):
sedList = None
else:
sedList = self._bulgeSedList
elif componentName == 'disk':
self._loadDiskSedList(bandpassDict.wavelenMatch)
if not hasattr(self, '_diskSedList'):
sedList = None
else:
sedList = self._diskSedList
elif componentName == 'agn':
self._loadAgnSedList(bandpassDict.wavelenMatch)
if not hasattr(self, '_agnSedList'):
sedList = None
else:
sedList = self._agnSedList
else:
raise RuntimeError('_quiescentMagnitudeGetter does not understand component %s ' \
% componentName)
if sedList is None:
magnitudes = numpy.ones((len(columnNameList), 0))
else:
magnitudes = bandpassDict.magListForSedList(sedList, indices=indices).transpose()
if self._hasCosmoDistMod():
cosmoDistMod = self.column_by_name('cosmologicalDistanceModulus')
if len(cosmoDistMod)>0:
for ix in range(magnitudes.shape[0]):
magnitudes[ix] += cosmoDistMod
return magnitudes
@compound('sigma_uBulge', 'sigma_gBulge', 'sigma_rBulge',
'sigma_iBulge', 'sigma_zBulge', 'sigma_yBulge')
def get_photometric_uncertainties_bulge(self):
"""
Getter for photometric uncertainties associated with galaxy bulges
"""
return self._magnitudeUncertaintyGetter(['uBulge', 'gBulge', 'rBulge',
'iBulge', 'zBulge', 'yBulge'],
['u', 'g', 'r', 'i', 'z', 'y'],
'lsstBandpassDict')
@compound('sigma_uDisk', 'sigma_gDisk', 'sigma_rDisk',
'sigma_iDisk', 'sigma_zDisk', 'sigma_yDisk')
def get_photometric_uncertainties_disk(self):
"""
Getter for photometeric uncertainties associated with galaxy disks
"""
return self._magnitudeUncertaintyGetter(['uDisk', 'gDisk', 'rDisk',
'iDisk', 'zDisk', 'yDisk'],
['u', 'g', 'r', 'i', 'z', 'y'],
'lsstBandpassDict')
@compound('sigma_uAgn', 'sigma_gAgn', 'sigma_rAgn',
'sigma_iAgn', 'sigma_zAgn', 'sigma_yAgn')
def get_photometric_uncertainties_agn(self):
"""
Getter for photometric uncertainties associated with Agn
"""
return self._magnitudeUncertaintyGetter(['uAgn', 'gAgn', 'rAgn',
'iAgn', 'zAgn', 'yAgn'],
['u', 'g', 'r', 'i', 'z', 'y'],
'lsstBandpassDict')
@compound('uBulge', 'gBulge', 'rBulge', 'iBulge', 'zBulge', 'yBulge')
def get_lsst_bulge_mags(self):
"""
Getter for bulge magnitudes in LSST bandpasses
"""
# load a BandpassDict of LSST bandpasses, if not done already
if not hasattr(self, 'lsstBandpassDict'):
self.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
# actually calculate the magnitudes
mag = self._quiescentMagnitudeGetter('bulge', self.lsstBandpassDict,
self.get_lsst_bulge_mags._colnames)
mag += self._variabilityGetter(self.get_lsst_bulge_mags._colnames)
return mag
@compound('uDisk', 'gDisk', 'rDisk', 'iDisk', 'zDisk', 'yDisk')
def get_lsst_disk_mags(self):
"""
Getter for galaxy disk magnitudes in the LSST bandpasses
"""
# load a BandpassDict of LSST bandpasses, if not done already
if not hasattr(self, 'lsstBandpassDict'):
self.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
# actually calculate the magnitudes
mag = self._quiescentMagnitudeGetter('disk', self.lsstBandpassDict,
self.get_lsst_disk_mags._colnames)
mag += self._variabilityGetter(self.get_lsst_disk_mags._colnames)
return mag
@compound('uAgn', 'gAgn', 'rAgn', 'iAgn', 'zAgn', 'yAgn')
def get_lsst_agn_mags(self):
"""
Getter for AGN magnitudes in the LSST bandpasses
"""
# load a BandpassDict of LSST bandpasses, if not done already
if not hasattr(self, 'lsstBandpassDict'):
self.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
# actually calculate the magnitudes
mag = self._quiescentMagnitudeGetter('agn', self.lsstBandpassDict,
self.get_lsst_agn_mags._colnames)
mag += self._variabilityGetter(self.get_lsst_agn_mags._colnames)
return mag
@compound('lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y')
def get_lsst_total_mags(self):
"""
Getter for total galaxy magnitudes in the LSST bandpasses
"""
idList = self.column_by_name('uniqueId')
numObj = len(idList)
output = []
# Loop over the columns calculated by this getter. For each
# column, calculate the bluge, disk, and agn magnitude in the
# corresponding bandpass, then sum them using the
# sum_magnitudes method.
for columnName in self.get_lsst_total_mags._colnames:
if columnName not in self._actually_calculated_columns:
sub_list = [numpy.NaN]*numObj
else:
bandpass = columnName[-1]
bulge = self.column_by_name('%sBulge' % bandpass)
disk = self.column_by_name('%sDisk' % bandpass)
agn = self.column_by_name('%sAgn' % bandpass)
sub_list = self.sum_magnitudes(bulge=bulge, disk=disk, agn=agn)
output.append(sub_list)
return numpy.array(output)
def testFlush(self):
"""
Test that the flush method of SedList behaves properly
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = numpy.random.random_sample(nSed)*5.0
galacticAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0, internalAvList=internalAvList_0, \
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
self.assertEqual(len(testList), nSed)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, \
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
testList.flush()
sedNameList_1 = self.getListOfSedNames(nSed/2)
magNormList_1 = numpy.random.random_sample(nSed/2)*5.0 + 15.0
internalAvList_1 = numpy.random.random_sample(nSed/2)*0.3 + 0.1
redshiftList_1 = numpy.random.random_sample(nSed/2)*5.0
galacticAvList_1 = numpy.random.random_sample(nSed/2)*0.3 + 0.1
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), nSed/2)
self.assertEqual(len(testList.redshiftList), nSed/2)
self.assertEqual(len(testList.internalAvList), nSed/2)
self.assertEqual(len(testList.galacticAvList), nSed/2)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, \
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def test_flare_magnitudes_mixed_with_none(self):
"""
Test that we get the expected magnitudes out
"""
db = MLT_test_DB(database=self.db_name, driver='sqlite')
# load the quiescent SEDs of the objects in our catalog
sed_list = SedList(['lte028-5.0+0.5a+0.0.BT-Settl.spec.gz']*4,
[17.1, 17.2, 17.3, 17.4],
galacticAvList = [2.432, 1.876, 2.654, 2.364],
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
bp_dict = BandpassDict.loadTotalBandpassesFromFiles()
# calculate the quiescent fluxes of the objects in our catalog
baseline_fluxes = bp_dict.fluxListForSedList(sed_list)
bb_wavelen = np.arange(100.0, 1600.0, 0.1)
bb = models.BlackBody(temperature=9000.0 * u.K, scale=1.0 * u.erg / (u.cm ** 2 * u.AA * u.s * u.sr))
bb_flambda = bb(bb_wavelen * u.nm).to_value()
# this data is taken from the setUpClass() classmethod above
t0_list = [456.2, 41006.2, 117.2, 10456.2]
av_list = [2.432, 1.876, 2.654, 2.364]
parallax_list = np.array([0.25, 0.15, 0.3, 0.22])
distance_list = 1.0/(206265.0*radiansFromArcsec(0.001*parallax_list))
distance_list *= 3.0857e18 # convert to cm
dtype = np.dtype([('id', int), ('u', float), ('g', float)])
photParams = PhotometricParameters()
ss = Sed()
quiet_cat_name = os.path.join(self.scratch_dir, 'mlt_mixed_with_none_quiet_cat.txt')
flare_cat_name = os.path.join(self.scratch_dir, 'mlt_mixed_with_none_flaring_cat.txt')
# loop over several MJDs and verify that, to within a
# milli-mag, our flaring model gives us the magnitudes
# expected, given the light curves specified in
# setUpClass()
for mjd in (59580.0, 60000.0, 70000.0, 80000.0):
obs = ObservationMetaData(mjd=mjd)
quiet_cat = QuiescentCatalog(db, obs_metadata=obs)
quiet_cat.write_catalog(quiet_cat_name)
flare_cat = FlaringCatalog(db, obs_metadata=obs)
flare_cat._mlt_lc_file = self.mlt_lc_name
flare_cat.write_catalog(flare_cat_name)
quiescent_data = np.genfromtxt(quiet_cat_name, dtype=dtype, delimiter=',')
flaring_data = np.genfromtxt(flare_cat_name, dtype=dtype, delimiter=',')
self.assertGreater(len(flaring_data), 3)
for ix in range(len(flaring_data)):
obj_id = flaring_data['id'][ix]
self.assertEqual(obj_id, ix)
# the models below are as specified in the
# setUpClass() method
if obj_id == 0 or obj_id == 1:
amp = 1.0e42
dt = 3652.5
t_min = flare_cat._survey_start - t0_list[obj_id]
tt = mjd - t_min
while tt > dt:
tt -= dt
u_flux = amp*(1.0+np.power(np.sin(tt/100.0), 2))
g_flux = amp*(1.0+np.power(np.cos(tt/100.0), 2))
elif obj_id==2:
amp = 2.0e41
dt = 365.25
t_min = flare_cat._survey_start - t0_list[obj_id]
tt = mjd - t_min
while tt > dt:
tt -= dt
u_flux = amp*(1.0+np.power(np.sin(tt/50.0), 2))
g_flux = amp*(1.0+np.power(np.cos(tt/50.0), 2))
else:
u_flux = 0.0
g_flux = 0.0
# calculate the multiplicative effect of dust on a 9000K
# black body
bb_sed = Sed(wavelen=bb_wavelen, flambda=bb_flambda)
u_bb_flux = bb_sed.calcFlux(bp_dict['u'])
g_bb_flux = bb_sed.calcFlux(bp_dict['g'])
a_x, b_x = bb_sed.setupCCM_ab()
bb_sed.addDust(a_x, b_x, A_v=av_list[obj_id])
u_bb_dusty_flux = bb_sed.calcFlux(bp_dict['u'])
g_bb_dusty_flux = bb_sed.calcFlux(bp_dict['g'])
dust_u = u_bb_dusty_flux/u_bb_flux
dust_g = g_bb_dusty_flux/g_bb_flux
area = 4.0*np.pi*np.power(distance_list[obj_id], 2)
tot_u_flux = baseline_fluxes[obj_id][0] + u_flux*dust_u/area
tot_g_flux = baseline_fluxes[obj_id][1] + g_flux*dust_g/area
msg = ('failed on object %d; mjd %.2f\n u_quiet %e u_flare %e\n g_quiet %e g_flare %e' %
(obj_id, mjd, quiescent_data['u'][obj_id], flaring_data['u'][obj_id],
quiescent_data['g'][obj_id], flaring_data['g'][obj_id]))
self.assertEqual(quiescent_data['id'][obj_id], flaring_data['id'][obj_id], msg=msg)
self.assertAlmostEqual(ss.magFromFlux(baseline_fluxes[obj_id][0]),
quiescent_data['u'][obj_id], 3, msg=msg)
self.assertAlmostEqual(ss.magFromFlux(baseline_fluxes[obj_id][1]),
quiescent_data['g'][obj_id], 3, msg=msg)
self.assertAlmostEqual(ss.magFromFlux(tot_u_flux), flaring_data['u'][obj_id],
3, msg=msg)
self.assertAlmostEqual(ss.magFromFlux(tot_g_flux), flaring_data['g'][obj_id],
3, msg=msg)
if obj_id != 3:
self.assertGreater(np.abs(flaring_data['g'][obj_id]-quiescent_data['g'][obj_id]),
0.001, msg=msg)
self.assertGreater(np.abs(flaring_data['u'][obj_id]-quiescent_data['u'][obj_id]),
0.001, msg=msg)
else:
self.assertEqual(flaring_data['g'][obj_id]-quiescent_data['g'][obj_id], 0.0, msg=msg)
self.assertEqual(flaring_data['u'][obj_id]-quiescent_data['u'][obj_id], 0.0, msg=msg)
if os.path.exists(quiet_cat_name):
os.unlink(quiet_cat_name)
if os.path.exists(flare_cat_name):
os.unlink(flare_cat_name)
def testAddingToList(self):
"""
Test that we can add Seds to an already instantiated SedList
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = numpy.random.random_sample(nSed)*5.0
galacticAvList_0 = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0, internalAvList=internalAvList_0, \
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
# experiment with adding different combinations of physical parameter lists
# as None and not None
for addIav in [True, False]:
for addRedshift in [True, False]:
for addGav in [True, False]:
testList = SedList(sedNameList_0, magNormList_0, internalAvList=internalAvList_0, \
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = numpy.random.random_sample(nSed)*5.0 + 15.0
if addIav:
internalAvList_1 = numpy.random.random_sample(nSed)*0.3 + 0.1
else:
internalAvList_1 = None
if addRedshift:
redshiftList_1 = numpy.random.random_sample(nSed)*5.0
else:
redshiftList_1 = None
if addGav:
galacticAvList_1 = numpy.random.random_sample(nSed)*0.3 + 0.1
else:
galacticAvList_1 = None
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2*nSed)
numpy.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
if addIav:
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10)
else:
self.assertTrue(testList.internalAvList[ix+nSed] is None)
if addGav:
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
else:
self.assertTrue(testList.galacticAvList[ix+nSed] is None)
if addRedshift:
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
else:
self.assertTrue(testList.redshiftList[ix+nSed] is None)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0, \
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
if not addIav:
internalAvList_1 = [None] * nSed
if not addRedshift:
redshiftList_1 = [None] * nSed
if not addGav:
galacticAvList_1 = [None] * nSed
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1, \
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
if addIav:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=iav)
if addRedshift:
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
if addGav:
a_coeff, b_coeff = sedControl.setupCCMab()
sedControl.addCCMDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix+nSed]
numpy.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
numpy.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
numpy.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testFlush(self):
"""
Test that the flush method of SedList behaves properly
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = self.rng.random_sample(nSed)*5.0
galacticAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0,
fileDir=self.sedDir,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
self.assertEqual(len(testList), nSed)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
testList.flush()
sedNameList_1 = self.getListOfSedNames(nSed//2)
magNormList_1 = self.rng.random_sample(nSed//2)*5.0 + 15.0
internalAvList_1 = self.rng.random_sample(nSed//2)*0.3 + 0.1
redshiftList_1 = self.rng.random_sample(nSed//2)*5.0
galacticAvList_1 = self.rng.random_sample(nSed//2)*0.3 + 0.1
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), nSed/2)
self.assertEqual(len(testList.redshiftList), nSed/2)
self.assertEqual(len(testList.internalAvList), nSed/2)
self.assertEqual(len(testList.galacticAvList), nSed/2)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
class PhotometryStars(PhotometryBase):
"""
This mixin provides the infrastructure for doing photometry on stars
It assumes that we want LSST filters.
"""
def _loadSedList(self, wavelen_match):
"""
Method to load the member variable self._sedList, which is a SedList.
If self._sedList does not already exist, this method sets it up.
If it does already exist, this method flushes its contents and loads a new
chunk of Seds.
"""
sedNameList = self.column_by_name('sedFilename')
magNormList = self.column_by_name('magNorm')
galacticAvList = self.column_by_name('galacticAv')
if len(sedNameList)==0:
return numpy.ones((0))
if not hasattr(self, '_sedList'):
self._sedList = SedList(sedNameList, magNormList,
galacticAvList=galacticAvList,
wavelenMatch=wavelen_match)
else:
self._sedList.flush()
self._sedList.loadSedsFromList(sedNameList, magNormList,
galacticAvList=galacticAvList)
def _quiescentMagnitudeGetter(self, bandpassDict, columnNameList):
"""
This method gets the magnitudes for an InstanceCatalog, returning them
in a 2-D numpy array in which rows correspond to bandpasses and columns
correspond to astronomical objects.
@param [in] bandpassDict is a BandpassDict containing the bandpasses
whose magnitudes are to be calculated
@param [in] columnNameList is a list of the names of the magnitude columns
being calculated
@param [out] magnitudes is a 2-D numpy array of magnitudes in which
rows correspond to bandpasses in bandpassDict and columns correspond
to astronomical objects.
"""
# figure out which of these columns we are actually calculating
indices = [ii for ii, name in enumerate(columnNameList)
if name in self._actually_calculated_columns]
if len(indices) == len(columnNameList):
indices = None
self._loadSedList(bandpassDict.wavelenMatch)
if not hasattr(self, '_sedList'):
magnitudes = numpy.ones((len(columnNameList),0))
else:
magnitudes = bandpassDict.magListForSedList(self._sedList, indices=indices).transpose()
return magnitudes
@compound('quiescent_lsst_u', 'quiescent_lsst_g', 'quiescent_lsst_r',
'quiescent_lsst_i', 'quiescent_lsst_z', 'quiescent_lsst_y')
def get_quiescent_lsst_magnitudes(self):
if not hasattr(self, 'lsstBandpassDict'):
self.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
return self._quiescentMagnitudeGetter(self.lsstBandpassDict,
self.get_quiescent_lsst_magnitudes._colnames)
@compound('lsst_u','lsst_g','lsst_r','lsst_i','lsst_z','lsst_y')
def get_lsst_magnitudes(self):
"""
getter for LSST stellar magnitudes
"""
magnitudes = numpy.array([self.column_by_name('quiescent_lsst_u'),
self.column_by_name('quiescent_lsst_g'),
self.column_by_name('quiescent_lsst_r'),
self.column_by_name('quiescent_lsst_i'),
self.column_by_name('quiescent_lsst_z'),
self.column_by_name('quiescent_lsst_y')])
delta = self._variabilityGetter(self.get_lsst_magnitudes._colnames)
magnitudes += delta
return magnitudes
def testIndicesOnMagnitudes(self):
"""
Test that, when you pass a list of indices into the calcMagList
methods, you get the correct magnitudes out.
"""
nBandpasses = 7
nameList, bpList = self.getListOfBandpasses(nBandpasses)
testBpDict = BandpassDict(bpList, nameList)
# first try it with a single Sed
wavelen = np.arange(10.0, 2000.0, 1.0)
flux = (wavelen*2.0-5.0)*1.0e-6
spectrum = Sed(wavelen=wavelen, flambda=flux)
indices = [1, 2, 5]
magList = testBpDict.magListForSed(spectrum, indices=indices)
ctNaN = 0
for ix, (name, bp, magTest) in enumerate(zip(nameList,
bpList,
magList)):
if ix in indices:
magControl = spectrum.calcMag(bp)
self.assertAlmostEqual(magTest, magControl, 5)
else:
ctNaN += 1
np.testing.assert_equal(magTest, np.NaN)
self.assertEqual(ctNaN, 4)
nSed = 20
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList = self.rng.random_sample(nSed)*5.0
galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1
# now try a SedList without a wavelenMatch
testSedList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList)
magList = testBpDict.magListForSedList(testSedList, indices=indices)
magArray = testBpDict.magArrayForSedList(testSedList, indices=indices)
self.assertEqual(magList.shape[0], nSed)
self.assertEqual(magList.shape[1], nBandpasses)
self.assertEqual(magArray.shape[0], nSed)
for bpname in testBpDict:
self.assertEqual(len(magArray[bpname]), nSed)
for ix, sedObj in enumerate(testSedList):
dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen),
flambda=copy.deepcopy(sedObj.flambda))
ctNaN = 0
for iy, bp in enumerate(testBpDict):
if iy in indices:
mag = dummySed.calcMag(testBpDict[bp])
self.assertAlmostEqual(mag, magList[ix][iy], 2)
self.assertAlmostEqual(mag, magArray[ix][iy], 2)
self.assertAlmostEqual(mag, magArray[bp][ix], 2)
else:
ctNaN += 1
np.testing.assert_equal(magList[ix][iy], np.NaN)
np.testing.assert_equal(magArray[ix][iy], np.NaN)
np.testing.assert_equal(magArray[bp][ix], np.NaN)
self.assertEqual(ctNaN, 4)
# now use wavelenMatch
testSedList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList,
wavelenMatch=testBpDict.wavelenMatch)
magList = testBpDict.magListForSedList(testSedList, indices=indices)
magArray = testBpDict.magArrayForSedList(testSedList, indices=indices)
self.assertEqual(magList.shape[0], nSed)
self.assertEqual(magList.shape[1], nBandpasses)
self.assertEqual(magArray.shape[0], nSed)
for bpname in testBpDict:
self.assertEqual(len(magArray[bpname]), nSed)
for ix, sedObj in enumerate(testSedList):
dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen),
flambda=copy.deepcopy(sedObj.flambda))
ctNaN = 0
for iy, bp in enumerate(testBpDict):
if iy in indices:
mag = dummySed.calcMag(testBpDict[bp])
self.assertAlmostEqual(mag, magList[ix][iy], 2)
self.assertAlmostEqual(mag, magArray[ix][iy], 2)
self.assertAlmostEqual(mag, magArray[bp][ix], 2)
else:
ctNaN += 1
np.testing.assert_equal(magList[ix][iy], np.NaN)
np.testing.assert_equal(magArray[ix][iy], np.NaN)
np.testing.assert_equal(magArray[bp][ix], np.NaN)
self.assertEqual(ctNaN, 4)
def testAddingNonesToList(self):
"""
Test what happens if you add SEDs to an SedList that have None for
one or more of the physical parameters (i.e. galacticAv, internalAv, or redshift)
"""
imsimBand = Bandpass()
imsimBand.imsimBandpass()
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = self.rng.random_sample(nSed)*5.0
galacticAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0,
fileDir=self.sedDir,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = list(self.rng.random_sample(nSed)*5.0 + 15.0)
internalAvList_1 = list(self.rng.random_sample(nSed)*0.3 + 0.1)
redshiftList_1 = list(self.rng.random_sample(nSed)*5.0)
galacticAvList_1 = list(self.rng.random_sample(nSed)*0.3 + 0.1)
internalAvList_1[0] = None
redshiftList_1[1] = None
galacticAvList_1[2] = None
internalAvList_1[3] = None
redshiftList_1[3] = None
internalAvList_1[4] = None
galacticAvList_1[4] = None
redshiftList_1[5] = None
galacticAvList_1[5] = None
internalAvList_1[6] = None
redshiftList_1[6] = None
galacticAvList_1[6] = None
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2*nSed)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10)
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
if iav is not None:
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=iav)
if zz is not None:
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
if gav is not None:
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix+nSed]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
class PhotometryGalaxies(PhotometryBase):
"""
This mixin provides the code necessary for calculating the component magnitudes associated with
galaxies. It assumes that we want LSST filters.
"""
def _hasCosmoDistMod(self):
"""
Determine whether or not this InstanceCatalog has a column
specifically devoted to the cosmological distance modulus.
"""
if 'cosmologicalDistanceModulus' in self._all_available_columns:
return True
return False
def _loadBulgeSedList(self, wavelen_match):
"""
Load a SedList of galaxy bulge Seds.
The list will be stored in the variable self._bulgeSedList.
@param [in] wavelen_match is the wavelength grid (in nm)
on which the Seds are to be sampled.
"""
sedNameList = self.column_by_name('sedFilenameBulge')
magNormList = self.column_by_name('magNormBulge')
redshiftList = self.column_by_name('redshift')
internalAvList = self.column_by_name('internalAvBulge')
cosmologicalDimming = not self._hasCosmoDistMod()
if len(sedNameList)==0:
return np.ones((0))
if not hasattr(self, '_bulgeSedList'):
self._bulgeSedList = SedList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList,
cosmologicalDimming=cosmologicalDimming,
wavelenMatch=wavelen_match,
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
else:
self._bulgeSedList.flush()
self._bulgeSedList.loadSedsFromList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList)
def _loadDiskSedList(self, wavelen_match):
"""
Load a SedList of galaxy disk Seds.
The list will be stored in the variable self._bulgeSedList.
@param [in] wavelen_match is the wavelength grid (in nm)
on which the Seds are to be sampled.
"""
sedNameList = self.column_by_name('sedFilenameDisk')
magNormList = self.column_by_name('magNormDisk')
redshiftList = self.column_by_name('redshift')
internalAvList = self.column_by_name('internalAvDisk')
cosmologicalDimming = not self._hasCosmoDistMod()
if len(sedNameList)==0:
return np.ones((0))
if not hasattr(self, '_diskSedList'):
self._diskSedList = SedList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList,
cosmologicalDimming=cosmologicalDimming,
wavelenMatch=wavelen_match,
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
else:
self._diskSedList.flush()
self._diskSedList.loadSedsFromList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList)
def _loadAgnSedList(self, wavelen_match):
"""
Load a SedList of galaxy AGN Seds.
The list will be stored in the variable self._bulgeSedList.
@param [in] wavelen_match is the wavelength grid (in nm)
on which the Seds are to be sampled.
"""
sedNameList = self.column_by_name('sedFilenameAgn')
magNormList = self.column_by_name('magNormAgn')
redshiftList = self.column_by_name('redshift')
cosmologicalDimming = not self._hasCosmoDistMod()
if len(sedNameList)==0:
return np.ones((0))
if not hasattr(self, '_agnSedList'):
self._agnSedList = SedList(sedNameList, magNormList,
redshiftList=redshiftList,
cosmologicalDimming=cosmologicalDimming,
wavelenMatch=wavelen_match,
fileDir=getPackageDir('sims_sed_library'),
specMap=defaultSpecMap)
else:
self._agnSedList.flush()
self._agnSedList.loadSedsFromList(sedNameList, magNormList,
redshiftList=redshiftList)
def sum_magnitudes(self, disk = None, bulge = None, agn = None):
"""
Sum the component magnitudes of a galaxy and return the answer
@param [in] disk is the disk magnitude must be a numpy array or a float
@param [in] bulge is the bulge magnitude must be a numpy array or a float
@param [in] agn is the agn magnitude must be a numpy array or a float
@param [out] outMag is the total magnitude of the galaxy
"""
with np.errstate(divide='ignore', invalid='ignore'):
baselineType = type(None)
if not isinstance(disk, type(None)):
baselineType = type(disk)
if baselineType == np.ndarray:
elements=len(disk)
if not isinstance(bulge, type(None)):
if baselineType == type(None):
baselineType = type(bulge)
if baselineType == np.ndarray:
elements = len(bulge)
elif not isinstance(bulge, baselineType):
raise RuntimeError("All non-None arguments of sum_magnitudes need to be " +
"of the same type (float or numpy array)")
elif not isinstance(agn, type(None)):
if baseLineType == type(None):
baselineType = type(agn)
if baselineType == np.ndarray:
elements = len(agn)
elif not isinstance(agn, baselineType):
raise RuntimeError("All non-None arguments of sum_magnitudes need to be " +
"of the same type (float or numpy array)")
if baselineType is not float and \
baselineType is not np.ndarray and \
baselineType is not np.float and \
baselineType is not np.float64:
raise RuntimeError("Arguments of sum_magnitudes need to be " +
"either floats or numpy arrays; you appear to have passed %s " % baselineType)
mm_0 = 22.
tol = 1.0e-30
if baselineType == np.ndarray:
nn = np.zeros(elements)
else:
nn = 0.0
if disk is not None:
nn += np.where(np.isnan(disk), 0.0, np.power(10, -0.4*(disk - mm_0)))
if bulge is not None:
nn += np.where(np.isnan(bulge), 0.0, np.power(10, -0.4*(bulge - mm_0)))
if agn is not None:
nn += np.where(np.isnan(agn), 0.0, np.power(10, -0.4*(agn - mm_0)))
if baselineType == np.ndarray:
# according to this link
# http://stackoverflow.com/questions/25087769/runtimewarning-divide-by-zero-error-how-to-avoid-python-numpy
# we will still get a divide by zero error from log10, but np.where will be
# circumventing the offending value, so it is probably okay
return np.where(nn>tol, -2.5*np.log10(nn) + mm_0, np.NaN)
else:
if nn>tol:
return -2.5*np.log10(nn) + mm_0
else:
return np.NaN
def _quiescentMagnitudeGetter(self, componentName, bandpassDict, columnNameList):
"""
A generic getter for quiescent magnitudes of galaxy components.
@param [in] componentName is either 'bulge', 'disk', or 'agn'
@param [in] bandpassDict is a BandpassDict of the bandpasses
in which to calculate the magnitudes
@param [in] columnNameList is a list of the columns corresponding to
these magnitudes (for purposes of applying variability).
@param [out] magnitudes is a 2-D numpy array of magnitudes in which
rows correspond to bandpasses and columns correspond to astronomical
objects.
"""
# figure out which of these columns we are actually calculating
indices = [ii for ii, name in enumerate(columnNameList)
if name in self._actually_calculated_columns]
if len(indices) == len(columnNameList):
indices = None
if componentName == 'bulge':
self._loadBulgeSedList(bandpassDict.wavelenMatch)
if not hasattr(self, '_bulgeSedList'):
sedList = None
else:
sedList = self._bulgeSedList
elif componentName == 'disk':
self._loadDiskSedList(bandpassDict.wavelenMatch)
if not hasattr(self, '_diskSedList'):
sedList = None
else:
sedList = self._diskSedList
elif componentName == 'agn':
self._loadAgnSedList(bandpassDict.wavelenMatch)
if not hasattr(self, '_agnSedList'):
sedList = None
else:
sedList = self._agnSedList
else:
raise RuntimeError('_quiescentMagnitudeGetter does not understand component %s ' \
% componentName)
if sedList is None:
magnitudes = np.ones((len(columnNameList), 0))
else:
magnitudes = bandpassDict.magListForSedList(sedList, indices=indices).transpose()
if self._hasCosmoDistMod():
cosmoDistMod = self.column_by_name('cosmologicalDistanceModulus')
if len(cosmoDistMod)>0:
for ix in range(magnitudes.shape[0]):
magnitudes[ix] += cosmoDistMod
return magnitudes
@compound('sigma_uBulge', 'sigma_gBulge', 'sigma_rBulge',
'sigma_iBulge', 'sigma_zBulge', 'sigma_yBulge')
def get_photometric_uncertainties_bulge(self):
"""
Getter for photometric uncertainties associated with galaxy bulges
"""
return self._magnitudeUncertaintyGetter(['uBulge', 'gBulge', 'rBulge',
'iBulge', 'zBulge', 'yBulge'],
['u', 'g', 'r', 'i', 'z', 'y'],
'lsstBandpassDict')
@compound('sigma_uDisk', 'sigma_gDisk', 'sigma_rDisk',
'sigma_iDisk', 'sigma_zDisk', 'sigma_yDisk')
def get_photometric_uncertainties_disk(self):
"""
Getter for photometeric uncertainties associated with galaxy disks
"""
return self._magnitudeUncertaintyGetter(['uDisk', 'gDisk', 'rDisk',
'iDisk', 'zDisk', 'yDisk'],
['u', 'g', 'r', 'i', 'z', 'y'],
'lsstBandpassDict')
@compound('sigma_uAgn', 'sigma_gAgn', 'sigma_rAgn',
'sigma_iAgn', 'sigma_zAgn', 'sigma_yAgn')
def get_photometric_uncertainties_agn(self):
"""
Getter for photometric uncertainties associated with Agn
"""
return self._magnitudeUncertaintyGetter(['uAgn', 'gAgn', 'rAgn',
'iAgn', 'zAgn', 'yAgn'],
['u', 'g', 'r', 'i', 'z', 'y'],
'lsstBandpassDict')
@compound('uBulge', 'gBulge', 'rBulge', 'iBulge', 'zBulge', 'yBulge')
def get_lsst_bulge_mags(self):
"""
Getter for bulge magnitudes in LSST bandpasses
"""
# load a BandpassDict of LSST bandpasses, if not done already
if not hasattr(self, 'lsstBandpassDict'):
self.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
# actually calculate the magnitudes
mag = self._quiescentMagnitudeGetter('bulge', self.lsstBandpassDict,
self.get_lsst_bulge_mags._colnames)
mag += self._variabilityGetter(self.get_lsst_bulge_mags._colnames)
return mag
@compound('uDisk', 'gDisk', 'rDisk', 'iDisk', 'zDisk', 'yDisk')
def get_lsst_disk_mags(self):
"""
Getter for galaxy disk magnitudes in the LSST bandpasses
"""
# load a BandpassDict of LSST bandpasses, if not done already
if not hasattr(self, 'lsstBandpassDict'):
self.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
# actually calculate the magnitudes
mag = self._quiescentMagnitudeGetter('disk', self.lsstBandpassDict,
self.get_lsst_disk_mags._colnames)
mag += self._variabilityGetter(self.get_lsst_disk_mags._colnames)
return mag
@compound('uAgn', 'gAgn', 'rAgn', 'iAgn', 'zAgn', 'yAgn')
def get_lsst_agn_mags(self):
"""
Getter for AGN magnitudes in the LSST bandpasses
"""
# load a BandpassDict of LSST bandpasses, if not done already
if not hasattr(self, 'lsstBandpassDict'):
self.lsstBandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
# actually calculate the magnitudes
mag = self._quiescentMagnitudeGetter('agn', self.lsstBandpassDict,
self.get_lsst_agn_mags._colnames)
mag += self._variabilityGetter(self.get_lsst_agn_mags._colnames)
return mag
@compound('lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y')
def get_lsst_total_mags(self):
"""
Getter for total galaxy magnitudes in the LSST bandpasses
"""
idList = self.column_by_name('uniqueId')
numObj = len(idList)
output = []
# Loop over the columns calculated by this getter. For each
# column, calculate the bluge, disk, and agn magnitude in the
# corresponding bandpass, then sum them using the
# sum_magnitudes method.
for columnName in self.get_lsst_total_mags._colnames:
if columnName not in self._actually_calculated_columns:
sub_list = [np.NaN]*numObj
else:
bandpass = columnName[-1]
bulge = self.column_by_name('%sBulge' % bandpass)
disk = self.column_by_name('%sDisk' % bandpass)
agn = self.column_by_name('%sAgn' % bandpass)
sub_list = self.sum_magnitudes(bulge=bulge, disk=disk, agn=agn)
output.append(sub_list)
return np.array(output)
def testAlternateNormalizingBandpass(self):
"""
A reiteration of testAddingToList, but testing with a non-imsimBandpass
normalizing bandpass
"""
normalizingBand = Bandpass()
normalizingBand.readThroughput(os.path.join(getPackageDir('throughputs'), 'baseline', 'total_r.dat'))
nSed = 10
sedNameList_0 = self.getListOfSedNames(nSed)
magNormList_0 = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList_0 = self.rng.random_sample(nSed)*5.0
galacticAvList_0 = self.rng.random_sample(nSed)*0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList_0, magNormList_0,
fileDir=self.sedDir,
normalizingBandpass=normalizingBand,
internalAvList=internalAvList_0,
redshiftList=redshiftList_0, galacticAvList=galacticAvList_0,
wavelenMatch=wavelen_match)
sedNameList_1 = self.getListOfSedNames(nSed)
magNormList_1 = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList_1 = self.rng.random_sample(nSed)*5.0
galacticAvList_1 = self.rng.random_sample(nSed)*0.3 + 0.1
testList.loadSedsFromList(sedNameList_1, magNormList_1,
internalAvList=internalAvList_1,
galacticAvList=galacticAvList_1,
redshiftList=redshiftList_1)
self.assertEqual(len(testList), 2*nSed)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for ix in range(len(sedNameList_0)):
self.assertAlmostEqual(internalAvList_0[ix], testList.internalAvList[ix], 10)
self.assertAlmostEqual(galacticAvList_0[ix], testList.galacticAvList[ix], 10)
self.assertAlmostEqual(redshiftList_0[ix], testList.redshiftList[ix], 10)
for ix in range(len(sedNameList_1)):
self.assertAlmostEqual(internalAvList_1[ix], testList.internalAvList[ix+nSed], 10)
self.assertAlmostEqual(galacticAvList_1[ix], testList.galacticAvList[ix+nSed], 10)
self.assertAlmostEqual(redshiftList_1[ix], testList.redshiftList[ix+nSed], 10)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_0, magNormList_0, internalAvList_0,
galacticAvList_0, redshiftList_0)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
for ix, (name, norm, iav, gav, zz) in \
enumerate(zip(sedNameList_1, magNormList_1, internalAvList_1,
galacticAvList_1, redshiftList_1)):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, normalizingBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=iav)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
sedTest = testList[ix+nSed]
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testIndicesOnFlux(self):
"""
Test that, when you pass a list of indices into the calcFluxList
methods, you get the correct fluxes out.
"""
nBandpasses = 7
nameList, bpList = self.getListOfBandpasses(nBandpasses)
testBpDict = BandpassDict(bpList, nameList)
# first try it with a single Sed
wavelen = numpy.arange(10.0,2000.0,1.0)
flux = (wavelen*2.0-5.0)*1.0e-6
spectrum = Sed(wavelen=wavelen, flambda=flux)
indices = [1,2,5]
fluxList = testBpDict.fluxListForSed(spectrum, indices=indices)
ctNaN = 0
for ix, (name, bp, fluxTest) in enumerate(zip(nameList, bpList, fluxList)):
if ix in indices:
fluxControl = spectrum.calcFlux(bp)
self.assertAlmostEqual(fluxTest/fluxControl, 1.0, 2)
else:
ctNaN += 1
self.assertTrue(numpy.isnan(fluxTest))
self.assertEqual(ctNaN, 4)
nSed = 20
sedNameList = self.getListOfSedNames(nSed)
magNormList = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList = numpy.random.random_sample(nSed)*5.0
galacticAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
# now try a SedList without a wavelenMatch
testSedList = SedList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList)
fluxList = testBpDict.fluxListForSedList(testSedList, indices=indices)
self.assertEqual(fluxList.shape[0], nSed)
self.assertEqual(fluxList.shape[1], nBandpasses)
for ix, sedObj in enumerate(testSedList):
dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen),
flambda=copy.deepcopy(sedObj.flambda))
ctNaN = 0
for iy, bp in enumerate(testBpDict):
if iy in indices:
flux = dummySed.calcFlux(testBpDict[bp])
self.assertAlmostEqual(flux/fluxList[ix][iy], 1.0, 2)
else:
ctNaN += 1
self.assertTrue(numpy.isnan(fluxList[ix][iy]))
self.assertEqual(ctNaN, 4)
# now use wavelenMatch
testSedList = SedList(sedNameList, magNormList,
internalAvList=internalAvList,
redshiftList=redshiftList,
galacticAvList=galacticAvList,
wavelenMatch=testBpDict.wavelenMatch)
fluxList = testBpDict.fluxListForSedList(testSedList, indices=indices)
self.assertEqual(fluxList.shape[0], nSed)
self.assertEqual(fluxList.shape[1], nBandpasses)
for ix, sedObj in enumerate(testSedList):
dummySed = Sed(wavelen=copy.deepcopy(sedObj.wavelen),
flambda=copy.deepcopy(sedObj.flambda))
ctNaN = 0
for iy, bp in enumerate(testBpDict):
if iy in indices:
flux = dummySed.calcFlux(testBpDict[bp])
self.assertAlmostEqual(flux/fluxList[ix][iy], 1.0, 2)
else:
ctNaN += 1
self.assertTrue(numpy.isnan(fluxList[ix][iy]))
self.assertEqual(ctNaN, 4)
def testSetUp(self):
"""
Test the SedList can be successfully initialized
"""
############## Try just reading in an normalizing some SEDs
nSed = 10
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
testList = SedList(sedNameList, magNormList, fileDir=self.sedDir)
self.assertEqual(len(testList), nSed)
self.assertIsNone(testList.internalAvList)
self.assertIsNone(testList.galacticAvList)
self.assertIsNone(testList.redshiftList)
self.assertIsNone(testList.wavelenMatch)
self.assertTrue(testList.cosmologicalDimming)
imsimBand = Bandpass()
imsimBand.imsimBandpass()
for name, norm, sedTest in zip(sedNameList, magNormList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################# now add an internalAv
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1
testList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList)
self.assertIsNone(testList.galacticAvList)
self.assertIsNone(testList.redshiftList)
self.assertIsNone(testList.wavelenMatch)
self.assertTrue(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for name, norm, av, sedTest in zip(sedNameList, magNormList, internalAvList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=av)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################ now add redshift
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList = self.rng.random_sample(nSed)*5.0
testList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList)
self.assertIsNone(testList.galacticAvList)
self.assertIsNone(testList.wavelenMatch)
self.assertTrue(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for name, norm, av, zz, sedTest in \
zip(sedNameList, magNormList, internalAvList, redshiftList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=True)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################# without cosmological dimming
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList = self.rng.random_sample(nSed)*5.0
testList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList, cosmologicalDimming=False)
self.assertIsNone(testList.galacticAvList)
self.assertIsNone(testList.wavelenMatch)
self.assertFalse(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for name, norm, av, zz, sedTest in \
zip(sedNameList, magNormList, internalAvList, redshiftList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=False)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################ now add galacticAv
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList = self.rng.random_sample(nSed)*5.0
galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1
testList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList, galacticAvList=galacticAvList)
self.assertIsNone(testList.wavelenMatch)
self.assertTrue(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for avControl, avTest in zip(galacticAvList, testList.galacticAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for name, norm, av, zz, gav, sedTest in \
zip(sedNameList, magNormList, internalAvList,
redshiftList, galacticAvList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=True)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
################ now use a wavelen_match
sedNameList = self.getListOfSedNames(nSed)
magNormList = self.rng.random_sample(nSed)*5.0 + 15.0
internalAvList = self.rng.random_sample(nSed)*0.3 + 0.1
redshiftList = self.rng.random_sample(nSed)*5.0
galacticAvList = self.rng.random_sample(nSed)*0.3 + 0.1
wavelen_match = np.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList, magNormList,
fileDir=self.sedDir,
internalAvList=internalAvList,
redshiftList=redshiftList, galacticAvList=galacticAvList,
wavelenMatch=wavelen_match)
self.assertTrue(testList.cosmologicalDimming)
for avControl, avTest in zip(internalAvList, testList.internalAvList):
self.assertAlmostEqual(avControl, avTest, 10)
for zControl, zTest in zip(redshiftList, testList.redshiftList):
self.assertAlmostEqual(zControl, zTest, 10)
for avControl, avTest in zip(galacticAvList, testList.galacticAvList):
self.assertAlmostEqual(avControl, avTest, 10)
np.testing.assert_array_equal(wavelen_match, testList.wavelenMatch)
for name, norm, av, zz, gav, sedTest in \
zip(sedNameList, magNormList, internalAvList,
redshiftList, galacticAvList, testList):
sedControl = Sed()
sedControl.readSED_flambda(os.path.join(self.sedDir, name+'.gz'))
fnorm = sedControl.calcFluxNorm(norm, imsimBand)
sedControl.multiplyFluxNorm(fnorm)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=av)
sedControl.redshiftSED(zz, dimming=True)
sedControl.resampleSED(wavelen_match=wavelen_match)
a_coeff, b_coeff = sedControl.setupCCM_ab()
sedControl.addDust(a_coeff, b_coeff, A_v=gav)
np.testing.assert_array_equal(sedControl.wavelen, sedTest.wavelen)
np.testing.assert_array_equal(sedControl.flambda, sedTest.flambda)
np.testing.assert_array_equal(sedControl.fnu, sedTest.fnu)
def testExceptions(self):
"""
Test that exceptions are raised when they should be
"""
nSed = 10
sedNameList = self.getListOfSedNames(nSed)
magNormList = numpy.random.random_sample(nSed)*5.0 + 15.0
internalAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
redshiftList = numpy.random.random_sample(nSed)*5.0
galacticAvList = numpy.random.random_sample(nSed)*0.3 + 0.1
wavelen_match = numpy.arange(300.0, 1500.0, 10.0)
testList = SedList(sedNameList, magNormList, internalAvList=internalAvList,
redshiftList=redshiftList, galacticAvList=galacticAvList,
wavelenMatch=wavelen_match)
with self.assertRaises(AttributeError) as context:
testList.wavelenMatch = numpy.arange(10.0, 1000.0, 1000.0)
with self.assertRaises(AttributeError) as context:
testList.cosmologicalDimming = False
with self.assertRaises(AttributeError) as context:
testList.redshiftList = [1.8]
with self.assertRaises(AttributeError) as context:
testList.internalAvList = [2.5]
with self.assertRaises(AttributeError) as context:
testList.galacticAvList = [1.9]
testList = SedList(sedNameList, magNormList)
with self.assertRaises(RuntimeError) as context:
testList.loadSedsFromList(sedNameList, magNormList, internalAvList=internalAvList)
self.assertTrue('does not contain internalAvList' in context.exception.message)
with self.assertRaises(RuntimeError) as context:
testList.loadSedsFromList(sedNameList, magNormList, galacticAvList=galacticAvList)
self.assertTrue('does not contain galacticAvList' in context.exception.message)
with self.assertRaises(RuntimeError) as context:
testList.loadSedsFromList(sedNameList, magNormList, redshiftList=redshiftList)
self.assertTrue('does not contain redshiftList' in context.exception.message)
