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

1# 

2# LSST Data Management System 

3# Copyright 2016 LSST Corporation. 

4# 

5# This product includes software developed by the 

6# LSST Project (http://www.lsst.org/). 

7# 

8# This program is free software: you can redistribute it and/or modify 

9# it under the terms of the GNU General Public License as published by 

10# the Free Software Foundation, either version 3 of the License, or 

11# (at your option) any later version. 

12# 

13# This program is distributed in the hope that it will be useful, 

14# but WITHOUT ANY WARRANTY; without even the implied warranty of 

15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

16# GNU General Public License for more details. 

17# 

18# You should have received a copy of the LSST License Statement and 

19# the GNU General Public License along with this program. If not, 

20# see <http://www.lsstcorp.org/LegalNotices/>. 

21# 

22import math 

23import os 

24import unittest 

25import collections 

26import numpy as np 

27 

28import lsst.utils.tests 

29import lsst.pex.exceptions 

30from lsst.daf.base import DateTime, PropertySet, PropertyList 

31from lsst.geom import Angle, degrees, SpherePoint 

32from lsst.afw.coord import Observatory, Weather 

33import lsst.afw.image as afwImage 

34 

35RotTypeEnumNameDict = { 

36 afwImage.RotType.UNKNOWN: "UNKNOWN", 

37 afwImage.RotType.SKY: "SKY", 

38 afwImage.RotType.HORIZON: "HORIZON", 

39 afwImage.RotType.MOUNT: "MOUNT", 

40} 

41 

42 

43def propertySetFromDict(keyValDict): 

44 """Make an lsst.daf.base.PropertySet from a dict of key: value""" 

45 metadata = PropertySet() 

46 for key, val in keyValDict.items(): 

47 metadata.set(key, val) 

48 return metadata 

49 

50 

51def makeVisitInfo(data): 

52 """Return a VisitInfo constructed from a VisitInfoData namedtuple.""" 

53 return afwImage.VisitInfo(data.exposureId, 

54 data.exposureTime, 

55 data.darkTime, 

56 data.date, 

57 data.ut1, 

58 data.era, 

59 data.boresightRaDec, 

60 data.boresightAzAlt, 

61 data.boresightAirmass, 

62 data.boresightRotAngle, 

63 data.rotType, 

64 data.observatory, 

65 data.weather, 

66 data.instrumentLabel 

67 ) 

68 

69 

70class VisitInfoTestCase(lsst.utils.tests.TestCase): 

71 """Test lsst.afw.image.VisitInfo, a simple struct-like class""" 

72 

73 def setUp(self): 

74 self.testDir = os.path.dirname(__file__) 

75 

76 def computeLstHA(data): 

77 """Return LST, Hour Angle, computed from VisitInfoData.""" 

78 localEra = data.era + data.observatory.getLongitude() 

79 hourAngle = localEra - data.boresightRaDec[0] 

80 return localEra, hourAngle 

81 

82 fields = ['exposureId', 

83 'exposureTime', 

84 'darkTime', 

85 'date', 

86 'ut1', 

87 'era', 

88 'boresightRaDec', 

89 'boresightAzAlt', 

90 'boresightAirmass', 

91 'boresightRotAngle', 

92 'rotType', 

93 'observatory', 

94 'weather', 

95 'instrumentLabel' 

96 ] 

97 VisitInfoData = collections.namedtuple("VisitInfoData", fields) 

98 data1 = VisitInfoData(exposureId=10313423, 

99 exposureTime=10.01, 

100 darkTime=11.02, 

101 date=DateTime( 

102 65321.1, DateTime.MJD, DateTime.TAI), 

103 ut1=12345.1, 

104 era=45.1*degrees, 

105 boresightRaDec=SpherePoint( 

106 23.1*degrees, 73.2*degrees), 

107 boresightAzAlt=SpherePoint( 

108 134.5*degrees, 33.3*degrees), 

109 boresightAirmass=1.73, 

110 boresightRotAngle=73.2*degrees, 

111 rotType=afwImage.RotType.SKY, 

112 observatory=Observatory( 

113 11.1*degrees, 22.2*degrees, 0.333), 

114 weather=Weather(1.1, 2.2, 34.5), 

115 instrumentLabel="TestCameraOne", 

116 ) 

