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 

2 

3import numpy as np 

4import unittest 

5import lsst.utils.tests 

6from lsst.sims.utils import ObservationMetaData, ModifiedJulianDate 

7from lsst.sims.utils import Site, BoxBounds, CircleBounds 

8 

9 

10def setup_module(module): 

11 lsst.utils.tests.init() 

12 

13 

14class ObservationMetaDataTest(unittest.TestCase): 

15 """ 

16 This class will test that ObservationMetaData correctly assigns 

17 and returns its class variables (pointingRA, pointingDec, etc.) 

18 

19 It will also test the behavior of the m5 member variable. 

20 """ 

21 

22 def testM5(self): 

23 """ 

24 Test behavior of ObservationMetaData's m5 member variable 

25 """ 

26 

27 self.assertRaises(RuntimeError, ObservationMetaData, bandpassName='u', m5=[12.0, 13.0]) 

28 self.assertRaises(RuntimeError, ObservationMetaData, bandpassName=['u', 'g'], m5=15.0) 

29 self.assertRaises(RuntimeError, ObservationMetaData, bandpassName=['u', 'g'], m5=[12.0, 13.0, 15.0]) 

30 

31 obsMD = ObservationMetaData() 

32 self.assertIsNone(obsMD.m5) 

33 

34 obsMD = ObservationMetaData(bandpassName='g', m5=12.0) 

35 self.assertAlmostEqual(obsMD.m5['g'], 12.0, 10) 

36 

37 obsMD = ObservationMetaData(bandpassName=['u', 'g', 'r'], m5=[10, 11, 12]) 

38 self.assertEqual(obsMD.m5['u'], 10) 

39 self.assertEqual(obsMD.m5['g'], 11) 

40 self.assertEqual(obsMD.m5['r'], 12) 

41 

42 def testSeeing(self): 

43 """ 

44 Test behavior of ObservationMetaData's seeing member variable 

45 """ 

46 

47 self.assertRaises(RuntimeError, ObservationMetaData, bandpassName='u', seeing=[0.7, 0.6]) 

48 self.assertRaises(RuntimeError, ObservationMetaData, bandpassName=['u', 'g'], seeing=0.7) 

49 self.assertRaises(RuntimeError, ObservationMetaData, bandpassName=['u', 'g'], seeing=[0.8, 0.7, 0.6]) 

50 

51 obsMD = ObservationMetaData() 

52 self.assertIsNone(obsMD.seeing) 

53 

54 obsMD = ObservationMetaData(bandpassName='g', seeing=0.7) 

55 self.assertAlmostEqual(obsMD.seeing['g'], 0.7, 10) 

56 

57 obsMD = ObservationMetaData(bandpassName=['u', 'g', 'r'], seeing=[0.7, 0.6, 0.5]) 

58 self.assertEqual(obsMD.seeing['u'], 0.7) 

59 self.assertEqual(obsMD.seeing['g'], 0.6) 

60 self.assertEqual(obsMD.seeing['r'], 0.5) 

61 

62 def testM5andSeeingAssignment(self): 

63 """ 

64 Test assignment of m5 and seeing seeing and bandpass in ObservationMetaData 

65 """ 

66 obsMD = ObservationMetaData(bandpassName=['u', 'g'], m5=[15.0, 16.0], seeing=[0.7, 0.6]) 

67 self.assertAlmostEqual(obsMD.m5['u'], 15.0, 10) 

68 self.assertAlmostEqual(obsMD.m5['g'], 16.0, 10) 

69 self.assertAlmostEqual(obsMD.seeing['u'], 0.7, 10) 

70 self.assertAlmostEqual(obsMD.seeing['g'], 0.6, 10) 

71 

72 obsMD.setBandpassM5andSeeing(bandpassName=['i', 'z'], m5=[25.0, 22.0], seeing=[0.5, 0.4]) 

73 self.assertAlmostEqual(obsMD.m5['i'], 25.0, 10) 

