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 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)