117 self.data1 = data1 

118 self.localEra1, self.hourAngle1 = computeLstHA(data1) 

119 data2 = VisitInfoData(exposureId=1, 

120 exposureTime=15.5, 

121 darkTime=17.8, 

122 date=DateTime( 

123 55321.2, DateTime.MJD, DateTime.TAI), 

124 ut1=312345.1, 

125 era=25.1*degrees, 

126 boresightRaDec=SpherePoint( 

127 2.1*degrees, 33.2*degrees), 

128 boresightAzAlt=SpherePoint(13.5*degrees, 83.3*degrees), 

129 boresightAirmass=2.05, 

130 boresightRotAngle=-53.2*degrees, 

131 rotType=afwImage.RotType.HORIZON, 

132 observatory=Observatory( 

133 22.2*degrees, 33.3*degrees, 0.444), 

134 weather=Weather(2.2, 3.3, 44.4), 

135 instrumentLabel="TestCameraTwo" 

136 ) 

137 self.data2 = data2 

138 self.localEra2, self.hourAngle2 = computeLstHA(data2) 

139 

140 def _testValueConstructor(self, data, localEra, hourAngle): 

141 visitInfo = makeVisitInfo(data) 

142 self.assertEqual(visitInfo.getExposureId(), data.exposureId) 

143 self.assertEqual(visitInfo.getExposureTime(), data.exposureTime) 

144 self.assertEqual(visitInfo.getDarkTime(), data.darkTime) 

145 self.assertEqual(visitInfo.getDate(), data.date) 

146 self.assertEqual(visitInfo.getUt1(), data.ut1) 

147 self.assertEqual(visitInfo.getEra(), data.era) 

148 self.assertEqual(visitInfo.getBoresightRaDec(), data.boresightRaDec) 

149 self.assertEqual(visitInfo.getBoresightAzAlt(), data.boresightAzAlt) 

150 self.assertEqual(visitInfo.getBoresightAirmass(), 

151 data.boresightAirmass) 

152 self.assertEqual(visitInfo.getBoresightRotAngle(), 

153 data.boresightRotAngle) 

154 self.assertEqual(visitInfo.getRotType(), data.rotType) 

155 self.assertEqual(visitInfo.getObservatory(), data.observatory) 

156 self.assertEqual(visitInfo.getInstrumentLabel(), data.instrumentLabel) 

157 self.assertEqual(visitInfo.getWeather(), data.weather) 

158 self.assertEqual(visitInfo.getLocalEra(), localEra) 

159 self.assertEqual(visitInfo.getBoresightHourAngle(), hourAngle) 

160 

161 def testValueConstructor_data1(self): 

162 self._testValueConstructor(self.data1, self.localEra1, self.hourAngle1) 

163 

164 def testValueConstructor_data2(self): 

165 self._testValueConstructor(self.data2, self.localEra2, self.hourAngle2) 

166 

167 def testTablePersistence(self): 

168 """Test that VisitInfo can be round-tripped with current code. 

169 """ 

170 for item in (self.data1, self.data2): 

171 tablePath = os.path.join( 

172 self.testDir, "testVisitInfo_testTablePersistence.fits") 

173 v1 = afwImage.VisitInfo(*item) 

174 v1.writeFits(tablePath) 

175 v2 = afwImage.VisitInfo.readFits(tablePath) 

176 self.assertEqual(v1, v2) 

177 os.unlink(tablePath) 

178 

179 def _testFitsRead(self, data, filePath, version): 

180 """Test that old VersionInfo files are read correctly. 

181 

182 Parameters 

183 ---------- 

184 data : `VisitInfoData` 

185 The values expected to be stored in the file, or a 

186 superset thereof. 

187 filePath : `str` 

188 The file to test. 

189 version : `int` 

190 The VersionInfo persistence format used in ``filePath``. 

191 """ 

192 visitInfo = afwImage.VisitInfo.readFits(filePath) 

193 

194 if version >= 0: 

195 self.assertEqual(visitInfo.getExposureId(), data.exposureId) 

196 self.assertEqual(visitInfo.getExposureTime(), data.exposureTime) 

197 self.assertEqual(visitInfo.getDarkTime(), data.darkTime) 

