Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1from builtins import range 

2import os 

3import numpy as np 

4import unittest 

5import tempfile 

6 

7import lsst.utils.tests 

8from lsst.utils import getPackageDir 

9from lsst.sims.utils.CodeUtilities import sims_clean_up 

10from lsst.sims.catUtils.utils import makePhoSimTestDB 

11from lsst.sims.utils import ObservationMetaData 

12from lsst.sims.catalogs.definitions import InstanceCatalog 

13from lsst.sims.utils import defaultSpecMap 

14from lsst.sims.catUtils.utils import testStarsDBObj, testGalaxyTileDBObj 

15from lsst.sims.photUtils import Sed, Bandpass, LSSTdefaults, calcMagError_sed 

16from lsst.sims.photUtils import PhotometricParameters 

17from lsst.sims.photUtils.utils import setM5 

18from lsst.sims.catUtils.mixins import PhotometryStars, PhotometryGalaxies 

19 

20ROOT = os.path.abspath(os.path.dirname(__file__)) 

21 

22 

23def setup_module(module): 

24 lsst.utils.tests.init() 

25 

26 

27class testStarCatalog(InstanceCatalog, PhotometryStars): 

28 catalog_type = __file__ + 'test_star_catalog' 

29 column_outputs = ['raJ2000', 'decJ2000', 

30 'lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y', 

31 'sigma_lsst_u', 'sigma_lsst_g', 'sigma_lsst_r', 'sigma_lsst_i', 

32 'sigma_lsst_z', 'sigma_lsst_y', 'sedFilename', 'magNorm', 'galacticAv'] 

33 

34 

35class testGalaxyCatalog(InstanceCatalog, PhotometryGalaxies): 

36 catalog_type = __file__ + "test_galaxy_catalog" 

37 

38 column_outputs = ['raJ2000', 'decJ2000', 

39 'lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y', 

40 'uBulge', 'gBulge', 'rBulge', 'iBulge', 'zBulge', 'yBulge', 

41 'uDisk', 'gDisk', 'rDisk', 'iDisk', 'zDisk', 'yDisk', 

42 'uAgn', 'gAgn', 'rAgn', 'iAgn', 'zAgn', 'yAgn', 

43 'sigma_lsst_u', 'sigma_lsst_g', 'sigma_lsst_r', 'sigma_lsst_i', 

44 'sigma_lsst_z', 'sigma_lsst_y', 

45 'sigma_uBulge', 'sigma_gBulge', 'sigma_rBulge', 'sigma_iBulge', 

46 'sigma_zBulge', 'sigma_yBulge', 

47 'sigma_uDisk', 'sigma_gDisk', 'sigma_rDisk', 'sigma_iDisk', 

48 'sigma_zDisk', 'sigma_yDisk', 

49 'sigma_uAgn', 'sigma_gAgn', 'sigma_rAgn', 'sigma_iAgn', 

50 'sigma_zAgn', 'sigma_yAgn', 

51 'sedFilenameBulge', 'sedFilenameDisk', 'sedFilenameAgn', 

52 'magNormBulge', 'magNormDisk', 'magNormAgn', 

53 'internalAvBulge', 'internalAvDisk', 'redshift'] 

54 

55 

56class testPhotometricUncertaintyGetters(unittest.TestCase): 

57 """ 

58 This class will test that the getters for photometric uncertainties 

59 are calculating the correct values. 

60 

61 This test is here rather than in sims_photUtils because the infrastructure 

62 to generate fake databases is in sims_catUtils. 

63 """ 

64 

65 @classmethod 

66 def setUpClass(cls): 

67 lsstDefaults = LSSTdefaults() 

68 cls.dbName = tempfile.mktemp(prefix='uncertaintyTestDB-', suffix='.db', dir=ROOT) 

69 

70 default_obs_metadata = makePhoSimTestDB(filename=cls.dbName, size=10, radius = 5.0) 

71 bandpass = ['u', 'g', 'r', 'i', 'z', 'y'] 

72 m5 = list(lsstDefaults._m5.values()) 

73 

74 cls.obs_metadata = ObservationMetaData(pointingRA = default_obs_metadata.pointingRA, 

75 pointingDec = default_obs_metadata.pointingDec, 

76 rotSkyPos = default_obs_metadata.rotSkyPos, 

77 bandpassName = bandpass, 

78 m5 = m5) 