74 self.assertAlmostEqual(obsMD.m5['z'], 22.0, 10) 

75 self.assertAlmostEqual(obsMD.seeing['i'], 0.5, 10) 

76 self.assertAlmostEqual(obsMD.seeing['z'], 0.4, 10) 

77 

78 with self.assertRaises(KeyError): 

79 obsMD.m5['u'] 

80 

81 with self.assertRaises(KeyError): 

82 obsMD.m5['g'] 

83 

84 obsMD.m5 = [13.0, 14.0] 

85 obsMD.seeing = [0.2, 0.3] 

86 self.assertAlmostEqual(obsMD.m5['i'], 13.0, 10) 

87 self.assertAlmostEqual(obsMD.m5['z'], 14.0, 10) 

88 self.assertAlmostEqual(obsMD.seeing['i'], 0.2, 10) 

89 self.assertAlmostEqual(obsMD.seeing['z'], 0.3, 10) 

90 

91 obsMD.setBandpassM5andSeeing(bandpassName=['k', 'j'], m5=[21.0, 23.0]) 

92 self.assertAlmostEqual(obsMD.m5['k'], 21.0, 10) 

93 self.assertAlmostEqual(obsMD.m5['j'], 23.0, 10) 

94 self.assertIsNone(obsMD.seeing) 

95 

96 obsMD.setBandpassM5andSeeing(bandpassName=['w', 'x'], seeing=[0.9, 1.1]) 

97 self.assertAlmostEqual(obsMD.seeing['w'], 0.9, 10) 

98 self.assertAlmostEqual(obsMD.seeing['x'], 1.1, 10) 

99 

100 def testDefault(self): 

101 """ 

102 Test that ObservationMetaData's default variables are properly set 

103 """ 

104 

105 testObsMD = ObservationMetaData() 

106 

107 self.assertEqual(testObsMD.pointingRA, None) 

108 self.assertEqual(testObsMD.pointingDec, None) 

109 self.assertEqual(testObsMD.rotSkyPos, None) 

110 self.assertEqual(testObsMD.bandpass, None) 

111 self.assertEqual(testObsMD.m5, None) 

112 self.assertEqual(testObsMD.seeing, None) 

113 self.assertAlmostEqual(testObsMD.site.longitude, -70.7494, 10) 

114 self.assertAlmostEqual(testObsMD.site.latitude, -30.2444, 10) 

115 self.assertAlmostEqual(testObsMD.site.height, 2650, 10) 

116 self.assertAlmostEqual(testObsMD.site.temperature_kelvin, 284.65, 10) 

117 self.assertAlmostEqual(testObsMD.site.temperature, 11.5, 10) 

118 self.assertAlmostEqual(testObsMD.site.pressure, 750.0, 10) 

119 self.assertAlmostEqual(testObsMD.site.humidity, 0.4, 10) 

120 self.assertAlmostEqual(testObsMD.site.lapseRate, 0.0065, 10) 

121 

122 def testSite(self): 

123 """ 

124 Test that site data gets passed correctly when it is not default 

125 """ 

126 testSite = Site(longitude=20.0, latitude=-71.0, height=4.0, 

127 temperature=100.0, pressure=500.0, humidity=0.1, 

128 lapseRate=0.1) 

129 

130 testObsMD = ObservationMetaData(site=testSite) 

131 

132 self.assertAlmostEqual(testObsMD.site.longitude, 20.0, 10) 

133 self.assertAlmostEqual(testObsMD.site.longitude_rad, np.radians(20.0), 10) 

134 self.assertAlmostEqual(testObsMD.site.latitude, -71.0, 10) 

135 self.assertAlmostEqual(testObsMD.site.latitude_rad, np.radians(-71.0), 10) 

136 self.assertAlmostEqual(testObsMD.site.height, 4.0, 10) 

137 self.assertAlmostEqual(testObsMD.site.temperature, 100.0, 10) 