198 self.assertEqual(visitInfo.getDate(), data.date) 

199 self.assertEqual(visitInfo.getUt1(), data.ut1) 

200 self.assertEqual(visitInfo.getEra(), data.era) 

201 self.assertEqual(visitInfo.getBoresightRaDec(), data.boresightRaDec) 

202 self.assertEqual(visitInfo.getBoresightAzAlt(), data.boresightAzAlt) 

203 self.assertEqual(visitInfo.getBoresightAirmass(), 

204 data.boresightAirmass) 

205 self.assertEqual(visitInfo.getBoresightRotAngle(), 

206 data.boresightRotAngle) 

207 self.assertEqual(visitInfo.getRotType(), data.rotType) 

208 self.assertEqual(visitInfo.getObservatory(), data.observatory) 

209 self.assertEqual(visitInfo.getWeather(), data.weather) 

210 if version >= 1: 

211 self.assertEqual(visitInfo.getInstrumentLabel(), data.instrumentLabel) 

212 else: 

213 self.assertEqual(visitInfo.getInstrumentLabel(), "") 

214 

215 def testPersistenceVersions(self): 

216 """Test that older versions are handled appropriately. 

217 """ 

218 dataDir = os.path.join(os.path.dirname(__file__), "data") 

219 

220 # All files created by makeVisitInfo(self.data1).writeFits() 

221 self._testFitsRead(self.data1, os.path.join(dataDir, "visitInfo-noversion.fits"), 0) 

222 self._testFitsRead(self.data1, os.path.join(dataDir, "visitInfo-version-1.fits"), 1) 

223 

224 def testSetVisitInfoMetadata(self): 

225 for item in (self.data1, self.data2): 

226 visitInfo = makeVisitInfo(item) 

227 metadata = PropertyList() 

228 afwImage.setVisitInfoMetadata(metadata, visitInfo) 

229 self.assertEqual(metadata.nameCount(), 21) 

230 self.assertEqual(metadata.getScalar("EXPID"), item.exposureId) 

231 self.assertEqual(metadata.getScalar("EXPTIME"), item.exposureTime) 

232 self.assertEqual(metadata.getScalar("DARKTIME"), item.darkTime) 

233 self.assertEqual(metadata.getScalar("DATE-AVG"), 

234 item.date.toString(DateTime.TAI)) 

235 self.assertEqual(metadata.getScalar("TIMESYS"), "TAI") 

236 self.assertEqual(metadata.getScalar("MJD-AVG-UT1"), item.ut1) 

237 self.assertEqual(metadata.getScalar("AVG-ERA"), item.era.asDegrees()) 

238 self.assertEqual(metadata.getScalar("BORE-RA"), 

239 item.boresightRaDec[0].asDegrees()) 

240 self.assertEqual(metadata.getScalar("BORE-DEC"), 

241 item.boresightRaDec[1].asDegrees()) 

242 self.assertEqual(metadata.getScalar("BORE-AZ"), 

243 item.boresightAzAlt[0].asDegrees()) 

244 self.assertEqual(metadata.getScalar("BORE-ALT"), 

245 item.boresightAzAlt[1].asDegrees()) 

246 self.assertEqual(metadata.getScalar("BORE-AIRMASS"), 

247 item.boresightAirmass) 

248 self.assertEqual(metadata.getScalar("BORE-ROTANG"), 

249 item.boresightRotAngle.asDegrees()) 

250 self.assertEqual(metadata.getScalar("ROTTYPE"), 

251 RotTypeEnumNameDict[item.rotType]) 

252 self.assertEqual(metadata.getScalar("OBS-LONG"), 

253 item.observatory.getLongitude().asDegrees()) 

254 self.assertEqual(metadata.getScalar("OBS-LAT"), 

255 item.observatory.getLatitude().asDegrees()) 

256 self.assertEqual(metadata.getScalar("OBS-ELEV"), 

257 item.observatory.getElevation()) 

258 self.assertEqual(metadata.getScalar("AIRTEMP"), 

259 item.weather.getAirTemperature()) 

260 self.assertEqual(metadata.getScalar("AIRPRESS"), 

261 item.weather.getAirPressure()) 

