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 __future__ import with_statement 

2from builtins import zip 

3from builtins import range 

4import unittest 

5import os 

6import numpy as np 

7import lsst 

8 

9import lsst.utils.tests 

10from lsst.utils import getPackageDir 

11from lsst.sims.utils import defaultSpecMap 

12from lsst.sims.utils import ObservationMetaData 

13from lsst.sims.catalogs.db import fileDBObject 

14from lsst.sims.catalogs.definitions import InstanceCatalog 

15from lsst.sims.catalogs.decorators import compound 

16from lsst.sims.catUtils.mixins import PhotometrySSM, AstrometrySSM 

17from lsst.sims.photUtils import BandpassDict, SedList, PhotometricParameters 

18from lsst.sims.utils import _observedFromICRS 

19 

20 

21def setup_module(module): 

22 lsst.utils.tests.init() 

23 

24 

25class LSST_SSM_photCat(InstanceCatalog, PhotometrySSM): 

26 catalog_type = __file__ + 'lsst_ssm_phot_cat' 

27 

28 column_outputs = ['id', 'lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y'] 

29 

30 default_formats = {'f': '%.13f'} 

31 

32 

33class Compound_SSM_photCat(InstanceCatalog, PhotometrySSM): 

34 catalog_type = __file__ + 'compound_ssm_phot_cat' 

35 

36 column_outputs = ['id', 'lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y', 

37 'cartoon_u', 'cartoon_g', 'cartoon_r', 'cartoon_i', 'cartoon_z'] 

38 

39 default_formats = {'f': '%.13f'} 

40 

41 @compound('cartoon_u', 'cartoon_g', 'cartoon_r', 'cartoon_i', 'cartoon_z') 

42 def get_cartoon_mags(self): 

43 

44 if not hasattr(self, 'cartoonBandpassDict'): 

45 bandpassDir = os.path.join(getPackageDir('sims_photUtils'), 'tests', 'cartoonSedTestData') 

46 

47 self.cartoonBandpassDict = \ 

48 BandpassDict.loadTotalBandpassesFromFiles(['u', 'g', 'r', 'i', 'z'], 

49 bandpassDir=bandpassDir, 

50 bandpassRoot='test_bandpass_') 

51 

52 return self._quiescentMagnitudeGetter(self.cartoonBandpassDict, self.get_cartoon_mags._colnames, 

53 bandpassTag='cartoon') 

54 

55 

56class SSM_dmagCat(InstanceCatalog, PhotometrySSM): 

57 catalog_type = __file__ + 'ssm_dmag_cat' 

58 

59 column_outputs = ['id', 'dmagTrailing', 'dmagDetection'] 

60 

61 default_formats = {'f': '%.13f'} 

62 

63 

64class SSMphotometryTest(unittest.TestCase): 

65 

66 @classmethod 

67 def setUpClass(cls): 

68 cls.dbFile = os.path.join(getPackageDir('sims_catUtils'), 

69 'tests', 'testData', 'SSMphotometryCatalog.txt') 

70 

71 cls.dtype = np.dtype([('id', np.int), ('sedFilename', str, 100), ('magNorm', np.float), 

72 ('velRa', np.float), ('velDec', np.float)]) 

73 

74 cls.photDB = fileDBObject(cls.dbFile, runtable='test', dtype=cls.dtype, idColKey='id') 

75 

76 def testLSSTmags(self): 

77 """ 

78 Test that PhotometrySSM properly calculates LSST magnitudes 

79 """ 

80 cat = LSST_SSM_photCat(self.photDB) 

81 

82 dtype = np.dtype([('id', np.int), ('u', np.float), ('g', np.float), 

83 ('r', np.float), ('i', np.float), ('z', np.float), 

84 ('y', np.float)]) 

85 

86 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

87 cat.write_catalog(catName) 

88 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

89 self.assertGreater(len(testData), 0) 

90 

91 controlData = np.genfromtxt(self.dbFile, dtype=self.dtype) 

92 self.assertGreater(len(controlData), 0) 

93 

94 LSSTbandpasses = BandpassDict.loadTotalBandpassesFromFiles() 

95 controlSedList = SedList(controlData['sedFilename'], controlData['magNorm'], 

96 wavelenMatch=LSSTbandpasses.wavelenMatch, 

97 fileDir=getPackageDir('sims_sed_library'), 

98 specMap=defaultSpecMap) 

99 

100 controlMags = LSSTbandpasses.magListForSedList(controlSedList) 

101 

102 for ii in range(len(controlMags)): 

103 for jj, bpName in enumerate(['u', 'g', 'r', 'i', 'z', 'y']): 