138 self.assertAlmostEqual(testObsMD.site.temperature_kelvin, 373.15, 10) 

139 self.assertAlmostEqual(testObsMD.site.pressure, 500.0, 10) 

140 self.assertAlmostEqual(testObsMD.site.humidity, 0.1, 10) 

141 self.assertAlmostEqual(testObsMD.site.lapseRate, 0.1, 10) 

142 

143 def testAssignment(self): 

144 """ 

145 Test that ObservationMetaData member variables get passed correctly 

146 """ 

147 

148 mjd = 5120.0 

149 RA = 1.5 

150 Dec = -1.1 

151 rotSkyPos = -10.0 

152 skyBrightness = 25.0 

153 

154 testObsMD = ObservationMetaData() 

155 testObsMD.pointingRA = RA 

156 testObsMD.pointingDec = Dec 

157 testObsMD.rotSkyPos = rotSkyPos 

158 testObsMD.skyBrightness = skyBrightness 

159 testObsMD.mjd = mjd 

160 testObsMD.boundType = 'box' 

161 testObsMD.boundLength = [1.2, 3.0] 

162 

163 self.assertAlmostEqual(testObsMD.pointingRA, RA, 10) 

164 self.assertAlmostEqual(testObsMD.pointingDec, Dec, 10) 

165 self.assertAlmostEqual(testObsMD.rotSkyPos, rotSkyPos, 10) 

166 self.assertAlmostEqual(testObsMD.skyBrightness, skyBrightness, 10) 

167 self.assertEqual(testObsMD.boundType, 'box') 

168 self.assertAlmostEqual(testObsMD.boundLength[0], 1.2, 10) 

169 self.assertAlmostEqual(testObsMD.boundLength[1], 3.0, 10) 

170 self.assertAlmostEqual(testObsMD.mjd.TAI, mjd, 10) 

171 

172 # test reassignment 

173 

174 testObsMD.pointingRA = RA+1.0 

175 testObsMD.pointingDec = Dec+1.0 

176 testObsMD.rotSkyPos = rotSkyPos+1.0 

177 testObsMD.skyBrightness = skyBrightness+1.0 

178 testObsMD.boundLength = 2.2 

179 testObsMD.boundType = 'circle' 

180 testObsMD.mjd = mjd + 10.0 

181 

182 self.assertAlmostEqual(testObsMD.pointingRA, RA+1.0, 10) 

183 self.assertAlmostEqual(testObsMD.pointingDec, Dec+1.0, 10) 

184 self.assertAlmostEqual(testObsMD.rotSkyPos, rotSkyPos+1.0, 10) 

185 self.assertAlmostEqual(testObsMD.skyBrightness, skyBrightness+1.0, 10) 

186 self.assertEqual(testObsMD.boundType, 'circle') 

187 self.assertAlmostEqual(testObsMD.boundLength, 2.2, 10) 

188 self.assertAlmostEqual(testObsMD.mjd.TAI, mjd+10.0, 10) 

189 

190 testObsMD = ObservationMetaData(mjd=mjd, pointingRA=RA, 

191 pointingDec=Dec, rotSkyPos=rotSkyPos, bandpassName='z', 

192 skyBrightness=skyBrightness) 

193 

194 self.assertAlmostEqual(testObsMD.mjd.TAI, 5120.0, 10) 

195 self.assertAlmostEqual(testObsMD.pointingRA, 1.5, 10) 

196 self.assertAlmostEqual(testObsMD.pointingDec, -1.1, 10) 

197 self.assertAlmostEqual(testObsMD.rotSkyPos, -10.0, 10) 

198 self.assertEqual(testObsMD.bandpass, 'z') 

199 self.assertAlmostEqual(testObsMD.skyBrightness, skyBrightness, 10) 

200 

201 # test assigning ModifiedJulianDate 

202 obs = ObservationMetaData() 