262 self.assertEqual(metadata.getScalar("HUMIDITY"), 

263 item.weather.getHumidity()) 

264 self.assertEqual(metadata.getScalar("INSTRUMENT"), 

265 item.instrumentLabel) 

266 

267 def testSetVisitInfoMetadataMissingValues(self): 

268 """If a value is unknown then it should not be written to the metadata""" 

269 visitInfo = afwImage.VisitInfo() # only rot type is known 

270 metadata = PropertyList() 

271 afwImage.setVisitInfoMetadata(metadata, visitInfo) 

272 self.assertEqual(metadata.getScalar("ROTTYPE"), 

273 RotTypeEnumNameDict[afwImage.RotType.UNKNOWN]) 

274 self.assertEqual(metadata.nameCount(), 1) 

275 

276 def testStripVisitInfoKeywords(self): 

277 for argList in (self.data1, self.data2): 

278 visitInfo = afwImage.VisitInfo(*argList) 

279 metadata = PropertyList() 

280 afwImage.setVisitInfoMetadata(metadata, visitInfo) 

281 # add an extra keyword that will not be stripped 

282 metadata.set("EXTRA", 5) 

283 self.assertEqual(metadata.nameCount(), 22) 

284 afwImage.stripVisitInfoKeywords(metadata) 

285 self.assertEqual(metadata.nameCount(), 1) 

286 

287 def _testIsEmpty(self, visitInfo): 

288 """Test that visitInfo is all NaN, 0, or empty string, as appropriate. 

289 """ 

290 self.assertEqual(visitInfo.getExposureId(), 0) 

291 self.assertTrue(math.isnan(visitInfo.getExposureTime())) 

292 self.assertTrue(math.isnan(visitInfo.getDarkTime())) 

293 self.assertEqual(visitInfo.getDate(), DateTime()) 

294 self.assertTrue(math.isnan(visitInfo.getUt1())) 

295 self.assertTrue(math.isnan(visitInfo.getEra().asDegrees())) 

296 for i in range(2): 

297 self.assertTrue(math.isnan( 

298 visitInfo.getBoresightRaDec()[i].asDegrees())) 

299 self.assertTrue(math.isnan( 

300 visitInfo.getBoresightAzAlt()[i].asDegrees())) 

301 self.assertTrue(math.isnan(visitInfo.getBoresightAirmass())) 

302 self.assertTrue(math.isnan( 

303 visitInfo.getBoresightRotAngle().asDegrees())) 

304 self.assertEqual(visitInfo.getRotType(), afwImage.RotType.UNKNOWN) 

305 self.assertTrue(math.isnan( 

306 visitInfo.getObservatory().getLongitude().asDegrees())) 

307 self.assertTrue(math.isnan( 

308 visitInfo.getObservatory().getLatitude().asDegrees())) 

309 self.assertTrue(math.isnan(visitInfo.getObservatory().getElevation())) 

310 self.assertTrue(math.isnan(visitInfo.getWeather().getAirTemperature())) 

311 self.assertTrue(math.isnan(visitInfo.getWeather().getAirPressure())) 

312 self.assertTrue(math.isnan(visitInfo.getWeather().getHumidity())) 

313 self.assertTrue(math.isnan(visitInfo.getBoresightHourAngle())) 

314 self.assertEqual(visitInfo.getInstrumentLabel(), "") 

315 

316 def testMetadataConstructor(self): 

317 """Test the metadata constructor 

318 

319 This constructor allows missing values 

320 """ 

321 data = self.data1 

322 

323 metadata = propertySetFromDict({}) 

324 visitInfo = afwImage.VisitInfo(metadata) 

325 self._testIsEmpty(visitInfo) 

326 

327 metadata = propertySetFromDict({"EXPID": data.exposureId}) 

328 visitInfo = afwImage.VisitInfo(metadata) 

329 self.assertEqual(visitInfo.getExposureId(), data.exposureId) 

330 self.assertTrue(math.isnan(visitInfo.getExposureTime())) 

331 

332 metadata = propertySetFromDict({"EXPTIME": data.exposureTime}) 

333 visitInfo = afwImage.VisitInfo(metadata) 

334 self.assertEqual(visitInfo.getExposureTime(), data.exposureTime) 

335 