79 

80 cls.obs_metadata.setBandpassM5andSeeing(bandpassName=bandpass, m5=m5) 

81 cls.driver = 'sqlite' 

82 cls.host = '' 

83 

84 cls.skySeds = [] 

85 cls.hardwareBandpasses = [] 

86 cls.totalBandpasses = [] 

87 cls.bandpasses = ['u', 'g', 'r', 'i', 'z', 'y'] 

88 

89 components = ['detector.dat', 'm1.dat', 'm2.dat', 'm3.dat', 

90 'lens1.dat', 'lens2.dat', 'lens3.dat'] 

91 

92 for b in cls.bandpasses: 

93 bandpassDummy = Bandpass() 

94 bandpassDummy.readThroughput(os.path.join(getPackageDir('throughputs'), 

95 'baseline', 'total_%s.dat' % b)) 

96 cls.totalBandpasses.append(bandpassDummy) 

97 

98 for b in cls.bandpasses: 

99 finalComponents = [] 

100 for c in components: 

101 finalComponents.append(os.path.join(getPackageDir('throughputs'), 'baseline', c)) 

102 finalComponents.append(os.path.join(getPackageDir('throughputs'), 

103 'baseline', 'filter_%s.dat' % b)) 

104 bandpassDummy = Bandpass() 

105 bandpassDummy.readThroughputList(finalComponents) 

106 cls.hardwareBandpasses.append(bandpassDummy) 

107 

108 for i in range(len(cls.bandpasses)): 

109 sedDummy = Sed() 

110 sedDummy.readSED_flambda(os.path.join(getPackageDir('throughputs'), 

111 'baseline', 'darksky.dat')) 

112 normalizedSedDummy = setM5(cls.obs_metadata.m5[cls.bandpasses[i]], sedDummy, 

113 cls.totalBandpasses[i], cls.hardwareBandpasses[i], 

114 FWHMeff=lsstDefaults.FWHMeff(cls.bandpasses[i]), 

115 photParams=PhotometricParameters()) 

116 

117 cls.skySeds.append(normalizedSedDummy) 

118 

119 @classmethod 

120 def tearDownClass(cls): 

121 sims_clean_up() 

122 if os.path.exists(cls.dbName): 

123 os.unlink(cls.dbName) 

124 del cls.dbName 

125 del cls.driver 

126 del cls.host 

127 del cls.obs_metadata 

128 del cls.totalBandpasses 

129 del cls.hardwareBandpasses 

130 del cls.skySeds 

131 

132 def testStellarPhotometricUncertainties(self): 

133 """ 

134 Test in the case of a catalog of stars 

135 """ 

136 lsstDefaults = LSSTdefaults() 

137 starDB = testStarsDBObj(driver=self.driver, host=self.host, database=self.dbName) 

138 starCat = testStarCatalog(starDB, obs_metadata=self.obs_metadata) 

139 

140 ct = 0 

141 for line in starCat.iter_catalog(): 

142 starSed = Sed() 

143 starSed.readSED_flambda(os.path.join(getPackageDir('sims_sed_library'), 

144 defaultSpecMap[line[14]])) 

145 imsimband = Bandpass() 

146 imsimband.imsimBandpass() 

147 fNorm = starSed.calcFluxNorm(line[15], imsimband) 

148 starSed.multiplyFluxNorm(fNorm) 

149 

150 aV = np.float(line[16]) 

151 a_int, b_int = starSed.setupCCM_ab() 

152 starSed.addDust(a_int, b_int, A_v=aV) 

153 

154 for i in range(len(self.bandpasses)): 

155 controlSigma = calcMagError_sed(starSed, self.totalBandpasses[i], 

156 self.skySeds[i], 

157 self.hardwareBandpasses[i], 

158 FWHMeff=lsstDefaults.FWHMeff(self.bandpasses[i]), 

159 photParams=PhotometricParameters()) 

160 

161 testSigma = line[8+i] 

162 self.assertAlmostEqual(controlSigma, testSigma, 4) 

163 ct += 1 

164 self.assertGreater(ct, 0) 

165 

166 def testGalaxyPhotometricUncertainties(self): 

