def testApplyIGM(self):
"""Test application of IGM from Lookup Tables to SED objects"""
#Test that a warning comes up if input redshift is out of range and that no changes occurs to SED
testSed = Sed()
testSed.readSED_flambda(os.environ['SIMS_SED_LIBRARY_DIR'] +
'/galaxySED/Inst.80E09.25Z.spec.gz')
testFlambda = []
for fVal in testSed.flambda:
testFlambda.append(fVal)
testIGM = ApplyIGM()
testIGM.initializeIGM()
with warnings.catch_warnings(record=True) as wa:
testIGM.applyIGM(1.1, testSed)
self.assertEqual(len(wa), 1)
self.assertTrue('IGM Lookup tables' in str(wa[-1].message))
np.testing.assert_equal(testFlambda, testSed.flambda)
#Test that lookup table is read in correctly
testTable15 = np.genfromtxt(
str(os.environ['SIMS_SED_LIBRARY_DIR'] + '/igm/' +
'MeanLookupTable_zSource1.5.tbl'))
np.testing.assert_equal(testTable15, testIGM.meanLookups['1.5'])
#Test output by making sure that an incoming sed with flambda = 1.0 everywhere will return the
#transmission values of the lookup table as its flambda output
testSed.setSED(testSed.wavelen, flambda=np.ones(len(testSed.wavelen)))
testIGM.applyIGM(1.5, testSed)
testTable15Above300 = testTable15[np.where(testTable15[:, 0] >= 300.0)]
testSed.resampleSED(wavelen_match=testTable15Above300[:, 0])
np.testing.assert_allclose(testTable15Above300[:, 1], testSed.flambda,
1e-4)
def testApplyIGM(self):
"""Test application of IGM from Lookup Tables to SED objects"""
#Test that a warning comes up if input redshift is out of range and that no changes occurs to SED
testSed = Sed()
testSed.readSED_flambda(os.environ['SIMS_SED_LIBRARY_DIR'] + '/galaxySED/Inst.80E09.25Z.spec.gz')
testFlambda = []
for fVal in testSed.flambda:
testFlambda.append(fVal)
testIGM = ApplyIGM()
testIGM.initializeIGM()
with warnings.catch_warnings(record=True) as wa:
testIGM.applyIGM(1.1, testSed)
self.assertEqual(len(wa), 1)
self.assertTrue('IGM Lookup tables' in str(wa[-1].message))
np.testing.assert_equal(testFlambda, testSed.flambda)
#Test that lookup table is read in correctly
testTable15 = np.genfromtxt(str(os.environ['SIMS_SED_LIBRARY_DIR'] + '/igm/' +
'MeanLookupTable_zSource1.5.tbl'))
np.testing.assert_equal(testTable15, testIGM.meanLookups['1.5'])
#Test output by making sure that an incoming sed with flambda = 1.0 everywhere will return the
#transmission values of the lookup table as its flambda output
testSed.setSED(testSed.wavelen, flambda = np.ones(len(testSed.wavelen)))
testIGM.applyIGM(1.5, testSed)
testTable15Above300 = testTable15[np.where(testTable15[:,0] >= 300.0)]
testSed.resampleSED(wavelen_match = testTable15Above300[:,0])
np.testing.assert_allclose(testTable15Above300[:,1], testSed.flambda, 1e-4)
def loadKuruczSEDs(self, subset=None):
"""
By default will load all seds in kurucz directory. The user can also define a subset of
what's in the directory and load only those SEDs instead. Will skip over extraneous
files in sed folder.
@param [in] subset is the list of the subset of files wanted if one doesn't want all files
in the kurucz directory.
@param [out] sedList is the set of model SED spectra objects to be passed onto the matching
routines.
"""
files = []
if subset is None:
for fileName in os.listdir(self.kuruczDir):
files.append(fileName)
else:
for fileName in subset:
files.append(fileName)
numFiles = len(files)
numOn = 0
sedList = []
for fileName in files:
if numOn % 100 == 0:
print 'Loading %i of %i: Kurucz SEDs' % (numOn, numFiles)
try:
spec = Sed()
spec.readSED_flambda(str(self.kuruczDir + '/' + fileName))
logZTimesTen, temp, gravity, fineTemp = [
x.split(".")[0] for x in fileName.split("_")
]
if logZTimesTen[1] == 'm':
spec.logZ = -1.0 * float(logZTimesTen[2:]) * 0.1
else:
spec.logZ = float(logZTimesTen[2:]) * 0.1
spec.logg = float(gravity[1:]) * 0.1
spec.temp = float(fineTemp)
spec.name = fileName
except:
continue
sedList.append(spec)
numOn += 1
return sedList
def testSignalToNoise(self):
"""
Test that calcSNR_m5 and calcSNR_sed give similar results
"""
defaults = LSSTdefaults()
photParams = PhotometricParameters()
totalDict, hardwareDict = BandpassDict.loadBandpassesFromFiles()
skySED = Sed()
skySED.readSED_flambda(
os.path.join(lsst.utils.getPackageDir('throughputs'), 'baseline',
'darksky.dat'))
m5 = []
for filt in totalDict:
m5.append(
calcM5(skySED,
totalDict[filt],
hardwareDict[filt],
photParams,
seeing=defaults.seeing(filt)))
sedDir = lsst.utils.getPackageDir('sims_sed_library')
sedDir = os.path.join(sedDir, 'starSED', 'kurucz')
fileNameList = os.listdir(sedDir)
numpy.random.seed(42)
offset = numpy.random.random_sample(len(fileNameList)) * 2.0
for ix, name in enumerate(fileNameList):
if ix > 100:
break
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, name))
ff = spectrum.calcFluxNorm(m5[2] - offset[ix],
totalDict.values()[2])
spectrum.multiplyFluxNorm(ff)
magList = []
controlList = []
magList = []
for filt in totalDict:
controlList.append(
calcSNR_sed(spectrum, totalDict[filt], skySED,
hardwareDict[filt], photParams,
defaults.seeing(filt)))
magList.append(spectrum.calcMag(totalDict[filt]))
testList, gammaList = calcSNR_m5(numpy.array(magList),
numpy.array(totalDict.values()),
numpy.array(m5), photParams)
for tt, cc in zip(controlList, testList):
msg = '%e != %e ' % (tt, cc)
self.assertTrue(numpy.abs(tt / cc - 1.0) < 0.001, msg=msg)
def testAlternateBandpassesStars(self):
"""
This will test our ability to do photometry using non-LSST bandpasses.
It will first calculate the magnitudes using the getters in cartoonPhotometryStars.
It will then load the alternate bandpass files 'by hand' and re-calculate the magnitudes
and make sure that the magnitude values agree. This is guarding against the possibility
that some default value did not change and the code actually ended up loading the
LSST bandpasses.
"""
obs_metadata_pointed = ObservationMetaData(
mjd=2013.23, boundType="circle", unrefractedRA=200.0, unrefractedDec=-30.0, boundLength=1.0
)
bandpassDir = os.path.join(lsst.utils.getPackageDir("sims_photUtils"), "tests", "cartoonSedTestData")
cartoon_dict = BandpassDict.loadTotalBandpassesFromFiles(
["u", "g", "r", "i", "z"], bandpassDir=bandpassDir, bandpassRoot="test_bandpass_"
)
testBandPasses = {}
keys = ["u", "g", "r", "i", "z"]
bplist = []
for kk in keys:
testBandPasses[kk] = Bandpass()
testBandPasses[kk].readThroughput(os.path.join(bandpassDir, "test_bandpass_%s.dat" % kk))
bplist.append(testBandPasses[kk])
sedObj = Sed()
phiArray, waveLenStep = sedObj.setupPhiArray(bplist)
sedFileName = os.path.join(lsst.utils.getPackageDir("sims_sed_library"), "starSED", "kurucz")
sedFileName = os.path.join(sedFileName, "km20_5750.fits_g40_5790.gz")
ss = Sed()
ss.readSED_flambda(sedFileName)
controlBandpass = Bandpass()
controlBandpass.imsimBandpass()
ff = ss.calcFluxNorm(22.0, controlBandpass)
ss.multiplyFluxNorm(ff)
testMags = cartoon_dict.magListForSed(ss)
ss.resampleSED(wavelen_match=bplist[0].wavelen)
ss.flambdaTofnu()
mags = -2.5 * numpy.log10(numpy.sum(phiArray * ss.fnu, axis=1) * waveLenStep) - ss.zp
self.assertTrue(len(mags) == len(testMags))
self.assertTrue(len(mags) > 0)
for j in range(len(mags)):
self.assertAlmostEqual(mags[j], testMags[j], 10)
def loadKuruczSEDs(self, subset = None):
"""
By default will load all seds in kurucz directory. The user can also define a subset of
what's in the directory and load only those SEDs instead. Will skip over extraneous
files in sed folder.
@param [in] subset is the list of the subset of files wanted if one doesn't want all files
in the kurucz directory.
@param [out] sedList is the set of model SED spectra objects to be passed onto the matching
routines.
"""
files = []
if subset is None:
for fileName in os.listdir(self.kuruczDir):
files.append(fileName)
else:
for fileName in subset:
files.append(fileName)
numFiles = len(files)
numOn = 0
sedList = []
for fileName in files:
if numOn % 100 == 0:
print 'Loading %i of %i: Kurucz SEDs' % (numOn, numFiles)
try:
spec = Sed()
spec.readSED_flambda(str(self.kuruczDir + '/' + fileName))
logZTimesTen, temp, gravity, fineTemp = [x.split(".")[0] for x in fileName.split("_")]
if logZTimesTen[1] == 'm':
spec.logZ = -1.0 * float(logZTimesTen[2:]) * 0.1
else:
spec.logZ = float(logZTimesTen[2:]) * 0.1
spec.logg = float(gravity[1:]) * 0.1
spec.temp = float(fineTemp)
spec.name = fileName
except:
continue
sedList.append(spec)
numOn += 1
return sedList
def testAlternateBandpassesStars(self):
"""
This will test our ability to do photometry using non-LSST bandpasses.
It will first calculate the magnitudes using the getters in cartoonPhotometryStars.
It will then load the alternate bandpass files 'by hand' and re-calculate the magnitudes
and make sure that the magnitude values agree. This is guarding against the possibility
that some default value did not change and the code actually ended up loading the
LSST bandpasses.
"""
bandpassDir = os.path.join(lsst.utils.getPackageDir('sims_photUtils'), 'tests', 'cartoonSedTestData')
cartoon_dict = BandpassDict.loadTotalBandpassesFromFiles(['u', 'g', 'r', 'i', 'z'],
bandpassDir=bandpassDir,
bandpassRoot='test_bandpass_')
testBandPasses = {}
keys = ['u', 'g', 'r', 'i', 'z']
bplist = []
for kk in keys:
testBandPasses[kk] = Bandpass()
testBandPasses[kk].readThroughput(os.path.join(bandpassDir, "test_bandpass_%s.dat" % kk))
bplist.append(testBandPasses[kk])
sedObj = Sed()
phiArray, waveLenStep = sedObj.setupPhiArray(bplist)
sedFileName = os.path.join(lsst.utils.getPackageDir('sims_photUtils'),
'tests/cartoonSedTestData/starSed/')
sedFileName = os.path.join(sedFileName, 'kurucz', 'km20_5750.fits_g40_5790.gz')
ss = Sed()
ss.readSED_flambda(sedFileName)
controlBandpass = Bandpass()
controlBandpass.imsimBandpass()
ff = ss.calcFluxNorm(22.0, controlBandpass)
ss.multiplyFluxNorm(ff)
testMags = cartoon_dict.magListForSed(ss)
ss.resampleSED(wavelen_match = bplist[0].wavelen)
ss.flambdaTofnu()
mags = -2.5*np.log10(np.sum(phiArray*ss.fnu, axis=1)*waveLenStep) - ss.zp
self.assertEqual(len(mags), len(testMags))
self.assertGreater(len(mags), 0)
for j in range(len(mags)):
self.assertAlmostEqual(mags[j], testMags[j], 10)
def testSystematicUncertainty(self):
"""
Test that systematic uncertainty is added correctly.
"""
sigmaSys = 0.002
m5 = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams = PhotometricParameters(sigmaSys=sigmaSys)
bandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
obs_metadata = ObservationMetaData(unrefractedRA=23.0,
unrefractedDec=45.0,
m5=m5,
bandpassName=self.bandpasses)
magnitudes = bandpassDict.magListForSed(self.starSED)
skySeds = []
for i in range(len(self.bandpasses)):
skyDummy = Sed()
skyDummy.readSED_flambda(
os.path.join(lsst.utils.getPackageDir('throughputs'),
'baseline', 'darksky.dat'))
normalizedSkyDummy = setM5(obs_metadata.m5[self.bandpasses[i]],
skyDummy,
self.totalBandpasses[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(
self.bandpasses[i]),
photParams=PhotometricParameters())
skySeds.append(normalizedSkyDummy)
for i in range(len(self.bandpasses)):
snr = calcSNR_sed(self.starSED,
self.totalBandpasses[i],
skySeds[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(self.bandpasses[i]),
photParams=PhotometricParameters())
testSNR, gamma = calcSNR_m5(
numpy.array([magnitudes[i]]), [self.totalBandpasses[i]],
numpy.array([m5[i]]),
photParams=PhotometricParameters(sigmaSys=0.0))
self.assertAlmostEqual(snr, testSNR[0], 10, msg = 'failed on calcSNR_m5 test %e != %e ' \
% (snr, testSNR[0]))
control = numpy.sqrt(
numpy.power(magErrorFromSNR(testSNR), 2) +
numpy.power(sigmaSys, 2))
def loadBC03(self, subset=None):
"""
This loads the Bruzual and Charlot SEDs that are currently in the SIMS_SED_LIBRARY.
If the user wants to use different SEDs another loading method can be created and used in place
of this.
@param [in] subset is the list of the subset of files in the galDir that the user
can specify if using all the SEDs in the directory is not desired.
@param [out] sedList is the set of model SED spectra objects to be passed onto the matching routines.
"""
files = []
if subset is None:
for fileName in os.listdir(self.galDir):
files.append(fileName)
else:
for fileName in subset:
files.append(fileName)
numFiles = len(files)
numOn = 0
sedList = []
for fileName in files:
if numOn % 100 == 0:
print 'Loading %i of %i: BC Galaxy SEDs' % (numOn, numFiles)
try:
spec = Sed()
spec.readSED_flambda(str(self.galDir + '/' + fileName))
spec.name = fileName
fileNameAsList = fileName.split('.')
spec.type = fileNameAsList[0]
spec.age = float(fileNameAsList[1])
metallicity = fileNameAsList[2].split('Z')[0]
#Final form is z/zSun
spec.metallicity = float(metallicity) * (10**(
(len(metallicity) - 1) * -1))
except:
continue
sedList.append(spec)
numOn += 1
return sedList
def loadwdSEDs(self, subset = None):
"""
By default will load all seds in wd directory. The user can also define a subset of
what's in the directory and load only those SEDs instead. Will skip over extraneous
files in sed folder.
@param [in] subset is the list of the subset of files wanted if one doesn't want all files
in the kurucz directory.
@param [out] sedListH is the set of model SED spectra objects for Hydrogen WDs to be passed onto
the matching routines.
@param [out] sedListHE is the set of model SED spectra objects for Helium WDs to be passed onto
the matching routines.
"""
files = []
if subset is None:
for fileName in os.listdir(self.wdDir):
files.append(fileName)
else:
for fileName in subset:
files.append(fileName)
numFiles = len(files)
numOn = 0
sedListH = []
sedListHE = []
for fileName in files:
if numOn % 100 == 0:
print 'Loading %i of %i: WD SEDs' % (numOn, numFiles)
try:
spec = Sed()
spec.readSED_flambda(str(self.wdDir + '/' + fileName))
spec.name = fileName
if fileName.split("_")[1] == 'He':
sedListHE.append(spec)
else:
sedListH.append(spec)
except:
continue
numOn += 1
return sedListH, sedListHE
def loadBC03(self, subset = None):
"""
This loads the Bruzual and Charlot SEDs that are currently in the SIMS_SED_LIBRARY.
If the user wants to use different SEDs another loading method can be created and used in place
of this.
@param [in] subset is the list of the subset of files in the galDir that the user
can specify if using all the SEDs in the directory is not desired.
@param [out] sedList is the set of model SED spectra objects to be passed onto the matching routines.
"""
files = []
if subset is None:
for fileName in os.listdir(self.galDir):
files.append(fileName)
else:
for fileName in subset:
files.append(fileName)
numFiles = len(files)
numOn = 0
sedList = []
for fileName in files:
if numOn % 100 == 0:
print 'Loading %i of %i: BC Galaxy SEDs' % (numOn, numFiles)
try:
spec = Sed()
spec.readSED_flambda(str(self.galDir + '/' + fileName))
spec.name = fileName
fileNameAsList = fileName.split('.')
spec.type = fileNameAsList[0]
spec.age = float(fileNameAsList[1])
metallicity = fileNameAsList[2].split('Z')[0]
#Final form is z/zSun
spec.metallicity = float(metallicity) * (10 ** ((len(metallicity)-1)*-1))
except:
continue
sedList.append(spec)
numOn += 1
return sedList
def loadwdSEDs(self, subset=None):
"""
By default will load all seds in wd directory. The user can also define a subset of
what's in the directory and load only those SEDs instead. Will skip over extraneous
files in sed folder.
@param [in] subset is the list of the subset of files wanted if one doesn't want all files
in the kurucz directory.
@param [out] sedListH is the set of model SED spectra objects for Hydrogen WDs to be passed onto
the matching routines.
@param [out] sedListHE is the set of model SED spectra objects for Helium WDs to be passed onto
the matching routines.
"""
files = []
if subset is None:
for fileName in os.listdir(self.wdDir):
files.append(fileName)
else:
for fileName in subset:
files.append(fileName)
numFiles = len(files)
numOn = 0
sedListH = []
sedListHE = []
for fileName in files:
if numOn % 100 == 0:
print 'Loading %i of %i: WD SEDs' % (numOn, numFiles)
try:
spec = Sed()
spec.readSED_flambda(str(self.wdDir + '/' + fileName))
spec.name = fileName
if fileName.split("_")[1] == 'He':
sedListHE.append(spec)
else:
sedListH.append(spec)
except:
continue
numOn += 1
return sedListH, sedListHE
def __init__(self, catsim_cat, om10_cat='twinkles_lenses_v2.fits',
density_param=1.):
"""
Parameters
----------
catsim_cat: catsim catalog
The results array from an instance catalog.
om10_cat: optional, defaults to 'twinkles_tdc_rung4.fits
fits file with OM10 catalog
density_param: `np.float`, optioanl, defaults to 1.0
the fraction of eligible agn objects that become lensed and should
be between 0.0 and 1.0.
Returns
-------
updated_catalog:
A new results array with lens systems added.
"""
twinklesDir = getPackageDir('Twinkles')
om10_cat = os.path.join(twinklesDir, 'data', om10_cat)
self.catalog = catsim_cat
# ****** THIS ASSUMES THAT THE ENVIRONMENT VARIABLE OM10_DIR IS SET *******
lensdb = om10.DB(catalog=om10_cat)
self.lenscat = lensdb.lenses.copy()
self.density_param = density_param
self.bandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames=['i'])
specFileStart = 'Burst'
for key, val in sorted(iteritems(SpecMap.subdir_map)):
if re.match(key, specFileStart):
galSpecDir = str(val)
galDir = str(getPackageDir('sims_sed_library') + '/' + galSpecDir + '/')
self.LRG_name = 'Burst.25E09.1Z.spec'
self.LRG = Sed()
self.LRG.readSED_flambda(str(galDir + self.LRG_name))
#return
#Calculate imsimband magnitudes of source galaxies for matching
agn_sed = Sed()
agn_fname = str(getPackageDir('sims_sed_library') + '/agnSED/agn.spec.gz')
agn_sed.readSED_flambda(agn_fname)
src_iband = self.lenscat['MAGI_IN']
self.src_mag_norm = []
for src in src_iband:
self.src_mag_norm.append(matchBase().calcMagNorm([src],
agn_sed,
self.bandpassDict))
def testSignalToNoise(self):
"""
Test that calcSNR_m5 and calcSNR_sed give similar results
"""
defaults = LSSTdefaults()
photParams = PhotometricParameters()
totalDict, hardwareDict = BandpassDict.loadBandpassesFromFiles()
skySED = Sed()
skySED.readSED_flambda(os.path.join(lsst.utils.getPackageDir("throughputs"), "baseline", "darksky.dat"))
m5 = []
for filt in totalDict:
m5.append(calcM5(skySED, totalDict[filt], hardwareDict[filt], photParams, seeing=defaults.seeing(filt)))
sedDir = lsst.utils.getPackageDir("sims_sed_library")
sedDir = os.path.join(sedDir, "starSED", "kurucz")
fileNameList = os.listdir(sedDir)
numpy.random.seed(42)
offset = numpy.random.random_sample(len(fileNameList)) * 2.0
for ix, name in enumerate(fileNameList):
if ix > 100:
break
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, name))
ff = spectrum.calcFluxNorm(m5[2] - offset[ix], totalDict.values()[2])
spectrum.multiplyFluxNorm(ff)
magList = []
controlList = []
magList = []
for filt in totalDict:
controlList.append(
calcSNR_sed(
spectrum, totalDict[filt], skySED, hardwareDict[filt], photParams, defaults.seeing(filt)
)
)
magList.append(spectrum.calcMag(totalDict[filt]))
testList, gammaList = calcSNR_m5(
numpy.array(magList), numpy.array(totalDict.values()), numpy.array(m5), photParams
)
for tt, cc in zip(controlList, testList):
msg = "%e != %e " % (tt, cc)
self.assertTrue(numpy.abs(tt / cc - 1.0) < 0.001, msg=msg)
def testSystematicUncertainty(self):
"""
Test that systematic uncertainty is added correctly.
"""
sigmaSys = 0.002
m5 = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams = PhotometricParameters(sigmaSys=sigmaSys)
bandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
obs_metadata = ObservationMetaData(unrefractedRA=23.0, unrefractedDec=45.0, m5=m5, bandpassName=self.bandpasses)
magnitudes = bandpassDict.magListForSed(self.starSED)
skySeds = []
for i in range(len(self.bandpasses)):
skyDummy = Sed()
skyDummy.readSED_flambda(os.path.join(lsst.utils.getPackageDir("throughputs"), "baseline", "darksky.dat"))
normalizedSkyDummy = setM5(
obs_metadata.m5[self.bandpasses[i]],
skyDummy,
self.totalBandpasses[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(self.bandpasses[i]),
photParams=PhotometricParameters(),
)
skySeds.append(normalizedSkyDummy)
for i in range(len(self.bandpasses)):
snr = calcSNR_sed(
self.starSED,
self.totalBandpasses[i],
skySeds[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(self.bandpasses[i]),
photParams=PhotometricParameters(),
)
testSNR, gamma = calcSNR_m5(
numpy.array([magnitudes[i]]),
[self.totalBandpasses[i]],
numpy.array([m5[i]]),
photParams=PhotometricParameters(sigmaSys=0.0),
)
self.assertAlmostEqual(snr, testSNR[0], 10, msg="failed on calcSNR_m5 test %e != %e " % (snr, testSNR[0]))
control = numpy.sqrt(numpy.power(magErrorFromSNR(testSNR), 2) + numpy.power(sigmaSys, 2))
def testCalcMagNorm(self):
"""Tests the calculation of magnitude normalization for an SED with the given magnitudes
in the given bandpasses."""
testUtils = matchBase()
bandpassDir = os.path.join(lsst.utils.getPackageDir('throughputs'),
'sdss')
testPhot = BandpassDict.loadTotalBandpassesFromFiles(
self.filterList, bandpassDir=bandpassDir, bandpassRoot='sdss_')
unChangedSED = Sed()
unChangedSED.readSED_flambda(
str(self.galDir + os.listdir(self.galDir)[0]))
imSimBand = Bandpass()
imSimBand.imsimBandpass()
testSED = Sed()
testSED.setSED(unChangedSED.wavelen, flambda=unChangedSED.flambda)
magNorm = 20.0
redVal = 0.1
testSED.redshiftSED(redVal)
fluxNorm = testSED.calcFluxNorm(magNorm, imSimBand)
testSED.multiplyFluxNorm(fluxNorm)
sedMags = testPhot.magListForSed(testSED)
stepSize = 0.001
testMagNorm = testUtils.calcMagNorm(sedMags,
unChangedSED,
testPhot,
redshift=redVal)
# Test adding in mag_errors. If an array of np.ones is passed in we should get same result
testMagNormWithErr = testUtils.calcMagNorm(sedMags,
unChangedSED,
testPhot,
mag_error=np.ones(
len(sedMags)),
redshift=redVal)
# Also need to add in test for filtRange
sedMagsIncomp = sedMags
sedMagsIncomp[1] = None
filtRangeTest = [0, 2, 3, 4]
testMagNormFiltRange = testUtils.calcMagNorm(sedMagsIncomp,
unChangedSED,
testPhot,
redshift=redVal,
filtRange=filtRangeTest)
self.assertAlmostEqual(magNorm, testMagNorm, delta=stepSize)
self.assertAlmostEqual(magNorm, testMagNormWithErr, delta=stepSize)
self.assertAlmostEqual(magNorm, testMagNormFiltRange, delta=stepSize)
def loadmltSEDs(self, subset = None):
"""
By default will load all seds in mlt directory. The user can also define a subset of
what's in the directory and load only those SEDs instead. Will skip over extraneous
files in sed folder.
@param [in] subset is the list of the subset of files wanted if one doesn't want all files
in the mlt directory.
@param [out] sedList is the set of model SED spectra objects to be passed onto the matching
routines.
"""
files = []
if subset is None:
for fileName in os.listdir(self.mltDir):
files.append(fileName)
else:
for fileName in subset:
files.append(fileName)
numFiles = len(files)
numOn = 0
sedList = []
for fileName in files:
if numOn % 100 == 0:
print 'Loading %i of %i: MLT SEDs' % (numOn, numFiles)
try:
spec = Sed()
spec.readSED_flambda(str(self.mltDir + '/' + fileName))
spec.name = fileName
except:
continue
sedList.append(spec)
numOn += 1
return sedList
def testCalcBasicColors(self):
"""Tests the calculation of the colors of an SED in given bandpasses."""
testUtils = matchBase()
testSED = Sed()
testPhot = BandpassDict.loadTotalBandpassesFromFiles(self.filterList,
bandpassDir = os.path.join(lsst.utils.getPackageDir('throughputs'),'sdss'),
bandpassRoot = 'sdss_')
testSED.readSED_flambda(str(self.galDir + os.listdir(self.galDir)[0]))
testMags = testPhot.magListForSed(testSED)
testColors = []
for filtNum in range(0, len(self.filterList)-1):
testColors.append(testMags[filtNum] - testMags[filtNum+1])
testOutput = testUtils.calcBasicColors([testSED], testPhot)
np.testing.assert_equal([testColors], testOutput)
def testCalcBasicColors(self):
"""Tests the calculation of the colors of an SED in given bandpasses."""
testUtils = matchBase()
testSED = Sed()
bandpassDir = os.path.join(lsst.utils.getPackageDir('throughputs'),
'sdss')
testPhot = BandpassDict.loadTotalBandpassesFromFiles(
self.filterList, bandpassDir=bandpassDir, bandpassRoot='sdss_')
testSED.readSED_flambda(str(self.galDir + os.listdir(self.galDir)[0]))
testMags = testPhot.magListForSed(testSED)
testColors = []
for filtNum in range(0, len(self.filterList) - 1):
testColors.append(testMags[filtNum] - testMags[filtNum + 1])
testOutput = testUtils.calcBasicColors([testSED], testPhot)
np.testing.assert_equal([testColors], testOutput)
def testPhotometricIndicesRaw(self):
"""
Use manMagCalc_list with specified indices on an Sed. Make sure
that the appropriate magnitudes are or are not Nan
"""
starName = os.path.join(getPackageDir('sims_sed_library'), defaultSpecMap['km20_5750.fits_g40_5790'])
starPhot = BandpassDict.loadTotalBandpassesFromFiles()
testSed = Sed()
testSed.readSED_flambda(starName)
indices = [1, 3]
mags = starPhot.magListForSed(testSed, indices=indices)
np.testing.assert_equal(mags[0], np.NaN)
self.assertFalse(np.isnan(mags[1]), msg='mags[1] is NaN; should not be')
np.testing.assert_equal(mags[2], np.NaN)
self.assertFalse(np.isnan(mags[3]), msg='mags[3] is NaN; should not be')
np.testing.assert_equal(mags[4], np.NaN)
np.testing.assert_equal(mags[5], np.NaN)
self.assertEqual(len(mags), 6)
def testInitializeIGM(self):
"Test Initialization Method"
#Make sure that if we initialize IGM with new inputs that it is initializing with them
testIGM = ApplyIGM()
testSed = Sed()
testSed.readSED_flambda(os.environ['SIMS_SED_LIBRARY_DIR'] + '/galaxySED/Inst.80E09.25Z.spec.gz')
testIGM.applyIGM(1.8, testSed)
testZmin = 1.8
testZmax = 2.2
#Want new values for testing,
#so make sure we are not just putting in the same values as are already there
self.assertNotEqual(testZmin, testIGM.zMin)
self.assertNotEqual(testZmax, testIGM.zMax)
testIGM.initializeIGM(zMin = testZmin, zMax = testZmax)
self.assertEqual(testZmin, testIGM.zMin)
self.assertEqual(testZmax, testIGM.zMax)
def loadmltSEDs(self, subset=None):
"""
By default will load all seds in mlt directory. The user can also define a subset of
what's in the directory and load only those SEDs instead. Will skip over extraneous
files in sed folder.
@param [in] subset is the list of the subset of files wanted if one doesn't want all files
in the mlt directory.
@param [out] sedList is the set of model SED spectra objects to be passed onto the matching
routines.
"""
files = []
if subset is None:
for fileName in os.listdir(self.mltDir):
files.append(fileName)
else:
for fileName in subset:
files.append(fileName)
numFiles = len(files)
numOn = 0
sedList = []
for fileName in files:
if numOn % 100 == 0:
print 'Loading %i of %i: MLT SEDs' % (numOn, numFiles)
try:
spec = Sed()
spec.readSED_flambda(str(self.mltDir + '/' + fileName))
spec.name = fileName
except:
continue
sedList.append(spec)
numOn += 1
return sedList
def testPhotometricIndicesRaw(self):
"""
Use manMagCalc_list with specified indices on an Sed. Make sure
that the appropriate magnitudes are or are not Nan
"""
starName = os.path.join(lsst.utils.getPackageDir('sims_sed_library'),defaultSpecMap['km20_5750.fits_g40_5790'])
starPhot = PhotometryStars()
starPhot.loadTotalBandpassesFromFiles()
testSed = Sed()
testSed.readSED_flambda(starName)
indices = [1,3]
mags = starPhot.manyMagCalc_list(testSed, indices=indices)
self.assertTrue(numpy.isnan(mags[0]))
self.assertFalse(numpy.isnan(mags[1]))
self.assertTrue(numpy.isnan(mags[2]))
self.assertFalse(numpy.isnan(mags[3]))
self.assertTrue(numpy.isnan(mags[4]))
self.assertTrue(numpy.isnan(mags[5]))
self.assertTrue(len(mags)==6)
def testInitializeIGM(self):
"Test Initialization Method"
#Make sure that if we initialize IGM with new inputs that it is initializing with them
testIGM = ApplyIGM()
testSed = Sed()
testSed.readSED_flambda(os.environ['SIMS_SED_LIBRARY_DIR'] +
'/galaxySED/Inst.80E09.25Z.spec.gz')
testIGM.applyIGM(1.8, testSed)
testZmin = 1.8
testZmax = 2.2
#Want new values for testing,
#so make sure we are not just putting in the same values as are already there
self.assertNotEqual(testZmin, testIGM.zMin)
self.assertNotEqual(testZmax, testIGM.zMax)
testIGM.initializeIGM(zMin=testZmin, zMax=testZmax)
self.assertEqual(testZmin, testIGM.zMin)
self.assertEqual(testZmax, testIGM.zMax)
class uncertaintyUnitTest(unittest.TestCase):
"""
Test the calculation of photometric uncertainties
"""
def setUp(self):
starName = os.path.join(lsst.utils.getPackageDir('sims_sed_library'),defaultSpecMap['km20_5750.fits_g40_5790'])
self.starSED = Sed()
self.starSED.readSED_flambda(starName)
imsimband = Bandpass()
imsimband.imsimBandpass()
fNorm = self.starSED.calcFluxNorm(22.0, imsimband)
self.starSED.multiplyFluxNorm(fNorm)
self.totalBandpasses = []
self.hardwareBandpasses = []
componentList = ['detector.dat', 'm1.dat', 'm2.dat', 'm3.dat',
'lens1.dat', 'lens2.dat', 'lens3.dat']
hardwareComponents = []
for c in componentList:
hardwareComponents.append(os.path.join(lsst.utils.getPackageDir('throughputs'),'baseline',c))
self.bandpasses = ['u', 'g', 'r', 'i', 'z', 'y']
for b in self.bandpasses:
filterName = os.path.join(lsst.utils.getPackageDir('throughputs'),'baseline','filter_%s.dat' % b)
components = hardwareComponents + [filterName]
bandpassDummy = Bandpass()
bandpassDummy.readThroughputList(components)
self.hardwareBandpasses.append(bandpassDummy)
components = components + [os.path.join(lsst.utils.getPackageDir('throughputs'),'baseline','atmos.dat')]
bandpassDummy = Bandpass()
bandpassDummy.readThroughputList(components)
self.totalBandpasses.append(bandpassDummy)
def tearDown(self):
del self.starSED
del self.bandpasses
del self.hardwareBandpasses
del self.totalBandpasses
def testPhotometricIndicesRaw(self):
"""
Use manMagCalc_list with specified indices on an Sed. Make sure
that the appropriate magnitudes are or are not Nan
"""
starName = os.path.join(getPackageDir('sims_sed_library'),
defaultSpecMap['km20_5750.fits_g40_5790'])
starPhot = BandpassDict.loadTotalBandpassesFromFiles()
testSed = Sed()
testSed.readSED_flambda(starName)
indices = [1, 3]
mags = starPhot.magListForSed(testSed, indices=indices)
np.testing.assert_equal(mags[0], np.NaN)
self.assertFalse(np.isnan(mags[1]),
msg='mags[1] is NaN; should not be')
np.testing.assert_equal(mags[2], np.NaN)
self.assertFalse(np.isnan(mags[3]),
msg='mags[3] is NaN; should not be')
np.testing.assert_equal(mags[4], np.NaN)
np.testing.assert_equal(mags[5], np.NaN)
self.assertEqual(len(mags), 6)
def testSEDCopyBasicColors(self):
"""Tests that when makeCopy=True in calcBasicColors the SED object is unchanged after calling
and that colors are still accurately calculated"""
testUtils = matchBase()
testSED = Sed()
copyTest = Sed()
testPhot = BandpassDict.loadTotalBandpassesFromFiles(self.filterList,
bandpassDir = os.path.join(lsst.utils.getPackageDir('throughputs'),'sdss'),
bandpassRoot = 'sdss_')
testSED.readSED_flambda(str(self.galDir + os.listdir(self.galDir)[0]))
copyTest.setSED(wavelen = testSED.wavelen, flambda = testSED.flambda)
testLambda = copyTest.wavelen[0]
testMags = testPhot.magListForSed(testSED)
testColors = []
for filtNum in range(0, len(self.filterList)-1):
testColors.append(testMags[filtNum] - testMags[filtNum+1])
testOutput = testUtils.calcBasicColors([copyTest], testPhot, makeCopy=True)
self.assertEqual(testLambda, copyTest.wavelen[0])
np.testing.assert_equal([testColors], testOutput)
def testSEDCopyBasicColors(self):
"""Tests that when makeCopy=True in calcBasicColors the SED object is unchanged after calling
and that colors are still accurately calculated"""
testUtils = matchBase()
testSED = Sed()
copyTest = Sed()
testPhot = BandpassDict.loadTotalBandpassesFromFiles(self.filterList,
bandpassDir = os.path.join(lsst.utils.getPackageDir('throughputs'),'sdss'),
bandpassRoot = 'sdss_')
testSED.readSED_flambda(str(self.galDir + os.listdir(self.galDir)[0]))
copyTest.setSED(wavelen = testSED.wavelen, flambda = testSED.flambda)
testLambda = copyTest.wavelen[0]
testMags = testPhot.magListForSed(testSED)
testColors = []
for filtNum in range(0, len(self.filterList)-1):
testColors.append(testMags[filtNum] - testMags[filtNum+1])
testOutput = testUtils.calcBasicColors([copyTest], testPhot, makeCopy=True)
self.assertEqual(testLambda, copyTest.wavelen[0])
np.testing.assert_equal([testColors], testOutput)
def testInitializeIGM(self):
"Test Initialization Method"
# Make sure that if we initialize IGM with new inputs that it
# is initializing with them
testIGM = ApplyIGM()
testSed = Sed()
sedName = os.path.join(getPackageDir('sims_sed_library'), 'galaxySED')
testSed.readSED_flambda(
os.path.join(sedName, 'Burst.10E08.002Z.spec.gz'))
testIGM.applyIGM(1.8, testSed)
testZmin = 1.8
testZmax = 2.2
# Want new values for testing,
# so make sure we are not just putting in the same values
# as are already there
self.assertNotEqual(testZmin, testIGM.zMin)
self.assertNotEqual(testZmax, testIGM.zMax)
testIGM.initializeIGM(zMin=testZmin, zMax=testZmax)
self.assertEqual(testZmin, testIGM.zMin)
self.assertEqual(testZmax, testIGM.zMax)
def testInitializeIGM(self):
"Test Initialization Method"
# Make sure that if we initialize IGM with new inputs that it
# is initializing with them
testIGM = ApplyIGM()
testSed = Sed()
sedName = os.path.join(getPackageDir('sims_sed_library'), 'galaxySED')
testSed.readSED_flambda(os.path.join(sedName,
'Burst.10E08.002Z.spec.gz'))
testIGM.applyIGM(1.8, testSed)
testZmin = 1.8
testZmax = 2.2
# Want new values for testing,
# so make sure we are not just putting in the same values
# as are already there
self.assertNotEqual(testZmin, testIGM.zMin)
self.assertNotEqual(testZmax, testIGM.zMax)
testIGM.initializeIGM(zMin = testZmin, zMax = testZmax)
self.assertEqual(testZmin, testIGM.zMin)
self.assertEqual(testZmax, testIGM.zMax)
def testApplyIGM(self):
"""Test application of IGM from Lookup Tables to SED objects"""
# Test that a warning comes up if input redshift is out
# of range and that no changes occurs to SED
testSed = Sed()
sedName = os.path.join(getPackageDir('sims_photUtils'),
'tests/cartoonSedTestData/galaxySed/')
testSed.readSED_flambda(os.path.join(sedName,
'Burst.10E08.002Z.spec.gz'))
testFlambda = []
for fVal in testSed.flambda:
testFlambda.append(fVal)
testIGM = ApplyIGM()
testIGM.initializeIGM()
with warnings.catch_warnings(record=True) as wa:
testIGM.applyIGM(1.1, testSed)
self.assertEqual(len(wa), 1)
self.assertIn('IGM Lookup tables', str(wa[-1].message))
np.testing.assert_equal(testFlambda, testSed.flambda)
# Test that lookup table is read in correctly
testTable15 = np.genfromtxt(str(getPackageDir('sims_photUtils') +
'/python/lsst/sims/photUtils/igm_tables/' +
'MeanLookupTable_zSource1.5.tbl.gz'))
np.testing.assert_equal(testTable15, testIGM.meanLookups['1.5'])
# Test output by making sure that an incoming sed
# with flambda = 1.0 everywhere will return the
# transmission values of the lookup table as its
# flambda output
testSed.setSED(testSed.wavelen, flambda=np.ones(len(testSed.wavelen)))
testIGM.applyIGM(1.5, testSed)
testTable15Above300 = testTable15[np.where(testTable15[:, 0] >= 300.0)]
testSed.resampleSED(wavelen_match = testTable15Above300[:, 0])
np.testing.assert_allclose(testTable15Above300[:, 1],
testSed.flambda, 1e-4)
def testCalcMagNorm(self):
"""Tests the calculation of magnitude normalization for an SED with the given magnitudes
in the given bandpasses."""
testUtils = matchBase()
bandpassDir = os.path.join(lsst.utils.getPackageDir('throughputs'), 'sdss')
testPhot = BandpassDict.loadTotalBandpassesFromFiles(self.filterList,
bandpassDir = bandpassDir,
bandpassRoot = 'sdss_')
unChangedSED = Sed()
unChangedSED.readSED_flambda(str(self.galDir + os.listdir(self.galDir)[0]))
imSimBand = Bandpass()
imSimBand.imsimBandpass()
testSED = Sed()
testSED.setSED(unChangedSED.wavelen, flambda = unChangedSED.flambda)
magNorm = 20.0
redVal = 0.1
testSED.redshiftSED(redVal)
fluxNorm = testSED.calcFluxNorm(magNorm, imSimBand)
testSED.multiplyFluxNorm(fluxNorm)
sedMags = testPhot.magListForSed(testSED)
stepSize = 0.001
testMagNorm = testUtils.calcMagNorm(sedMags, unChangedSED, testPhot, redshift = redVal)
# Test adding in mag_errors. If an array of np.ones is passed in we should get same result
testMagNormWithErr = testUtils.calcMagNorm(sedMags, unChangedSED, testPhot,
mag_error = np.ones(len(sedMags)), redshift = redVal)
# Also need to add in test for filtRange
sedMagsIncomp = sedMags
sedMagsIncomp[1] = None
filtRangeTest = [0, 2, 3, 4]
testMagNormFiltRange = testUtils.calcMagNorm(sedMagsIncomp, unChangedSED, testPhot,
redshift = redVal, filtRange = filtRangeTest)
self.assertAlmostEqual(magNorm, testMagNorm, delta = stepSize)
self.assertAlmostEqual(magNorm, testMagNormWithErr, delta = stepSize)
self.assertAlmostEqual(magNorm, testMagNormFiltRange, delta = stepSize)
class UncertaintyMixinTest(unittest.TestCase):
def setUp(self):
starName = os.path.join(getPackageDir('sims_sed_library'),
defaultSpecMap['km20_5750.fits_g40_5790'])
self.starSED = Sed()
self.starSED.readSED_flambda(starName)
imsimband = Bandpass()
imsimband.imsimBandpass()
fNorm = self.starSED.calcFluxNorm(22.0, imsimband)
self.starSED.multiplyFluxNorm(fNorm)
self.totalBandpasses = []
self.hardwareBandpasses = []
componentList = [
'detector.dat', 'm1.dat', 'm2.dat', 'm3.dat', 'lens1.dat',
'lens2.dat', 'lens3.dat'
]
hardwareComponents = []
for c in componentList:
hardwareComponents.append(
os.path.join(getPackageDir('throughputs'), 'baseline', c))
self.bandpasses = ['u', 'g', 'r', 'i', 'z', 'y']
for b in self.bandpasses:
filterName = os.path.join(getPackageDir('throughputs'), 'baseline',
'filter_%s.dat' % b)
components = hardwareComponents + [filterName]
bandpassDummy = Bandpass()
bandpassDummy.readThroughputList(components)
self.hardwareBandpasses.append(bandpassDummy)
components = components + [
os.path.join(getPackageDir('throughputs'), 'baseline',
'atmos.dat')
]
bandpassDummy = Bandpass()
bandpassDummy.readThroughputList(components)
self.totalBandpasses.append(bandpassDummy)
def testApplyIGM(self):
"""Test application of IGM from Lookup Tables to SED objects"""
# Test that a warning comes up if input redshift is out
# of range and that no changes occurs to SED
testSed = Sed()
sedName = os.path.join(getPackageDir('sims_sed_library'), 'galaxySED')
testSed.readSED_flambda(os.path.join(sedName,
'Burst.10E08.002Z.spec.gz'))
testFlambda = []
for fVal in testSed.flambda:
testFlambda.append(fVal)
testIGM = ApplyIGM()
testIGM.initializeIGM()
with warnings.catch_warnings(record=True) as wa:
testIGM.applyIGM(1.1, testSed)
self.assertEqual(len(wa), 1)
self.assertIn('IGM Lookup tables', str(wa[-1].message))
np.testing.assert_equal(testFlambda, testSed.flambda)
# Test that lookup table is read in correctly
testTable15 = np.genfromtxt(str(getPackageDir('sims_catUtils') +
'/python/lsst/sims/catUtils/IGM/igm_tables/' +
'MeanLookupTable_zSource1.5.tbl.gz'))
np.testing.assert_equal(testTable15, testIGM.meanLookups['1.5'])
# Test output by making sure that an incoming sed
# with flambda = 1.0 everywhere will return the
# transmission values of the lookup table as its
# flambda output
testSed.setSED(testSed.wavelen, flambda=np.ones(len(testSed.wavelen)))
testIGM.applyIGM(1.5, testSed)
testTable15Above300 = testTable15[np.where(testTable15[:, 0] >= 300.0)]
testSed.resampleSED(wavelen_match = testTable15Above300[:, 0])
np.testing.assert_allclose(testTable15Above300[:, 1],
testSed.flambda, 1e-4)
class uncertaintyUnitTest(unittest.TestCase):
"""
Test the calculation of photometric uncertainties
"""
def setUp(self):
starName = os.path.join(lsst.utils.getPackageDir('sims_sed_library'),
defaultSpecMap['km20_5750.fits_g40_5790'])
self.starSED = Sed()
self.starSED.readSED_flambda(starName)
imsimband = Bandpass()
imsimband.imsimBandpass()
fNorm = self.starSED.calcFluxNorm(22.0, imsimband)
self.starSED.multiplyFluxNorm(fNorm)
self.totalBandpasses = []
self.hardwareBandpasses = []
componentList = [
'detector.dat', 'm1.dat', 'm2.dat', 'm3.dat', 'lens1.dat',
'lens2.dat', 'lens3.dat'
]
hardwareComponents = []
for c in componentList:
hardwareComponents.append(
os.path.join(lsst.utils.getPackageDir('throughputs'),
'baseline', c))
self.bandpasses = ['u', 'g', 'r', 'i', 'z', 'y']
for b in self.bandpasses:
filterName = os.path.join(lsst.utils.getPackageDir('throughputs'),
'baseline', 'filter_%s.dat' % b)
components = hardwareComponents + [filterName]
bandpassDummy = Bandpass()
bandpassDummy.readThroughputList(components)
self.hardwareBandpasses.append(bandpassDummy)
components = components + [
os.path.join(lsst.utils.getPackageDir('throughputs'),
'baseline', 'atmos.dat')
]
bandpassDummy = Bandpass()
bandpassDummy.readThroughputList(components)
self.totalBandpasses.append(bandpassDummy)
def tearDown(self):
del self.starSED
del self.bandpasses
del self.hardwareBandpasses
del self.totalBandpasses
def testUncertaintyExceptions(self):
"""
Test that calcSNR_m5 raises exceptions when it needs to
"""
totalDict, hardwareDict = BandpassDict.loadBandpassesFromFiles()
magnitudes = numpy.array([22.0, 23.0, 24.0, 25.0, 26.0, 27.0])
shortMagnitudes = numpy.array([22.0])
photParams = PhotometricParameters()
shortGamma = numpy.array([1.0, 1.0])
self.assertRaises(RuntimeError, calcSNR_m5, magnitudes,
totalDict.values(), shortMagnitudes, photParams)
self.assertRaises(RuntimeError, calcSNR_m5, shortMagnitudes,
totalDict.values(), magnitudes, photParams)
self.assertRaises(RuntimeError,
calcSNR_m5,
magnitudes,
totalDict.values(),
magnitudes,
photParams,
gamma=shortGamma)
snr, gg = calcSNR_m5(magnitudes, totalDict.values(), magnitudes,
photParams)
def testSignalToNoise(self):
"""
Test that calcSNR_m5 and calcSNR_sed give similar results
"""
defaults = LSSTdefaults()
photParams = PhotometricParameters()
totalDict, hardwareDict = BandpassDict.loadBandpassesFromFiles()
skySED = Sed()
skySED.readSED_flambda(
os.path.join(lsst.utils.getPackageDir('throughputs'), 'baseline',
'darksky.dat'))
m5 = []
for filt in totalDict:
m5.append(
calcM5(skySED,
totalDict[filt],
hardwareDict[filt],
photParams,
seeing=defaults.seeing(filt)))
sedDir = lsst.utils.getPackageDir('sims_sed_library')
sedDir = os.path.join(sedDir, 'starSED', 'kurucz')
fileNameList = os.listdir(sedDir)
numpy.random.seed(42)
offset = numpy.random.random_sample(len(fileNameList)) * 2.0
for ix, name in enumerate(fileNameList):
if ix > 100:
break
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, name))
ff = spectrum.calcFluxNorm(m5[2] - offset[ix],
totalDict.values()[2])
spectrum.multiplyFluxNorm(ff)
magList = []
controlList = []
magList = []
for filt in totalDict:
controlList.append(
calcSNR_sed(spectrum, totalDict[filt], skySED,
hardwareDict[filt], photParams,
defaults.seeing(filt)))
magList.append(spectrum.calcMag(totalDict[filt]))
testList, gammaList = calcSNR_m5(numpy.array(magList),
numpy.array(totalDict.values()),
numpy.array(m5), photParams)
for tt, cc in zip(controlList, testList):
msg = '%e != %e ' % (tt, cc)
self.assertTrue(numpy.abs(tt / cc - 1.0) < 0.001, msg=msg)
def testSystematicUncertainty(self):
"""
Test that systematic uncertainty is added correctly.
"""
sigmaSys = 0.002
m5 = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams = PhotometricParameters(sigmaSys=sigmaSys)
bandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
obs_metadata = ObservationMetaData(unrefractedRA=23.0,
unrefractedDec=45.0,
m5=m5,
bandpassName=self.bandpasses)
magnitudes = bandpassDict.magListForSed(self.starSED)
skySeds = []
for i in range(len(self.bandpasses)):
skyDummy = Sed()
skyDummy.readSED_flambda(
os.path.join(lsst.utils.getPackageDir('throughputs'),
'baseline', 'darksky.dat'))
normalizedSkyDummy = setM5(obs_metadata.m5[self.bandpasses[i]],
skyDummy,
self.totalBandpasses[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(
self.bandpasses[i]),
photParams=PhotometricParameters())
skySeds.append(normalizedSkyDummy)
for i in range(len(self.bandpasses)):
snr = calcSNR_sed(self.starSED,
self.totalBandpasses[i],
skySeds[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(self.bandpasses[i]),
photParams=PhotometricParameters())
testSNR, gamma = calcSNR_m5(
numpy.array([magnitudes[i]]), [self.totalBandpasses[i]],
numpy.array([m5[i]]),
photParams=PhotometricParameters(sigmaSys=0.0))
self.assertAlmostEqual(snr, testSNR[0], 10, msg = 'failed on calcSNR_m5 test %e != %e ' \
% (snr, testSNR[0]))
control = numpy.sqrt(
numpy.power(magErrorFromSNR(testSNR), 2) +
numpy.power(sigmaSys, 2))
def testNoSystematicUncertainty(self):
"""
Test that systematic uncertainty is handled correctly when set to None.
"""
m5 = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams = PhotometricParameters(sigmaSys=0.0)
bandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
obs_metadata = ObservationMetaData(unrefractedRA=23.0,
unrefractedDec=45.0,
m5=m5,
bandpassName=self.bandpasses)
magnitudes = bandpassDict.magListForSed(self.starSED)
skySeds = []
for i in range(len(self.bandpasses)):
skyDummy = Sed()
skyDummy.readSED_flambda(
os.path.join(lsst.utils.getPackageDir('throughputs'),
'baseline', 'darksky.dat'))
normalizedSkyDummy = setM5(obs_metadata.m5[self.bandpasses[i]],
skyDummy,
self.totalBandpasses[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(
self.bandpasses[i]),
photParams=PhotometricParameters())
skySeds.append(normalizedSkyDummy)
for i in range(len(self.bandpasses)):
snr = calcSNR_sed(self.starSED,
self.totalBandpasses[i],
skySeds[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(self.bandpasses[i]),
photParams=PhotometricParameters())
testSNR, gamma = calcSNR_m5(
numpy.array([magnitudes[i]]), [self.totalBandpasses[i]],
numpy.array([m5[i]]),
photParams=PhotometricParameters(sigmaSys=0.0))
self.assertAlmostEqual(snr, testSNR[0], 10, msg = 'failed on calcSNR_m5 test %e != %e ' \
% (snr, testSNR[0]))
class sprinkler():
def __init__(self, catsim_cat, om10_cat='twinkles_tdcLenses.fits', density_param = 1.):
"""
Input:
catsim_cat:
The results array from an instance catalog.
density_param:
A float between 0. and 1.0 that determines the fraction of eligible agn objects that become lensed.
Output:
updated_catalog:
A new results array with lens systems added.
"""
self.catalog = catsim_cat
# ****** THIS ASSUMES THAT THE ENVIRONMENT VARIABLE OM10_DIR IS SET *******
lensdb = om10.DB(catalog=om10_cat)
self.lenscat = lensdb.lenses.copy()
self.density_param = density_param
self.bandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames=['i'])
specFileStart = 'Burst'
for key, val in sorted(SpecMap.subdir_map.iteritems()):
if re.match(key, specFileStart):
galSpecDir = str(val)
galDir = str(getPackageDir('sims_sed_library') + '/' + galSpecDir + '/')
self.LRG_name = 'Burst.25E09.1Z.spec'
self.LRG = Sed()
self.LRG.readSED_flambda(str(galDir + self.LRG_name))
#return
def sprinkle(self):
# Define a list that we can write out to a text file
lenslines = []
# For each galaxy in the catsim catalog
updated_catalog = self.catalog.copy()
print "Running sprinkler. Catalog Length: ", len(self.catalog)
for rowNum, row in enumerate(self.catalog):
if rowNum == 100 or rowNum % 100000==0:
print "Gone through ", rowNum, " lines of catalog."
if not np.isnan(row['galaxyAgn_magNorm']):
candidates = self.find_lens_candidates(row['galaxyAgn_redshift'])
varString = json.loads(row['galaxyAgn_varParamStr'])
varString['pars']['t0_mjd'] = 59300.0
row['galaxyAgn_varParamStr'] = json.dumps(varString)
np.random.seed(row['galtileid'] % (2^32 -1))
pick_value = np.random.uniform()
# If there aren't any lensed sources at this redshift from OM10 move on the next object
if ((len(candidates) > 0) and (pick_value <= self.density_param)):
# Randomly choose one the lens systems
# (can decide with or without replacement)
newlens = np.random.choice(candidates)
# Append the lens galaxy
# For each image, append the lens images
for i in range(newlens['NIMG']):
lensrow = row.copy()
# XIMG and YIMG are in arcseconds
# raPhSim and decPhoSim are in radians
#Shift all parts of the lensed object, not just its agn part
for lensPart in ['galaxyBulge', 'galaxyDisk', 'galaxyAgn']:
lensrow[str(lensPart + '_raJ2000')] += np.radians(newlens['XIMG'][i]/(np.cos(np.radians(lensrow[str(lensPart + '_decJ2000')]))*3600.))
lensrow[str(lensPart + '_decJ2000')] += np.radians(newlens['YIMG'][i]/3600.)
mag_adjust = 2.5*np.log10(np.abs(newlens['MAG'][i]))
lensrow['galaxyAgn_magNorm'] -= mag_adjust
varString = json.loads(lensrow['galaxyAgn_varParamStr'])
varString['pars']['t0Delay'] = newlens['DELAY'][i]
varString['varMethodName'] = 'applyAgnTimeDelay'
lensrow['galaxyAgn_varParamStr'] = json.dumps(varString)
lensrow['galaxyDisk_majorAxis'] = 0.0
lensrow['galaxyDisk_minorAxis'] = 0.0
lensrow['galaxyDisk_positionAngle'] = 0.0
lensrow['galaxyDisk_internalAv'] = 0.0
lensrow['galaxyDisk_magNorm'] = np.nan
lensrow['galaxyDisk_sedFilename'] = None
lensrow['galaxyBulge_majorAxis'] = 0.0
lensrow['galaxyBulge_minorAxis'] = 0.0
lensrow['galaxyBulge_positionAngle'] = 0.0
lensrow['galaxyBulge_internalAv'] = 0.0
lensrow['galaxyBulge_magNorm'] = np.nan
lensrow['galaxyBulge_sedFilename'] = None
lensrow['galaxyBulge_redshift'] = newlens['ZSRC']
lensrow['galaxyDisk_redshift'] = newlens['ZSRC']
lensrow['galaxyAgn_redshift'] = newlens['ZSRC']
#To get back twinklesID in lens catalog from phosim catalog id number
#just use np.right_shift(phosimID-28, 10). Take the floor of the last
#3 numbers to get twinklesID in the twinkles lens catalog and the remainder is
#the image number minus 1.
lensrow['galtileid'] = (lensrow['galtileid']*1000 +
newlens['twinklesID']*4 + i)
updated_catalog = np.append(updated_catalog, lensrow)
#Now manipulate original entry to be the lens galaxy with desired properties
#Start by deleting Disk and AGN properties
if not np.isnan(row['galaxyDisk_magNorm']):
row['galaxyDisk_majorAxis'] = 0.0
row['galaxyDisk_minorAxis'] = 0.0
row['galaxyDisk_positionAngle'] = 0.0
row['galaxyDisk_internalAv'] = 0.0
row['galaxyDisk_magNorm'] = np.nan
row['galaxyDisk_sedFilename'] = None
row['galaxyAgn_magNorm'] = np.nan
row['galaxyAgn_sedFilename'] = None
#Now insert desired Bulge properties
row['galaxyBulge_sedFilename'] = self.LRG_name
row['galaxyBulge_redshift'] = newlens['ZLENS']
row['galaxyDisk_redshift'] = newlens['ZLENS']
row['galaxyAgn_redshift'] = newlens['ZLENS']
row['galaxyBulge_magNorm'] = matchBase().calcMagNorm([newlens['APMAG_I']], self.LRG, self.bandpassDict) #Changed from i band to imsimband
newlens['REFF'] = 1.0 #Hard coded for now. See issue in OM10 github.
row['galaxyBulge_majorAxis'] = radiansFromArcsec(newlens['REFF'])
row['galaxyBulge_minorAxis'] = radiansFromArcsec(newlens['REFF'] * (1 - newlens['ELLIP']))
#Convert orientation angle to west of north from east of north by *-1.0 and convert to radians
row['galaxyBulge_positionAngle'] = newlens['PHIE']*(-1.0)*np.pi/180.0
#Replace original entry with new entry
updated_catalog[rowNum] = row
return updated_catalog
def find_lens_candidates(self, galz):
# search the OM10 catalog for all sources +- 0.05 in redshift from the catsim source
w = np.where(np.abs(self.lenscat['ZSRC'] - galz) <= 0.05)[0]
lens_candidates = self.lenscat[w]
return lens_candidates
def update_catsim(self):
# Remove the catsim object
# Add lensed images to the catsim given source brightness and magnifications
# Add lens galaxy to catsim
return
def catsim_to_phosim(self):
# Pass this catsim to phosim to make images
return
def read_asteroids_reflectance(dataDir='.'):
# Read the sun's spectrum.
sun = Sed()
sun.readSED_flambda('kurucz_sun')
# Read the asteroid reflectance spectra.
allfiles = os.listdir(dataDir)
asteroidDtype = numpy.dtype([
('wavelength', numpy.float),
('A', numpy.float),
('A_sig', numpy.float),
('B', numpy.float),
('B_sig', numpy.float),
('C', numpy.float),
('C_sig', numpy.float),
('Cb', numpy.float),
('Cb_sig', numpy.float),
('Cg', numpy.float),
('Cg_sig', numpy.float),
('Cgh', numpy.float),
('Cgh_sig', numpy.float),
('Ch', numpy.float),
('Ch_sig', numpy.float),
('D', numpy.float),
('D_sig', numpy.float),
('K', numpy.float),
('K_sig', numpy.float),
('L', numpy.float),
('L_sig', numpy.float),
('O', numpy.float),
('O_sig', numpy.float),
('Q', numpy.float),
('Q_sig', numpy.float),
('R', numpy.float),
('R_sig', numpy.float),
('S', numpy.float),
('S_sig', numpy.float),
('Sa', numpy.float),
('Sa_sig', numpy.float),
('Sq', numpy.float),
('Sq_sig', numpy.float),
('Sr', numpy.float),
('Sr_sig', numpy.float),
('Sv', numpy.float),
('Sv_sig', numpy.float),
('T', numpy.float),
('T_sig', numpy.float),
('V', numpy.float),
('V_sig', numpy.float),
('X', numpy.float),
('X_sig', numpy.float),
('Xc', numpy.float),
('Xc_sig', numpy.float),
('Xe', numpy.float),
('Xe_sig', numpy.float),
('Xk', numpy.float),
('Xk_sig', numpy.float),
])
data = numpy.loadtxt(os.path.join(dataDir, 'meanspectra.tab'),
dtype=asteroidDtype)
data['wavelength'] *= 1000.0 #because spectra are in microns
wavelen_step = min(
numpy.diff(data['wavelength']).min(),
numpy.diff(sun.wavelen).min())
wavelen = numpy.arange(sun.wavelen[0], data['wavelength'][-1],
wavelen_step)
ast_reflect = {}
for a in data.dtype.names:
if a == 'wavelength' or a[-3:] == 'sig':
continue
# Read the basic reflectance data
ast_reflect[a] = Sed(wavelen=data['wavelength'], flambda=data[a])
# And now add an extrapolation to the blue end.
# Binzel cuts off at 450nm.
condition = ((ast_reflect[a].wavelen >= 450) &
(ast_reflect[a].wavelen < 700))
x = ast_reflect[a].wavelen[condition]
y = ast_reflect[a].flambda[condition]
p = numpy.polyfit(x, y, deg=2)
condition = (wavelen < 450)
flambda = numpy.zeros(len(wavelen), 'float')
interpolated = numpy.polyval(p, wavelen[condition])
flambda[condition] = [ii if ii > 0.0 else 0.0 for ii in interpolated]
condition = (wavelen >= 450)
flambda[condition] = numpy.interp(wavelen[condition],
ast_reflect[a].wavelen,
ast_reflect[a].flambda)
ast_reflect[a] = Sed(wavelen, flambda)
ast = {}
for a in ast_reflect:
ast[a] = sun.multiplySED(ast_reflect[a], wavelen_step=wavelen_step)
for a in ast:
name = a + '.dat'
normalizedSed = Sed(wavelen=ast[a].wavelen, flambda=ast[a].flambda)
norm = numpy.interp(500.0, normalizedSed.wavelen,
normalizedSed.flambda)
normalizedSed.multiplyFluxNorm(1.0 / norm)
normalizedSed.writeSED(
name,
print_header='21 April 2015; normalized to flambda=1 at 500nm')
return ast_reflect, sun, ast
class sprinkler():
def __init__(self, catsim_cat, om10_cat='twinkles_lenses_v2.fits',
density_param=1.):
"""
Parameters
----------
catsim_cat: catsim catalog
The results array from an instance catalog.
om10_cat: optional, defaults to 'twinkles_tdc_rung4.fits
fits file with OM10 catalog
density_param: `np.float`, optioanl, defaults to 1.0
the fraction of eligible agn objects that become lensed and should
be between 0.0 and 1.0.
Returns
-------
updated_catalog:
A new results array with lens systems added.
"""
twinklesDir = getPackageDir('Twinkles')
om10_cat = os.path.join(twinklesDir, 'data', om10_cat)
self.catalog = catsim_cat
# ****** THIS ASSUMES THAT THE ENVIRONMENT VARIABLE OM10_DIR IS SET *******
lensdb = om10.DB(catalog=om10_cat)
self.lenscat = lensdb.lenses.copy()
self.density_param = density_param
self.bandpassDict = BandpassDict.loadTotalBandpassesFromFiles(bandpassNames=['i'])
specFileStart = 'Burst'
for key, val in sorted(iteritems(SpecMap.subdir_map)):
if re.match(key, specFileStart):
galSpecDir = str(val)
galDir = str(getPackageDir('sims_sed_library') + '/' + galSpecDir + '/')
self.LRG_name = 'Burst.25E09.1Z.spec'
self.LRG = Sed()
self.LRG.readSED_flambda(str(galDir + self.LRG_name))
#return
#Calculate imsimband magnitudes of source galaxies for matching
agn_sed = Sed()
agn_fname = str(getPackageDir('sims_sed_library') + '/agnSED/agn.spec.gz')
agn_sed.readSED_flambda(agn_fname)
src_iband = self.lenscat['MAGI_IN']
self.src_mag_norm = []
for src in src_iband:
self.src_mag_norm.append(matchBase().calcMagNorm([src],
agn_sed,
self.bandpassDict))
#self.src_mag_norm = matchBase().calcMagNorm(src_iband,
# [agn_sed]*len(src_iband),
# self.bandpassDict)
def sprinkle(self):
# Define a list that we can write out to a text file
lenslines = []
# For each galaxy in the catsim catalog
updated_catalog = self.catalog.copy()
print("Running sprinkler. Catalog Length: ", len(self.catalog))
for rowNum, row in enumerate(self.catalog):
if rowNum == 100 or rowNum % 100000==0:
print("Gone through ", rowNum, " lines of catalog.")
if not np.isnan(row['galaxyAgn_magNorm']):
candidates = self.find_lens_candidates(row['galaxyAgn_redshift'],
row['galaxyAgn_magNorm'])
varString = json.loads(row['galaxyAgn_varParamStr'])
varString['pars']['t0_mjd'] = 59300.0
row['galaxyAgn_varParamStr'] = json.dumps(varString)
np.random.seed(row['galtileid'] % (2^32 -1))
pick_value = np.random.uniform()
# If there aren't any lensed sources at this redshift from OM10 move on the next object
if ((len(candidates) > 0) and (pick_value <= self.density_param)):
# Randomly choose one the lens systems
# (can decide with or without replacement)
# Sort first to make sure the same choice is made every time
candidates = candidates[np.argsort(candidates['twinklesId'])]
newlens = np.random.choice(candidates)
# Append the lens galaxy
# For each image, append the lens images
for i in range(newlens['NIMG']):
lensrow = row.copy()
# XIMG and YIMG are in arcseconds
# raPhSim and decPhoSim are in radians
#Shift all parts of the lensed object, not just its agn part
for lensPart in ['galaxyBulge', 'galaxyDisk', 'galaxyAgn']:
lens_ra = lensrow[str(lensPart+'_raJ2000')]
lens_dec = lensrow[str(lensPart+'_decJ2000')]
delta_ra = np.radians(newlens['XIMG'][i] / 3600.0) / np.cos(lens_dec)
delta_dec = np.radians(newlens['YIMG'][i] / 3600.0)
lensrow[str(lensPart + '_raJ2000')] = lens_ra + delta_ra
lensrow[str(lensPart + '_decJ2000')] = lens_dec + delta_dec
mag_adjust = 2.5*np.log10(np.abs(newlens['MAG'][i]))
lensrow['galaxyAgn_magNorm'] -= mag_adjust
varString = json.loads(lensrow['galaxyAgn_varParamStr'])
varString['pars']['t0Delay'] = newlens['DELAY'][i]
varString['varMethodName'] = 'applyAgnTimeDelay'
lensrow['galaxyAgn_varParamStr'] = json.dumps(varString)
lensrow['galaxyDisk_majorAxis'] = 0.0
lensrow['galaxyDisk_minorAxis'] = 0.0
lensrow['galaxyDisk_positionAngle'] = 0.0
lensrow['galaxyDisk_internalAv'] = 0.0
lensrow['galaxyDisk_magNorm'] = np.nan
lensrow['galaxyDisk_sedFilename'] = None
lensrow['galaxyBulge_majorAxis'] = 0.0
lensrow['galaxyBulge_minorAxis'] = 0.0
lensrow['galaxyBulge_positionAngle'] = 0.0
lensrow['galaxyBulge_internalAv'] = 0.0
lensrow['galaxyBulge_magNorm'] = np.nan
lensrow['galaxyBulge_sedFilename'] = None
lensrow['galaxyBulge_redshift'] = newlens['ZSRC']
lensrow['galaxyDisk_redshift'] = newlens['ZSRC']
lensrow['galaxyAgn_redshift'] = newlens['ZSRC']
#To get back twinklesID in lens catalog from phosim catalog id number
#just use np.right_shift(phosimID-28, 10). Take the floor of the last
#3 numbers to get twinklesID in the twinkles lens catalog and the remainder is
#the image number minus 1.
lensrow['galtileid'] = (lensrow['galtileid']*10000 +
newlens['twinklesId']*4 + i)
updated_catalog = np.append(updated_catalog, lensrow)
#Now manipulate original entry to be the lens galaxy with desired properties
#Start by deleting Disk and AGN properties
if not np.isnan(row['galaxyDisk_magNorm']):
row['galaxyDisk_majorAxis'] = 0.0
row['galaxyDisk_minorAxis'] = 0.0
row['galaxyDisk_positionAngle'] = 0.0
row['galaxyDisk_internalAv'] = 0.0
row['galaxyDisk_magNorm'] = np.nan
row['galaxyDisk_sedFilename'] = None
row['galaxyAgn_magNorm'] = np.nan
row['galaxyAgn_sedFilename'] = None
#Now insert desired Bulge properties
row['galaxyBulge_sedFilename'] = newlens['lens_sed']
row['galaxyBulge_redshift'] = newlens['ZLENS']
row['galaxyDisk_redshift'] = newlens['ZLENS']
row['galaxyAgn_redshift'] = newlens['ZLENS']
row['galaxyBulge_magNorm'] = matchBase().calcMagNorm([newlens['APMAG_I']], self.LRG, self.bandpassDict) #Changed from i band to imsimband
row['galaxyBulge_majorAxis'] = radiansFromArcsec(newlens['REFF'] / np.sqrt(1 - newlens['ELLIP']))
row['galaxyBulge_minorAxis'] = radiansFromArcsec(newlens['REFF'] * np.sqrt(1 - newlens['ELLIP']))
#Convert orientation angle to west of north from east of north by *-1.0 and convert to radians
row['galaxyBulge_positionAngle'] = newlens['PHIE']*(-1.0)*np.pi/180.0
#Replace original entry with new entry
updated_catalog[rowNum] = row
return updated_catalog
def find_lens_candidates(self, galz, gal_mag):
# search the OM10 catalog for all sources +- 0.1 dex in redshift
# and within .25 mags of the CATSIM source
w = np.where((np.abs(np.log10(self.lenscat['ZSRC']) - np.log10(galz)) <= 0.1) &
(np.abs(self.src_mag_norm - gal_mag) <= .25))[0]
lens_candidates = self.lenscat[w]
return lens_candidates
def update_catsim(self):
# Remove the catsim object
# Add lensed images to the catsim given source brightness and magnifications
# Add lens galaxy to catsim
return
def catsim_to_phosim(self):
# Pass this catsim to phosim to make images
return
def testAlternateBandpassesGalaxies(self):
"""
the same as testAlternateBandpassesStars, but for galaxies
"""
obs_metadata_pointed = ObservationMetaData(mjd=50000.0,
boundType='circle',
pointingRA=0.0, pointingDec=0.0,
boundLength=10.0)
dtype = np.dtype([('galid', np.int),
('ra', np.float),
('dec', np.float),
('uTotal', np.float),
('gTotal', np.float),
('rTotal', np.float),
('iTotal', np.float),
('zTotal', np.float),
('uBulge', np.float),
('gBulge', np.float),
('rBulge', np.float),
('iBulge', np.float),
('zBulge', np.float),
('uDisk', np.float),
('gDisk', np.float),
('rDisk', np.float),
('iDisk', np.float),
('zDisk', np.float),
('uAgn', np.float),
('gAgn', np.float),
('rAgn', np.float),
('iAgn', np.float),
('zAgn', np.float),
('bulgeName', str, 200),
('bulgeNorm', np.float),
('bulgeAv', np.float),
('diskName', str, 200),
('diskNorm', np.float),
('diskAv', np.float),
('agnName', str, 200),
('agnNorm', np.float),
('redshift', np.float)])
test_cat = cartoonGalaxies(self.galaxy, obs_metadata=obs_metadata_pointed)
with lsst.utils.tests.getTempFilePath('.txt') as catName:
test_cat.write_catalog(catName)
catData = np.genfromtxt(catName, dtype=dtype, delimiter=', ')
self.assertGreater(len(catData), 0)
cartoonDir = getPackageDir('sims_photUtils')
cartoonDir = os.path.join(cartoonDir, 'tests', 'cartoonSedTestData')
sedDir = getPackageDir('sims_sed_library')
testBandpasses = {}
keys = ['u', 'g', 'r', 'i', 'z']
for kk in keys:
testBandpasses[kk] = Bandpass()
testBandpasses[kk].readThroughput(os.path.join(cartoonDir, "test_bandpass_%s.dat" % kk))
imsimBand = Bandpass()
imsimBand.imsimBandpass()
specMap = defaultSpecMap
ct = 0
for line in catData:
bulgeMagList = []
diskMagList = []
agnMagList = []
if line['bulgeName'] == 'None':
for bp in keys:
np.testing.assert_equal(line['%sBulge' % bp], np.NaN)
bulgeMagList.append(np.NaN)
else:
ct += 1
dummySed = Sed()
dummySed.readSED_flambda(os.path.join(sedDir, specMap[line['bulgeName']]))
fnorm = dummySed.calcFluxNorm(line['bulgeNorm'], imsimBand)
dummySed.multiplyFluxNorm(fnorm)
a_int, b_int = dummySed.setupCCM_ab()
dummySed.addDust(a_int, b_int, A_v=line['bulgeAv'])
dummySed.redshiftSED(line['redshift'], dimming=True)
dummySed.resampleSED(wavelen_match=testBandpasses['u'].wavelen)
for bpName in keys:
mag = dummySed.calcMag(testBandpasses[bpName])
self.assertAlmostEqual(mag, line['%sBulge' % bpName], 10)
bulgeMagList.append(mag)
if line['diskName'] == 'None':
for bp in keys:
np.assert_equal(line['%sDisk' % bp], np.NaN)
diskMagList.append(np.NaN)
else:
ct += 1
dummySed = Sed()
dummySed.readSED_flambda(os.path.join(sedDir, specMap[line['diskName']]))
fnorm = dummySed.calcFluxNorm(line['diskNorm'], imsimBand)
dummySed.multiplyFluxNorm(fnorm)
a_int, b_int = dummySed.setupCCM_ab()
dummySed.addDust(a_int, b_int, A_v=line['diskAv'])
dummySed.redshiftSED(line['redshift'], dimming=True)
dummySed.resampleSED(wavelen_match=testBandpasses['u'].wavelen)
for bpName in keys:
mag = dummySed.calcMag(testBandpasses[bpName])
self.assertAlmostEqual(mag, line['%sDisk' % bpName], 10)
diskMagList.append(mag)
if line['agnName'] == 'None':
for bp in keys:
np.testing.assert_true(line['%sAgn' % bp], np.NaN)
agnMagList.append(np.NaN)
else:
ct += 1
dummySed = Sed()
dummySed.readSED_flambda(os.path.join(sedDir, specMap[line['agnName']]))
fnorm = dummySed.calcFluxNorm(line['agnNorm'], imsimBand)
dummySed.multiplyFluxNorm(fnorm)
dummySed.redshiftSED(line['redshift'], dimming=True)
dummySed.resampleSED(wavelen_match=testBandpasses['u'].wavelen)
for bpName in keys:
mag = dummySed.calcMag(testBandpasses[bpName])
self.assertAlmostEqual(mag, line['%sAgn' % bpName], 10)
agnMagList.append(mag)
totalMags = PhotometryGalaxies().sum_magnitudes(bulge=np.array(bulgeMagList),
disk=np.array(diskMagList),
agn=np.array(agnMagList))
for testMag, bpName in zip(totalMags, keys):
if np.isnan(line['%sTotal' % bpName]):
np.testing.assert_equal(testMag, np.NaN)
else:
self.assertAlmostEqual(testMag, line['%sTotal' % bpName], 10)
self.assertGreater(ct, 0)
class sprinkler():
def __init__(self,
catsim_cat,
om10_cat='twinkles_tdc_rung4.fits',
density_param=1.):
"""
Input:
catsim_cat:
The results array from an instance catalog.
density_param:
A float between 0. and 1.0 that determines the fraction of eligible agn objects that become lensed.
Output:
updated_catalog:
A new results array with lens systems added.
"""
self.catalog = catsim_cat
# ****** THIS ASSUMES THAT THE ENVIRONMENT VARIABLE OM10_DIR IS SET *******
lensdb = om10.DB(catalog=om10_cat)
self.lenscat = lensdb.lenses.copy()
self.density_param = density_param
self.bandpassDict = BandpassDict.loadTotalBandpassesFromFiles(
bandpassNames=['i'])
specFileStart = 'Burst'
for key, val in sorted(iteritems(SpecMap.subdir_map)):
if re.match(key, specFileStart):
galSpecDir = str(val)
galDir = str(
getPackageDir('sims_sed_library') + '/' + galSpecDir + '/')
self.LRG_name = 'Burst.25E09.1Z.spec'
self.LRG = Sed()
self.LRG.readSED_flambda(str(galDir + self.LRG_name))
#return
def sprinkle(self):
# Define a list that we can write out to a text file
lenslines = []
# For each galaxy in the catsim catalog
updated_catalog = self.catalog.copy()
print("Running sprinkler. Catalog Length: ", len(self.catalog))
for rowNum, row in enumerate(self.catalog):
if rowNum == 100 or rowNum % 100000 == 0:
print("Gone through ", rowNum, " lines of catalog.")
if not np.isnan(row['galaxyAgn_magNorm']):
candidates = self.find_lens_candidates(
row['galaxyAgn_redshift'])
varString = json.loads(row['galaxyAgn_varParamStr'])
varString['pars']['t0_mjd'] = 59300.0
row['galaxyAgn_varParamStr'] = json.dumps(varString)
np.random.seed(row['galtileid'] % (2 ^ 32 - 1))
pick_value = np.random.uniform()
# If there aren't any lensed sources at this redshift from OM10 move on the next object
if ((len(candidates) > 0)
and (pick_value <= self.density_param)):
# Randomly choose one the lens systems
# (can decide with or without replacement)
newlens = np.random.choice(candidates)
# Append the lens galaxy
# For each image, append the lens images
for i in range(newlens['NIMG']):
lensrow = row.copy()
# XIMG and YIMG are in arcseconds
# raPhSim and decPhoSim are in radians
#Shift all parts of the lensed object, not just its agn part
for lensPart in [
'galaxyBulge', 'galaxyDisk', 'galaxyAgn'
]:
lensrow[str(lensPart + '_raJ2000')] += np.radians(
newlens['XIMG'][i] / (np.cos(
np.radians(lensrow[str(lensPart +
'_decJ2000')])) *
3600.))
lensrow[str(lensPart + '_decJ2000')] += np.radians(
newlens['YIMG'][i] / 3600.)
mag_adjust = 2.5 * np.log10(np.abs(newlens['MAG'][i]))
lensrow['galaxyAgn_magNorm'] -= mag_adjust
varString = json.loads(
lensrow['galaxyAgn_varParamStr'])
varString['pars']['t0Delay'] = newlens['DELAY'][i]
varString['varMethodName'] = 'applyAgnTimeDelay'
lensrow['galaxyAgn_varParamStr'] = json.dumps(
varString)
lensrow['galaxyDisk_majorAxis'] = 0.0
lensrow['galaxyDisk_minorAxis'] = 0.0
lensrow['galaxyDisk_positionAngle'] = 0.0
lensrow['galaxyDisk_internalAv'] = 0.0
lensrow['galaxyDisk_magNorm'] = np.nan
lensrow['galaxyDisk_sedFilename'] = None
lensrow['galaxyBulge_majorAxis'] = 0.0
lensrow['galaxyBulge_minorAxis'] = 0.0
lensrow['galaxyBulge_positionAngle'] = 0.0
lensrow['galaxyBulge_internalAv'] = 0.0
lensrow['galaxyBulge_magNorm'] = np.nan
lensrow['galaxyBulge_sedFilename'] = None
lensrow['galaxyBulge_redshift'] = newlens['ZSRC']
lensrow['galaxyDisk_redshift'] = newlens['ZSRC']
lensrow['galaxyAgn_redshift'] = newlens['ZSRC']
#To get back twinklesID in lens catalog from phosim catalog id number
#just use np.right_shift(phosimID-28, 10). Take the floor of the last
#3 numbers to get twinklesID in the twinkles lens catalog and the remainder is
#the image number minus 1.
lensrow['galtileid'] = (lensrow['galtileid'] * 10000 +
newlens['twinklesId'] * 4 + i)
updated_catalog = np.append(updated_catalog, lensrow)
#Now manipulate original entry to be the lens galaxy with desired properties
#Start by deleting Disk and AGN properties
if not np.isnan(row['galaxyDisk_magNorm']):
row['galaxyDisk_majorAxis'] = 0.0
row['galaxyDisk_minorAxis'] = 0.0
row['galaxyDisk_positionAngle'] = 0.0
row['galaxyDisk_internalAv'] = 0.0
row['galaxyDisk_magNorm'] = np.nan
row['galaxyDisk_sedFilename'] = None
row['galaxyAgn_magNorm'] = np.nan
row['galaxyAgn_sedFilename'] = None
#Now insert desired Bulge properties
row['galaxyBulge_sedFilename'] = self.LRG_name
row['galaxyBulge_redshift'] = newlens['ZLENS']
row['galaxyDisk_redshift'] = newlens['ZLENS']
row['galaxyAgn_redshift'] = newlens['ZLENS']
row['galaxyBulge_magNorm'] = matchBase().calcMagNorm(
[newlens['APMAG_I']], self.LRG,
self.bandpassDict) #Changed from i band to imsimband
newlens[
'REFF'] = 1.0 #Hard coded for now. See issue in OM10 github.
row['galaxyBulge_majorAxis'] = radiansFromArcsec(
newlens['REFF'])
row['galaxyBulge_minorAxis'] = radiansFromArcsec(
newlens['REFF'] * (1 - newlens['ELLIP']))
#Convert orientation angle to west of north from east of north by *-1.0 and convert to radians
row['galaxyBulge_positionAngle'] = newlens['PHIE'] * (
-1.0) * np.pi / 180.0
#Replace original entry with new entry
updated_catalog[rowNum] = row
return updated_catalog
def find_lens_candidates(self, galz):
# search the OM10 catalog for all sources +- 0.05 in redshift from the catsim source
w = np.where(np.abs(self.lenscat['ZSRC'] - galz) <= 0.05)[0]
lens_candidates = self.lenscat[w]
return lens_candidates
def update_catsim(self):
# Remove the catsim object
# Add lensed images to the catsim given source brightness and magnifications
# Add lens galaxy to catsim
return
def catsim_to_phosim(self):
# Pass this catsim to phosim to make images
return
def read_asteroids_reflectance(dataDir='.'):
# Read the sun's spectrum.
sun = Sed()
sun.readSED_flambda('kurucz_sun')
# Read the asteroid reflectance spectra.
allfiles = os.listdir(dataDir)
asteroidDtype = numpy.dtype([
('wavelength', numpy.float),
('A', numpy.float),
('A_sig', numpy.float),
('B', numpy.float),
('B_sig', numpy.float),
('C', numpy.float),
('C_sig', numpy.float),
('Cb', numpy.float),
('Cb_sig', numpy.float),
('Cg', numpy.float),
('Cg_sig', numpy.float),
('Cgh', numpy.float),
('Cgh_sig', numpy.float),
('Ch', numpy.float),
('Ch_sig', numpy.float),
('D', numpy.float),
('D_sig', numpy.float),
('K', numpy.float),
('K_sig', numpy.float),
('L', numpy.float),
('L_sig', numpy.float),
('O', numpy.float),
('O_sig', numpy.float),
('Q', numpy.float),
('Q_sig', numpy.float),
('R', numpy.float),
('R_sig', numpy.float),
('S', numpy.float),
('S_sig', numpy.float),
('Sa', numpy.float),
('Sa_sig', numpy.float),
('Sq', numpy.float),
('Sq_sig', numpy.float),
('Sr', numpy.float),
('Sr_sig', numpy.float),
('Sv', numpy.float),
('Sv_sig', numpy.float),
('T', numpy.float),
('T_sig', numpy.float),
('V', numpy.float),
('V_sig', numpy.float),
('X', numpy.float),
('X_sig', numpy.float),
('Xc', numpy.float),
('Xc_sig', numpy.float),
('Xe', numpy.float),
('Xe_sig', numpy.float),
('Xk', numpy.float),
('Xk_sig', numpy.float),
])
data = numpy.loadtxt(os.path.join(dataDir,'meanspectra.tab'),
dtype = asteroidDtype)
data['wavelength'] *= 1000.0 #because spectra are in microns
wavelen_step = min(numpy.diff(data['wavelength']).min(), numpy.diff(sun.wavelen).min())
wavelen = numpy.arange(sun.wavelen[0], data['wavelength'][-1], wavelen_step)
ast_reflect = {}
for a in data.dtype.names:
if a == 'wavelength' or a[-3:] == 'sig':
continue
# Read the basic reflectance data
ast_reflect[a] = Sed(wavelen=data['wavelength'], flambda=data[a])
# And now add an extrapolation to the blue end.
# Binzel cuts off at 450nm.
condition = ((ast_reflect[a].wavelen >= 450) & (ast_reflect[a].wavelen < 700))
x = ast_reflect[a].wavelen[condition]
y = ast_reflect[a].flambda[condition]
p = numpy.polyfit(x, y, deg=2)
condition = (wavelen < 450)
flambda = numpy.zeros(len(wavelen), 'float')
interpolated = numpy.polyval(p, wavelen[condition])
flambda[condition] = [ii if ii > 0.0 else 0.0 for ii in interpolated]
condition = (wavelen >= 450)
flambda[condition] = numpy.interp(wavelen[condition], ast_reflect[a].wavelen, ast_reflect[a].flambda)
ast_reflect[a] = Sed(wavelen, flambda)
ast = {}
for a in ast_reflect:
ast[a] = sun.multiplySED(ast_reflect[a], wavelen_step=wavelen_step)
for a in ast:
name = a + '.dat'
normalizedSed = Sed(wavelen=ast[a].wavelen, flambda=ast[a].flambda)
norm = numpy.interp(500.0, normalizedSed.wavelen, normalizedSed.flambda)
normalizedSed.multiplyFluxNorm(1.0/norm)
normalizedSed.writeSED(name, print_header='21 April 2015; normalized to flambda=1 at 500nm')
return ast_reflect, sun, ast
class uncertaintyUnitTest(unittest.TestCase):
"""
Test the calculation of photometric uncertainties
"""
def setUp(self):
starName = os.path.join(lsst.utils.getPackageDir("sims_sed_library"), defaultSpecMap["km20_5750.fits_g40_5790"])
self.starSED = Sed()
self.starSED.readSED_flambda(starName)
imsimband = Bandpass()
imsimband.imsimBandpass()
fNorm = self.starSED.calcFluxNorm(22.0, imsimband)
self.starSED.multiplyFluxNorm(fNorm)
self.totalBandpasses = []
self.hardwareBandpasses = []
componentList = ["detector.dat", "m1.dat", "m2.dat", "m3.dat", "lens1.dat", "lens2.dat", "lens3.dat"]
hardwareComponents = []
for c in componentList:
hardwareComponents.append(os.path.join(lsst.utils.getPackageDir("throughputs"), "baseline", c))
self.bandpasses = ["u", "g", "r", "i", "z", "y"]
for b in self.bandpasses:
filterName = os.path.join(lsst.utils.getPackageDir("throughputs"), "baseline", "filter_%s.dat" % b)
components = hardwareComponents + [filterName]
bandpassDummy = Bandpass()
bandpassDummy.readThroughputList(components)
self.hardwareBandpasses.append(bandpassDummy)
components = components + [os.path.join(lsst.utils.getPackageDir("throughputs"), "baseline", "atmos.dat")]
bandpassDummy = Bandpass()
bandpassDummy.readThroughputList(components)
self.totalBandpasses.append(bandpassDummy)
def tearDown(self):
del self.starSED
del self.bandpasses
del self.hardwareBandpasses
del self.totalBandpasses
def testUncertaintyExceptions(self):
"""
Test that calcSNR_m5 raises exceptions when it needs to
"""
totalDict, hardwareDict = BandpassDict.loadBandpassesFromFiles()
magnitudes = numpy.array([22.0, 23.0, 24.0, 25.0, 26.0, 27.0])
shortMagnitudes = numpy.array([22.0])
photParams = PhotometricParameters()
shortGamma = numpy.array([1.0, 1.0])
self.assertRaises(RuntimeError, calcSNR_m5, magnitudes, totalDict.values(), shortMagnitudes, photParams)
self.assertRaises(RuntimeError, calcSNR_m5, shortMagnitudes, totalDict.values(), magnitudes, photParams)
self.assertRaises(
RuntimeError, calcSNR_m5, magnitudes, totalDict.values(), magnitudes, photParams, gamma=shortGamma
)
snr, gg = calcSNR_m5(magnitudes, totalDict.values(), magnitudes, photParams)
def testSignalToNoise(self):
"""
Test that calcSNR_m5 and calcSNR_sed give similar results
"""
defaults = LSSTdefaults()
photParams = PhotometricParameters()
totalDict, hardwareDict = BandpassDict.loadBandpassesFromFiles()
skySED = Sed()
skySED.readSED_flambda(os.path.join(lsst.utils.getPackageDir("throughputs"), "baseline", "darksky.dat"))
m5 = []
for filt in totalDict:
m5.append(calcM5(skySED, totalDict[filt], hardwareDict[filt], photParams, seeing=defaults.seeing(filt)))
sedDir = lsst.utils.getPackageDir("sims_sed_library")
sedDir = os.path.join(sedDir, "starSED", "kurucz")
fileNameList = os.listdir(sedDir)
numpy.random.seed(42)
offset = numpy.random.random_sample(len(fileNameList)) * 2.0
for ix, name in enumerate(fileNameList):
if ix > 100:
break
spectrum = Sed()
spectrum.readSED_flambda(os.path.join(sedDir, name))
ff = spectrum.calcFluxNorm(m5[2] - offset[ix], totalDict.values()[2])
spectrum.multiplyFluxNorm(ff)
magList = []
controlList = []
magList = []
for filt in totalDict:
controlList.append(
calcSNR_sed(
spectrum, totalDict[filt], skySED, hardwareDict[filt], photParams, defaults.seeing(filt)
)
)
magList.append(spectrum.calcMag(totalDict[filt]))
testList, gammaList = calcSNR_m5(
numpy.array(magList), numpy.array(totalDict.values()), numpy.array(m5), photParams
)
for tt, cc in zip(controlList, testList):
msg = "%e != %e " % (tt, cc)
self.assertTrue(numpy.abs(tt / cc - 1.0) < 0.001, msg=msg)
def testSystematicUncertainty(self):
"""
Test that systematic uncertainty is added correctly.
"""
sigmaSys = 0.002
m5 = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams = PhotometricParameters(sigmaSys=sigmaSys)
bandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
obs_metadata = ObservationMetaData(unrefractedRA=23.0, unrefractedDec=45.0, m5=m5, bandpassName=self.bandpasses)
magnitudes = bandpassDict.magListForSed(self.starSED)
skySeds = []
for i in range(len(self.bandpasses)):
skyDummy = Sed()
skyDummy.readSED_flambda(os.path.join(lsst.utils.getPackageDir("throughputs"), "baseline", "darksky.dat"))
normalizedSkyDummy = setM5(
obs_metadata.m5[self.bandpasses[i]],
skyDummy,
self.totalBandpasses[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(self.bandpasses[i]),
photParams=PhotometricParameters(),
)
skySeds.append(normalizedSkyDummy)
for i in range(len(self.bandpasses)):
snr = calcSNR_sed(
self.starSED,
self.totalBandpasses[i],
skySeds[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(self.bandpasses[i]),
photParams=PhotometricParameters(),
)
testSNR, gamma = calcSNR_m5(
numpy.array([magnitudes[i]]),
[self.totalBandpasses[i]],
numpy.array([m5[i]]),
photParams=PhotometricParameters(sigmaSys=0.0),
)
self.assertAlmostEqual(snr, testSNR[0], 10, msg="failed on calcSNR_m5 test %e != %e " % (snr, testSNR[0]))
control = numpy.sqrt(numpy.power(magErrorFromSNR(testSNR), 2) + numpy.power(sigmaSys, 2))
def testNoSystematicUncertainty(self):
"""
Test that systematic uncertainty is handled correctly when set to None.
"""
m5 = [23.5, 24.3, 22.1, 20.0, 19.5, 21.7]
photParams = PhotometricParameters(sigmaSys=0.0)
bandpassDict = BandpassDict.loadTotalBandpassesFromFiles()
obs_metadata = ObservationMetaData(unrefractedRA=23.0, unrefractedDec=45.0, m5=m5, bandpassName=self.bandpasses)
magnitudes = bandpassDict.magListForSed(self.starSED)
skySeds = []
for i in range(len(self.bandpasses)):
skyDummy = Sed()
skyDummy.readSED_flambda(os.path.join(lsst.utils.getPackageDir("throughputs"), "baseline", "darksky.dat"))
normalizedSkyDummy = setM5(
obs_metadata.m5[self.bandpasses[i]],
skyDummy,
self.totalBandpasses[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(self.bandpasses[i]),
photParams=PhotometricParameters(),
)
skySeds.append(normalizedSkyDummy)
for i in range(len(self.bandpasses)):
snr = calcSNR_sed(
self.starSED,
self.totalBandpasses[i],
skySeds[i],
self.hardwareBandpasses[i],
seeing=LSSTdefaults().seeing(self.bandpasses[i]),
photParams=PhotometricParameters(),
)
testSNR, gamma = calcSNR_m5(
numpy.array([magnitudes[i]]),
[self.totalBandpasses[i]],
numpy.array([m5[i]]),
photParams=PhotometricParameters(sigmaSys=0.0),
)
self.assertAlmostEqual(snr, testSNR[0], 10, msg="failed on calcSNR_m5 test %e != %e " % (snr, testSNR[0]))
def testAlternateBandpassesGalaxies(self):
"""
the same as testAlternateBandpassesStars, but for galaxies
"""
obs_metadata_pointed = ObservationMetaData(mjd=50000.0,
boundType='circle',
pointingRA=0.0,
pointingDec=0.0,
boundLength=10.0)
dtype = np.dtype([('galid', np.int), ('ra', np.float),
('dec', np.float), ('uTotal', np.float),
('gTotal', np.float), ('rTotal', np.float),
('iTotal', np.float), ('zTotal', np.float),
('uBulge', np.float), ('gBulge', np.float),
('rBulge', np.float), ('iBulge', np.float),
('zBulge', np.float), ('uDisk', np.float),
('gDisk', np.float), ('rDisk', np.float),
('iDisk', np.float), ('zDisk', np.float),
('uAgn', np.float), ('gAgn', np.float),
('rAgn', np.float), ('iAgn', np.float),
('zAgn', np.float), ('bulgeName', str, 200),
('bulgeNorm', np.float), ('bulgeAv', np.float),
('diskName', str, 200), ('diskNorm', np.float),
('diskAv', np.float), ('agnName', str, 200),
('agnNorm', np.float), ('redshift', np.float)])
test_cat = cartoonGalaxies(self.galaxy,
obs_metadata=obs_metadata_pointed)
with lsst.utils.tests.getTempFilePath('.txt') as catName:
test_cat.write_catalog(catName)
catData = np.genfromtxt(catName, dtype=dtype, delimiter=', ')
self.assertGreater(len(catData), 0)
cartoonDir = getPackageDir('sims_photUtils')
cartoonDir = os.path.join(cartoonDir, 'tests', 'cartoonSedTestData')
sedDir = getPackageDir('sims_sed_library')
testBandpasses = {}
keys = ['u', 'g', 'r', 'i', 'z']
for kk in keys:
testBandpasses[kk] = Bandpass()
testBandpasses[kk].readThroughput(
os.path.join(cartoonDir, "test_bandpass_%s.dat" % kk))
imsimBand = Bandpass()
imsimBand.imsimBandpass()
specMap = defaultSpecMap
ct = 0
for line in catData:
bulgeMagList = []
diskMagList = []
agnMagList = []
if line['bulgeName'] == 'None':
for bp in keys:
np.testing.assert_equal(line['%sBulge' % bp], np.NaN)
bulgeMagList.append(np.NaN)
else:
ct += 1
dummySed = Sed()
dummySed.readSED_flambda(
os.path.join(sedDir, specMap[line['bulgeName']]))
fnorm = dummySed.calcFluxNorm(line['bulgeNorm'], imsimBand)
dummySed.multiplyFluxNorm(fnorm)
a_int, b_int = dummySed.setupCCM_ab()
dummySed.addDust(a_int, b_int, A_v=line['bulgeAv'])
dummySed.redshiftSED(line['redshift'], dimming=True)
dummySed.resampleSED(wavelen_match=testBandpasses['u'].wavelen)
for bpName in keys:
mag = dummySed.calcMag(testBandpasses[bpName])
self.assertAlmostEqual(mag, line['%sBulge' % bpName], 10)
bulgeMagList.append(mag)
if line['diskName'] == 'None':
for bp in keys:
np.assert_equal(line['%sDisk' % bp], np.NaN)
diskMagList.append(np.NaN)
else:
ct += 1
dummySed = Sed()
dummySed.readSED_flambda(
os.path.join(sedDir, specMap[line['diskName']]))
fnorm = dummySed.calcFluxNorm(line['diskNorm'], imsimBand)
dummySed.multiplyFluxNorm(fnorm)
a_int, b_int = dummySed.setupCCM_ab()
dummySed.addDust(a_int, b_int, A_v=line['diskAv'])
dummySed.redshiftSED(line['redshift'], dimming=True)
dummySed.resampleSED(wavelen_match=testBandpasses['u'].wavelen)
for bpName in keys:
mag = dummySed.calcMag(testBandpasses[bpName])
self.assertAlmostEqual(mag, line['%sDisk' % bpName], 10)
diskMagList.append(mag)
if line['agnName'] == 'None':
for bp in keys:
np.testing.assert_true(line['%sAgn' % bp], np.NaN)
agnMagList.append(np.NaN)
else:
ct += 1
dummySed = Sed()
dummySed.readSED_flambda(
os.path.join(sedDir, specMap[line['agnName']]))
fnorm = dummySed.calcFluxNorm(line['agnNorm'], imsimBand)
dummySed.multiplyFluxNorm(fnorm)
dummySed.redshiftSED(line['redshift'], dimming=True)
dummySed.resampleSED(wavelen_match=testBandpasses['u'].wavelen)
for bpName in keys:
mag = dummySed.calcMag(testBandpasses[bpName])
self.assertAlmostEqual(mag, line['%sAgn' % bpName], 10)
agnMagList.append(mag)
totalMags = PhotometryGalaxies().sum_magnitudes(
bulge=np.array(bulgeMagList),
disk=np.array(diskMagList),
agn=np.array(agnMagList))
for testMag, bpName in zip(totalMags, keys):
if np.isnan(line['%sTotal' % bpName]):
np.testing.assert_equal(testMag, np.NaN)
else:
self.assertAlmostEqual(testMag, line['%sTotal' % bpName],
10)
self.assertGreater(ct, 0)