336 metadata = propertySetFromDict({"DARKTIME": data.darkTime}) 

337 visitInfo = afwImage.VisitInfo(metadata) 

338 self.assertEqual(visitInfo.getDarkTime(), data.darkTime) 

339 

340 metadata = propertySetFromDict( 

341 {"DATE-AVG": data.date.toString(DateTime.TAI), "TIMESYS": "TAI"}) 

342 visitInfo = afwImage.VisitInfo(metadata) 

343 self.assertEqual(visitInfo.getDate(), data.date) 

344 

345 # TIME-MID in UTC is an acceptable alternative to DATE-AVG 

346 metadata = propertySetFromDict( 

347 {"TIME-MID": data.date.toString(DateTime.UTC)}) 

348 visitInfo = afwImage.VisitInfo(metadata) 

349 self.assertEqual(visitInfo.getDate(), data.date) 

350 

351 # TIME-MID must be in UTC and TIMESYS is ignored 

352 metadata = propertySetFromDict({ 

353 "TIME-MID": data.date.toString(DateTime.TAI) + "Z", 

354 "TIMESYS": "TAI", 

355 }) 

356 visitInfo = afwImage.VisitInfo(metadata) 

357 self.assertNotEqual(visitInfo.getDate(), data.date) 

358 

359 # if both DATE-AVG and TIME-MID provided then use DATE-AVG 

360 # use the wrong time system for TIME-MID so if it is used, an error 

361 # will result 

362 metadata = propertySetFromDict({ 

363 "DATE-AVG": data.date.toString(DateTime.TAI), 

364 "TIMESYS": "TAI", 

365 "TIME-MID": data.date.toString(DateTime.TAI) + "Z", 

366 }) 

367 visitInfo = afwImage.VisitInfo(metadata) 

368 self.assertEqual(visitInfo.getDate(), data.date) 

369 

370 metadata = propertySetFromDict({"MJD-AVG-UT1": data.ut1}) 

371 visitInfo = afwImage.VisitInfo(metadata) 

372 self.assertEqual(visitInfo.getUt1(), data.ut1) 

373 

374 metadata = propertySetFromDict({"AVG-ERA": data.era.asDegrees()}) 

375 visitInfo = afwImage.VisitInfo(metadata) 

376 self.assertEqual(visitInfo.getEra(), data.era) 

377 

378 for i, key in enumerate(("BORE-RA", "BORE-DEC")): 

379 metadata = propertySetFromDict( 

380 {key: data.boresightRaDec[i].asDegrees()}) 

381 visitInfo = afwImage.VisitInfo(metadata) 

382 self.assertEqual(visitInfo.getBoresightRaDec() 

383 [i], data.boresightRaDec[i]) 

384 

385 for i, key in enumerate(("BORE-AZ", "BORE-ALT")): 

386 metadata = propertySetFromDict( 

387 {key: data.boresightAzAlt[i].asDegrees()}) 

388 visitInfo = afwImage.VisitInfo(metadata) 

389 self.assertEqual(visitInfo.getBoresightAzAlt() 

390 [i], data.boresightAzAlt[i]) 

391 

392 metadata = propertySetFromDict({"BORE-AIRMASS": data.boresightAirmass}) 

393 visitInfo = afwImage.VisitInfo(metadata) 

394 self.assertEqual(visitInfo.getBoresightAirmass(), 

395 data.boresightAirmass) 

396 

397 metadata = propertySetFromDict( 

398 {"BORE-ROTANG": data.boresightRotAngle.asDegrees()}) 

399 visitInfo = afwImage.VisitInfo(metadata) 

400 self.assertEqual(visitInfo.getBoresightRotAngle(), 

401 data.boresightRotAngle) 

402 

403 metadata = propertySetFromDict( 

404 {"ROTTYPE": RotTypeEnumNameDict[data.rotType]}) 

405 visitInfo = afwImage.VisitInfo(metadata) 

406 self.assertEqual(visitInfo.getRotType(), data.rotType) 

407 

408 metadata = propertySetFromDict( 

409 {"OBS-LONG": data.observatory.getLongitude().asDegrees()}) 

410 visitInfo = afwImage.VisitInfo(metadata) 