104 self.assertAlmostEqual(controlMags[ii][jj], testData[bpName][ii], 10) 

105 

106 def testManyMagSystems(self): 

107 """ 

108 Test that the SSM photometry mixin can simultaneously calculate magnitudes 

109 in multiple bandpass systems 

110 """ 

111 cat = Compound_SSM_photCat(self.photDB) 

112 

113 dtype = np.dtype([('id', np.int), ('lsst_u', np.float), ('lsst_g', np.float), 

114 ('lsst_r', np.float), ('lsst_i', np.float), ('lsst_z', np.float), 

115 ('lsst_y', np.float), 

116 ('cartoon_u', np.float), ('cartoon_g', np.float), 

117 ('cartoon_r', np.float), ('cartoon_i', np.float), 

118 ('cartoon_z', np.float)]) 

119 

120 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

121 cat.write_catalog(catName) 

122 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

123 self.assertGreater(len(testData), 0) 

124 

125 controlData = np.genfromtxt(self.dbFile, dtype=self.dtype) 

126 self.assertGreater(len(controlData), 0) 

127 

128 LSSTbandpasses = BandpassDict.loadTotalBandpassesFromFiles() 

129 bandpassDir = os.path.join(getPackageDir('sims_photUtils'), 'tests', 'cartoonSedTestData') 

130 cartoonBandpasses = BandpassDict.loadTotalBandpassesFromFiles(['u', 'g', 'r', 'i', 'z'], 

131 bandpassDir=bandpassDir, 

132 bandpassRoot='test_bandpass_') 

133 

134 controlSedList = SedList(controlData['sedFilename'], controlData['magNorm'], 

135 wavelenMatch=LSSTbandpasses.wavelenMatch, 

136 fileDir=getPackageDir('sims_sed_library'), 

137 specMap=defaultSpecMap) 

138 

139 controlLsstMags = LSSTbandpasses.magListForSedList(controlSedList) 

140 controlCartoonMags = cartoonBandpasses.magListForSedList(controlSedList) 

141 

142 for ii in range(len(controlLsstMags)): 

143 for jj, bpName in enumerate(['lsst_u', 'lsst_g', 'lsst_r', 'lsst_i', 'lsst_z', 'lsst_y']): 

144 self.assertAlmostEqual(controlLsstMags[ii][jj], testData[bpName][ii], 10) 

145 for jj, bpName in enumerate(['cartoon_u', 'cartoon_g', 'cartoon_r', 'cartoon_i', 'cartoon_z']): 

146 self.assertAlmostEqual(controlCartoonMags[ii][jj], testData[bpName][ii], 10) 

147 

148 def testDmagExceptions(self): 

149 """ 

150 Test that the dmagTrailing and dmagDetection getters raise expected 

151 exceptions 

152 """ 

153 obs = ObservationMetaData() 

154 with self.assertRaises(RuntimeError) as context: 

155 cat = SSM_dmagCat(self.photDB, obs_metadata=obs) 

156 self.assertIn("does not specify seeing", context.exception.args[0]) 

157 

158 obs = ObservationMetaData(bandpassName = ['u', 'g'], seeing=[0.6, 0.5]) 

159 

160 with self.assertRaises(RuntimeError) as context: 

161 cat = SSM_dmagCat(self.photDB, obs_metadata=obs) 

162 self.assertIn("multiple seeing values", context.exception.args[0]) 

163 

164 obs = ObservationMetaData(bandpassName = 'u', seeing=0.7) 

165 with self.assertRaises(RuntimeError) as context: 

166 cat = SSM_dmagCat(self.photDB, obs_metadata=obs) 

167 cat.photParams = None 

168 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

169 cat.write_catalog(catName) 

170 self.assertIn("does not have an associated PhotometricParameters", 

171 context.exception.args[0]) 

172 

173 def testDmag(self): 

174 """ 

175 Test the calculation of dmagTrailing and dmagDetection 

176 """ 

177 

178 obs = ObservationMetaData(bandpassName = 'u', seeing=1.48) 

179 photParams = PhotometricParameters() 

180 

181 controlData = np.genfromtxt(self.dbFile, dtype=self.dtype) 

182 

183 cat = SSM_dmagCat(self.photDB, obs_metadata=obs) 

184 

185 dtype = np.dtype([('id', np.int), ('dmagTrail', np.float), ('dmagDetect', np.float)]) 

186 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

187 cat.write_catalog(catName) 

188 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

189 self.assertGreater(len(testData), 0) 

190 

191 a_trail = 0.76 

192 b_trail = 1.16 

193 a_det = 0.42 

194 b_det = 0.00 

195 