203 mjd = ModifiedJulianDate(TAI=57388.0) 

204 obs.mjd = mjd 

205 self.assertEqual(obs.mjd, mjd) 

206 

207 mjd2 = ModifiedJulianDate(TAI=45000.0) 

208 obs.mjd = mjd2 

209 self.assertEqual(obs.mjd, mjd2) 

210 self.assertNotEqual(obs.mjd, mjd) 

211 

212 def testBoundBuilding(self): 

213 """ 

214 Make sure ObservationMetaData can build bounds 

215 """ 

216 boxBounds = [0.1, 0.3] 

217 circObs = ObservationMetaData(boundType='circle', pointingRA=0.0, pointingDec=0.0, 

218 boundLength=1.0, mjd=53580.0) 

219 boundControl = CircleBounds(0.0, 0.0, np.radians(1.0)) 

220 self.assertEqual(circObs.bounds, boundControl) 

221 

222 squareObs = ObservationMetaData(boundType = 'box', pointingRA=0.0, pointingDec=0.0, 

223 boundLength=1.0, mjd=53580.0) 

224 boundControl = BoxBounds(0.0, 0.0, np.radians(1.0)) 

225 self.assertEqual(squareObs.bounds, boundControl) 

226 

227 boxObs = ObservationMetaData(boundType = 'box', pointingRA=0.0, pointingDec=0.0, 

228 boundLength=boxBounds, mjd=53580.0) 

229 boundControl = BoxBounds(0.0, 0.0, np.radians([0.1, 0.3])) 

230 self.assertEqual(boxObs.bounds, boundControl) 

231 

232 def testBounds(self): 

233 """ 

234 Test if ObservationMetaData correctly assigns the pointing[RA,Dec] 

235 when circle and box bounds are specified 

236 """ 

237 

238 circRA = 25.0 

239 circDec = 50.0 

240 radius = 5.0 

241 

242 boxRA = 15.0 

243 boxDec = 0.0 

244 boxLength = np.array([5.0, 10.0]) 

245 

246 testObsMD = ObservationMetaData(boundType='circle', 

247 pointingRA = circRA, pointingDec=circDec, 

248 boundLength = radius, mjd=53580.0) 

249 self.assertAlmostEqual(testObsMD.pointingRA, 25.0, 10) 

250 self.assertAlmostEqual(testObsMD.pointingDec, 50.0, 10) 

251 

252 testObsMD = ObservationMetaData(boundType='box', 

253 pointingRA=boxRA, pointingDec=boxDec, boundLength=boxLength, 

254 mjd=53580.0) 

255 self.assertAlmostEqual(testObsMD.pointingRA, 15.0, 10) 

256 self.assertAlmostEqual(testObsMD.pointingDec, 0.0, 10) 

257 

258 def testSummary(self): 

259 """ 

260 Make sure summary is safe even when no parameters have been set 

261 """ 

262 obs = ObservationMetaData() 

263 obs.summary 

264 

265 def testOpsimMetaData(self): 

266 """ 

267 Make sure that an exception is raised if you pass a non-dict 

268 object in as OpsimMetaData 

269 """ 

270 obs = ObservationMetaData(pointingRA=23.0, pointingDec=-11.0) 

271 

272 with self.assertRaises(RuntimeError) as ee: 

273 obs.OpsimMetaData = 5.0 

274 self.assertIn("must be a dict", ee.exception.args[0]) 

275 

276 with self.assertRaises(RuntimeError) as ee: 

277 obs.OpsimMetaData = 5 

278 self.assertIn("must be a dict", ee.exception.args[0]) 

279 

280 with self.assertRaises(RuntimeError) as ee: 

281 obs.OpsimMetaData = [5.0, 3.0] 

282 self.assertIn("must be a dict", ee.exception.args[0]) 

283 

284 with self.assertRaises(RuntimeError) as ee: 

285 obs.OpsimMetaData = (5.0, 3.0) 