411 self.assertEqual(visitInfo.getObservatory().getLongitude(), 

412 data.observatory.getLongitude()) 

413 

414 metadata = propertySetFromDict( 

415 {"OBS-LAT": data.observatory.getLatitude().asDegrees()}) 

416 visitInfo = afwImage.VisitInfo(metadata) 

417 self.assertEqual(visitInfo.getObservatory().getLatitude(), 

418 data.observatory.getLatitude()) 

419 

420 metadata = propertySetFromDict( 

421 {"OBS-ELEV": data.observatory.getElevation()}) 

422 visitInfo = afwImage.VisitInfo(metadata) 

423 self.assertEqual(visitInfo.getObservatory().getElevation(), 

424 data.observatory.getElevation()) 

425 

426 metadata = propertySetFromDict( 

427 {"AIRTEMP": data.weather.getAirTemperature()}) 

428 visitInfo = afwImage.VisitInfo(metadata) 

429 self.assertEqual(visitInfo.getWeather().getAirTemperature(), 

430 data.weather.getAirTemperature()) 

431 

432 metadata = propertySetFromDict( 

433 {"AIRPRESS": data.weather.getAirPressure()}) 

434 visitInfo = afwImage.VisitInfo(metadata) 

435 self.assertEqual(visitInfo.getWeather().getAirPressure(), 

436 data.weather.getAirPressure()) 

437 

438 metadata = propertySetFromDict( 

439 {"HUMIDITY": data.weather.getHumidity()}) 

440 visitInfo = afwImage.VisitInfo(metadata) 

441 self.assertEqual(visitInfo.getWeather().getHumidity(), 

442 data.weather.getHumidity()) 

443 

444 metadata = propertySetFromDict({"INSTRUMENT": data.instrumentLabel}) 

445 visitInfo = afwImage.VisitInfo(metadata) 

446 self.assertEqual(visitInfo.getInstrumentLabel(), data.instrumentLabel) 

447 

448 def testConstructorKeywordArguments(self): 

449 """Test VisitInfo with named arguments""" 

450 data = self.data1 

451 

452 visitInfo = afwImage.VisitInfo() 

453 self._testIsEmpty(visitInfo) 

454 

455 visitInfo = afwImage.VisitInfo(exposureId=data.exposureId) 

456 self.assertEqual(visitInfo.getExposureId(), data.exposureId) 

457 self.assertTrue(math.isnan(visitInfo.getExposureTime())) 

458 

459 visitInfo = afwImage.VisitInfo(exposureTime=data.exposureTime) 

460 self.assertEqual(visitInfo.getExposureTime(), data.exposureTime) 

461 

462 visitInfo = afwImage.VisitInfo(darkTime=data.darkTime) 

463 self.assertEqual(visitInfo.getDarkTime(), data.darkTime) 

464 

465 visitInfo = afwImage.VisitInfo(date=data.date) 

466 self.assertEqual(visitInfo.getDate(), data.date) 

467 

468 visitInfo = afwImage.VisitInfo(ut1=data.ut1) 

469 self.assertEqual(visitInfo.getUt1(), data.ut1) 

470 

471 visitInfo = afwImage.VisitInfo(era=data.era) 

472 self.assertEqual(visitInfo.getEra(), data.era) 

473 

474 visitInfo = afwImage.VisitInfo(boresightRaDec=data.boresightRaDec) 

475 self.assertEqual(visitInfo.getBoresightRaDec(), data.boresightRaDec) 

476 

477 visitInfo = afwImage.VisitInfo(boresightAzAlt=data.boresightAzAlt) 

478 self.assertEqual(visitInfo.getBoresightAzAlt(), data.boresightAzAlt) 

479 

480 visitInfo = afwImage.VisitInfo(boresightAirmass=data.boresightAirmass) 

481 self.assertEqual(visitInfo.getBoresightAirmass(), 

482 data.boresightAirmass) 

483 

484 visitInfo = afwImage.VisitInfo( 

485 boresightRotAngle=data.boresightRotAngle) 

486 self.assertEqual(visitInfo.getBoresightRotAngle(), 

487 data.boresightRotAngle) 

488 

489 visitInfo = afwImage.VisitInfo(rotType=data.rotType) 

490 self.assertEqual(visitInfo.getRotType(), data.rotType) 