167 """ 

168 Test in the case of a catalog of galaxies 

169 """ 

170 lsstDefaults = LSSTdefaults() 

171 galDB = testGalaxyTileDBObj(driver=self.driver, host=self.host, database=self.dbName) 

172 galCat = testGalaxyCatalog(galDB, obs_metadata=self.obs_metadata) 

173 imsimband = Bandpass() 

174 imsimband.imsimBandpass() 

175 ct = 0 

176 for line in galCat.iter_catalog(): 

177 bulgeSedName = line[50] 

178 diskSedName = line[51] 

179 agnSedName = line[52] 

180 magNormBulge = line[53] 

181 magNormDisk = line[54] 

182 magNormAgn = line[55] 

183 avBulge = line[56] 

184 avDisk = line[57] 

185 redshift = line[58] 

186 

187 bulgeSed = Sed() 

188 bulgeSed.readSED_flambda(os.path.join(getPackageDir('sims_sed_library'), 

189 defaultSpecMap[bulgeSedName])) 

190 fNorm = bulgeSed.calcFluxNorm(magNormBulge, imsimband) 

191 bulgeSed.multiplyFluxNorm(fNorm) 

192 

193 diskSed = Sed() 

194 diskSed.readSED_flambda(os.path.join(getPackageDir('sims_sed_library'), 

195 defaultSpecMap[diskSedName])) 

196 fNorm = diskSed.calcFluxNorm(magNormDisk, imsimband) 

197 diskSed.multiplyFluxNorm(fNorm) 

198 

199 agnSed = Sed() 

200 agnSed.readSED_flambda(os.path.join(getPackageDir('sims_sed_library'), 

201 defaultSpecMap[agnSedName])) 

202 fNorm = agnSed.calcFluxNorm(magNormAgn, imsimband) 

203 agnSed.multiplyFluxNorm(fNorm) 

204 

205 a_int, b_int = bulgeSed.setupCCM_ab() 

206 bulgeSed.addDust(a_int, b_int, A_v=avBulge) 

207 

208 a_int, b_int = diskSed.setupCCM_ab() 

209 diskSed.addDust(a_int, b_int, A_v=avDisk) 

210 

211 bulgeSed.redshiftSED(redshift, dimming=True) 

212 diskSed.redshiftSED(redshift, dimming=True) 

213 agnSed.redshiftSED(redshift, dimming=True) 

214 

215 bulgeSed.resampleSED(wavelen_match=self.totalBandpasses[0].wavelen) 

216 diskSed.resampleSED(wavelen_match=bulgeSed.wavelen) 

217 agnSed.resampleSED(wavelen_match=bulgeSed.wavelen) 

218 

219 np.testing.assert_almost_equal(bulgeSed.wavelen, diskSed.wavelen) 

220 np.testing.assert_almost_equal(bulgeSed.wavelen, agnSed.wavelen) 

221 

222 fl = bulgeSed.flambda + diskSed.flambda + agnSed.flambda 

223 

224 totalSed = Sed(wavelen=bulgeSed.wavelen, flambda=fl) 

225 

226 sedList = [totalSed, bulgeSed, diskSed, agnSed] 

227 

228 for i, spectrum in enumerate(sedList): 

229 if i == 0: 

230 msgroot = 'failed on total' 

231 elif i == 1: 

232 msgroot = 'failed on bulge' 

233 elif i == 2: 

234 msgroot = 'failed on disk' 

235 elif i == 3: 

236 msgroot = 'failed on agn' 

237 

238 for j, b in enumerate(self.bandpasses): 

239 controlSigma = calcMagError_sed(spectrum, self.totalBandpasses[j], 

240 self.skySeds[j], 

241 self.hardwareBandpasses[j], 

242 FWHMeff=lsstDefaults.FWHMeff(b), 

243 photParams=PhotometricParameters()) 

244 

245 testSigma = line[26+(i*6)+j] 

246 msg = '%e neq %e; ' % (testSigma, controlSigma) + msgroot 

247 self.assertAlmostEqual(testSigma, controlSigma, 10, msg=msg) 

248 ct += 1 

249 

250 self.assertGreater(ct, 0) 

251 

252 

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

254 pass 

255 

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

257 lsst.utils.tests.init() 

258 unittest.main()