286 self.assertIn("must be a dict", ee.exception.args[0]) 

287 

288 obs.OpsimMetaData = {'a': 1, 'b': 2} 

289 

290 def test_eq(self): 

291 """ 

292 Test that we implemented __eq__ and __ne__ correctly 

293 """ 

294 empty_obs = ObservationMetaData() 

295 other_empty_obs = ObservationMetaData() 

296 self.assertEqual(empty_obs, other_empty_obs) 

297 self.assertTrue(empty_obs == other_empty_obs) 

298 self.assertFalse(empty_obs != other_empty_obs) 

299 

300 dummy_site = Site(longitude=23.1, latitude=-11.1, temperature=11.0, 

301 height=8921.01, pressure=734.1, humidity=0.1, 

302 lapseRate=0.006) 

303 

304 ref_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1, 

305 mjd=59580.1, rotSkyPos=91.2, 

306 bandpassName = 'u', m5=24.3, 

307 skyBrightness=22.1, seeing=0.8, 

308 site=dummy_site) 

309 

310 other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1, 

311 mjd=59580.1, rotSkyPos=91.2, 

312 bandpassName = 'u', m5=24.3, 

313 skyBrightness=22.1, seeing=0.8, 

314 site=dummy_site) 

315 

316 self.assertEqual(ref_obs, other_obs) 

317 self.assertTrue(ref_obs == other_obs) 

318 self.assertFalse(ref_obs != other_obs) 

319 

320 other_obs = ObservationMetaData(pointingRA=23.41, pointingDec=-19.1, 

321 mjd=59580.1, rotSkyPos=91.2, 

322 bandpassName = 'u', m5=24.3, 

323 skyBrightness=22.1, seeing=0.8, 

324 site=dummy_site) 

325 

326 self.assertNotEqual(ref_obs, other_obs) 

327 self.assertFalse(ref_obs == other_obs) 

328 self.assertTrue(ref_obs != other_obs) 

329 

330 other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.2, 

331 mjd=59580.1, rotSkyPos=91.2, 

332 bandpassName = 'u', m5=24.3, 

333 skyBrightness=22.1, seeing=0.8, 

334 site=dummy_site) 

335 

336 self.assertNotEqual(ref_obs, other_obs) 

337 self.assertFalse(ref_obs == other_obs) 

338 self.assertTrue(ref_obs != other_obs) 

339 

340 other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1, 

341 mjd=59580.2, rotSkyPos=91.2, 

342 bandpassName = 'u', m5=24.3, 

343 skyBrightness=22.1, seeing=0.8, 

344 site=dummy_site) 

345 

346 self.assertNotEqual(ref_obs, other_obs) 

347 self.assertFalse(ref_obs == other_obs) 

348 self.assertTrue(ref_obs != other_obs) 

349 

350 other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1, 

351 mjd=59580.1, rotSkyPos=91.1, 

352 bandpassName = 'u', m5=24.3, 

353 skyBrightness=22.1, seeing=0.8, 

354 site=dummy_site) 

355 

356 self.assertNotEqual(ref_obs, other_obs) 

357 self.assertFalse(ref_obs == other_obs) 

358 self.assertTrue(ref_obs != other_obs) 

359 

360 other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1, 

361 mjd=59580.1, rotSkyPos=91.2, 

362 bandpassName = 'g', m5=24.3, 

363 skyBrightness=22.1, seeing=0.8, 

364 site=dummy_site) 

365 

366 self.assertNotEqual(ref_obs, other_obs) 

367 self.assertFalse(ref_obs == other_obs) 

368 self.assertTrue(ref_obs != other_obs) 

369 

370 other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1, 

371 mjd=59580.1, rotSkyPos=91.2, 

372 bandpassName = 'u', m5=24.1, 

373 skyBrightness=22.1, seeing=0.8, 

374 site=dummy_site) 

375 

376 self.assertNotEqual(ref_obs, other_obs) 