196 velocity = np.sqrt(np.power(np.degrees(controlData['velRa']), 2) + 

197 np.power(np.degrees(controlData['velDec']), 2)) 

198 x = velocity * photParams.nexp * photParams.exptime / (obs.seeing[obs.bandpass] * 24.0) 

199 xsq = np.power(x, 2) 

200 

201 dmagTrailControl = 1.25*np.log10(1.0 + a_trail*xsq/(1.0+b_trail*x)) 

202 dmagDetectControl = 1.25*np.log10(1.0 + a_det*xsq/(1.0+b_det*x)) 

203 

204 # Check against precalculated numbers, just to verify units/conversions, etc. 

205 self.assertLess(abs(dmagTrailControl[-1] - 0.0219), 0.01) 

206 self.assertLess(abs(dmagDetectControl[-1] - 0.01594), 0.01) 

207 

208 np.testing.assert_array_almost_equal(dmagTrailControl, testData['dmagTrail'], 10) 

209 np.testing.assert_array_almost_equal(dmagDetectControl, testData['dmagDetect'], 10) 

210 

211 

212class SSM_astrometryCat(InstanceCatalog, AstrometrySSM): 

213 column_outputs = ['id', 'raObserved', 'decObserved'] 

214 

215 default_formats = {'f': '%.13f'} 

216 

217 

218class SSM_velocityCat(InstanceCatalog, AstrometrySSM): 

219 column_outputs = ['id', 'skyVelocity'] 

220 

221 default_formats = {'f': '%.13f'} 

222 

223 

224class SSMastrometryTest(unittest.TestCase): 

225 

226 @classmethod 

227 def setUpClass(cls): 

228 cls.dbFile = os.path.join(getPackageDir('sims_catUtils'), 

229 'tests', 'testData', 'SSMastrometryCatalog.txt') 

230 

231 cls.dtype = np.dtype([('id', np.int), ('raJ2000', np.float), ('decJ2000', np.float), 

232 ('velRa', np.float), ('velDec', np.float)]) 

233 

234 cls.astDB = fileDBObject(cls.dbFile, runtable='test', dtype=cls.dtype, idColKey='id') 

235 

236 def testObservedRaDec(self): 

237 """ 

238 Test that the mixins provided in Astrometry SSM really do convert ICRS RA, Dec 

239 into observed RA, Dec 

240 """ 

241 

242 dtype = np.dtype([('id', np.int), 

243 ('raObserved', np.float), ('decObserved', np.float)]) 

244 

245 controlData = np.genfromtxt(self.dbFile, dtype=self.dtype) 

246 

247 rng = np.random.RandomState(42) 

248 nTests = 5 

249 raList = rng.random_sample(nTests)*2.0*np.pi 

250 decList = (rng.random_sample(nTests)-0.5)*np.pi 

251 mjdList = rng.random_sample(nTests)*5000.0 + 53850.0 

252 for raPointing, decPointing, mjd in zip(raList, decList, mjdList): 

253 obs = ObservationMetaData(pointingRA=raPointing, pointingDec=decPointing, mjd=mjd) 

254 

255 cat = SSM_astrometryCat(self.astDB, obs_metadata=obs) 

256 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

257 cat.write_catalog(catName) 

258 

259 testData = np.genfromtxt(catName, dtype=dtype, delimiter=',') 

260 self.assertGreater(len(testData), 0) 

261 

262 raObservedControl, decObservedControl = _observedFromICRS(controlData['raJ2000'], 

263 controlData['decJ2000'], 

264 obs_metadata=obs, epoch=2000.0, 

265 includeRefraction=True) 

266 

267 np.testing.assert_array_almost_equal(raObservedControl, testData['raObserved'], 10) 

268 np.testing.assert_array_almost_equal(decObservedControl, testData['decObserved'], 10) 

269 

270 def testSkyVelocity(self): 

271 """ 

272 Test that getter for sky velocity correctly calculates its output 

273 """ 

274 controlData = np.genfromtxt(self.dbFile, dtype=self.dtype) 

275 controlVel = np.sqrt(np.power(controlData['velRa'], 2) + np.power(controlData['velDec'], 2)) 

276 

277 cat = SSM_velocityCat(self.astDB) 

278 dtype = np.dtype([('id', np.int), ('vel', np.float)]) 

279 with lsst.utils.tests.getTempFilePath('.txt') as catName: 

280 cat.write_catalog(catName) 

281 testData = np.genfromtxt(catName, dtype=dtype) 

282 self.assertGreater(len(testData), 0) 

283 

284 np.testing.assert_array_almost_equal(testData['vel'], controlVel, 10) 

285 

286 

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

288 pass 

289 

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

291 lsst.utils.tests.init() 

292 unittest.main()