491 

492 visitInfo = afwImage.VisitInfo(observatory=data.observatory) 

493 self.assertEqual(visitInfo.getObservatory(), data.observatory) 

494 

495 visitInfo = afwImage.VisitInfo(weather=data.weather) 

496 self.assertEqual(visitInfo.getWeather(), data.weather) 

497 

498 visitInfo = afwImage.VisitInfo(instrumentLabel=data.instrumentLabel) 

499 self.assertEqual(visitInfo.getInstrumentLabel(), data.instrumentLabel) 

500 

501 def testGoodRotTypes(self): 

502 """Test round trip of all valid rot types""" 

503 for rotType in RotTypeEnumNameDict: 

504 metadata = propertySetFromDict( 

505 {"ROTTYPE": RotTypeEnumNameDict[rotType]}) 

506 visitInfo = afwImage.VisitInfo(metadata) 

507 self.assertEqual(visitInfo.getRotType(), rotType) 

508 

509 def testBadRotTypes(self): 

510 """Test that invalid rot type names cannot be used to construct a VisitInfo""" 

511 for badRotTypeName in ( 

512 "unknown", # must be all uppercase 

513 "sky", # must be all uppercase 

514 "Sky", # must be all uppercase 

515 "SKY1", # extra chars 

516 "HORIZONTAL", # extra chars 

517 ): 

518 metadata = propertySetFromDict({"ROTTYPE": badRotTypeName}) 

519 with self.assertRaises(lsst.pex.exceptions.RuntimeError): 

520 afwImage.VisitInfo(metadata) 

521 

522 def test_str(self): 

523 """Check that we get something reasonable for str()""" 

524 visitInfo = makeVisitInfo(self.data1) 

525 string = str(visitInfo) 

526 self.assertIn("exposureId=10313423", string) 

527 self.assertIn("exposureTime=10.01", string) 

528 self.assertIn("darkTime=11.02", string) 

529 self.assertIn("rotType=1", string) 

530 

531 def testParallacticAngle(self): 

532 """Check that we get the same precomputed values for parallactic angle.""" 

533 parallacticAngle = [141.39684140703142*degrees, 76.99982166973487*degrees] 

534 for item, parAngle in zip((self.data1, self.data2), parallacticAngle): 

535 visitInfo = afwImage.VisitInfo(era=item.era, 

536 boresightRaDec=item.boresightRaDec, 

537 observatory=item.observatory, 

538 ) 

539 self.assertAnglesAlmostEqual(visitInfo.getBoresightParAngle(), parAngle) 

540 

541 def testParallacticAngleNorthMeridian(self): 

542 """An observation on the Meridian that is North of zenith has a parallactic angle of pi radians.""" 

543 meridianBoresightRA = self.data1.era + self.data1.observatory.getLongitude() 

544 northBoresightDec = self.data1.observatory.getLatitude() + 10.*degrees 

545 visitInfo = afwImage.VisitInfo(era=self.data1.era, 

546 boresightRaDec=SpherePoint(meridianBoresightRA, 

547 northBoresightDec), 

548 observatory=self.data1.observatory, 

549 ) 

550 self.assertAnglesAlmostEqual(visitInfo.getBoresightParAngle(), Angle(np.pi)) 

551 

552 def testParallacticAngleSouthMeridian(self): 

553 """An observation on the Meridian that is South of zenith has a parallactic angle of zero.""" 

554 meridianBoresightRA = self.data1.era + self.data1.observatory.getLongitude() 

555 southBoresightDec = self.data1.observatory.getLatitude() - 10.*degrees 

556 visitInfo = afwImage.VisitInfo(era=self.data1.era, 

557 boresightRaDec=SpherePoint(meridianBoresightRA, 

558 southBoresightDec), 

559 observatory=self.data1.observatory, 

560 ) 

561 self.assertAnglesAlmostEqual(visitInfo.getBoresightParAngle(), Angle(0.)) 

562 

563 

564def setup_module(module): 

565 lsst.utils.tests.init() 

566 

567 

568class MemoryTester(lsst.utils.tests.MemoryTestCase): 

569 pass 

570 

571 

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

573 lsst.utils.tests.init() 

574 unittest.main()