377 self.assertFalse(ref_obs == other_obs) 

378 self.assertTrue(ref_obs != other_obs) 

379 

380 other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1, 

381 mjd=59580.1, rotSkyPos=91.2, 

382 bandpassName = 'u', m5=24.3, 

383 skyBrightness=22.2, seeing=0.8, 

384 site=dummy_site) 

385 

386 self.assertNotEqual(ref_obs, other_obs) 

387 self.assertFalse(ref_obs == other_obs) 

388 self.assertTrue(ref_obs != other_obs) 

389 

390 other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1, 

391 mjd=59580.1, rotSkyPos=91.2, 

392 bandpassName = 'u', m5=24.3, 

393 skyBrightness=22.1, seeing=0.81, 

394 site=dummy_site) 

395 

396 self.assertNotEqual(ref_obs, other_obs) 

397 self.assertFalse(ref_obs == other_obs) 

398 self.assertTrue(ref_obs != other_obs) 

399 

400 other_obs = ObservationMetaData(pointingRA=23.44, pointingDec=-19.1, 

401 mjd=59580.1, rotSkyPos=91.2, 

402 bandpassName = 'u', m5=24.3, 

403 skyBrightness=22.1, seeing=0.8) 

404 

405 self.assertNotEqual(ref_obs, other_obs) 

406 self.assertFalse(ref_obs == other_obs) 

407 self.assertTrue(ref_obs != other_obs) 

408 

409 # use assignment to bring other_obs back into agreement with 

410 # ref_obs 

411 other_obs.site = dummy_site 

412 self.assertEqual(ref_obs, other_obs) 

413 self.assertTrue(ref_obs == other_obs) 

414 self.assertFalse(ref_obs != other_obs) 

415 

416 # now try cases of m5, bandpass, and seeing being lists 

417 ref_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'], 

418 m5=[22.1, 23.5, 24.2], 

419 seeing=[0.6, 0.7, 0.8]) 

420 

421 other_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'], 

422 m5=[22.1, 23.5, 24.2], 

423 seeing=[0.6, 0.7, 0.8]) 

424 

425 self.assertEqual(ref_obs, other_obs) 

426 self.assertTrue(ref_obs == other_obs) 

427 self.assertFalse(ref_obs != other_obs) 

428 

429 other_obs.setBandpassM5andSeeing(bandpassName=['u', 'i', 'z'], 

430 m5=[22.1, 23.5, 24.2], 

431 seeing=[0.6, 0.7, 0.8]) 

432 

433 self.assertNotEqual(ref_obs, other_obs) 

434 self.assertFalse(ref_obs == other_obs) 

435 self.assertTrue(ref_obs != other_obs) 

436 

437 other_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'], 

438 m5=[22.1, 23.4, 24.2], 

439 seeing=[0.6, 0.7, 0.8]) 

440 

441 self.assertNotEqual(ref_obs, other_obs) 

442 self.assertFalse(ref_obs == other_obs) 

443 self.assertTrue(ref_obs != other_obs) 

444 

445 other_obs.setBandpassM5andSeeing(bandpassName=['u', 'r', 'z'], 

446 m5=[22.1, 23.5, 24.2], 

447 seeing=[0.2, 0.7, 0.8]) 

448 

449 self.assertNotEqual(ref_obs, other_obs) 

450 self.assertFalse(ref_obs == other_obs) 

451 self.assertTrue(ref_obs != other_obs) 

452 

453 other_obs.setBandpassM5andSeeing(bandpassName=['u', 'z'], 

454 m5=[22.1, 24.2], 

455 seeing=[0.2, 0.8]) 

456 

457 self.assertNotEqual(ref_obs, other_obs) 

458 self.assertFalse(ref_obs == other_obs) 

459 self.assertTrue(ref_obs != other_obs) 

460 

461 

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

463 pass 

464 

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

466 lsst.utils.tests.init() 

467 unittest.main()