1from builtins import zip 

2import unittest 

3import numpy as np 

4import lsst.utils.tests 

5import lsst.sims.utils as utils 

6from lsst.sims.utils import ObservationMetaData, Site, ModifiedJulianDate 

7 

8 

9def setup_module(module): 

10 lsst.utils.tests.init() 

11 

12 

13class testDegrees(unittest.TestCase): 

14 """ 

15 Test that all the pairs of methods that deal in degrees versus 

16 radians agree with each other. 

17 """ 

18 

19 def setUp(self): 

20 self.rng = np.random.RandomState(87334) 

21 self.raList = self.rng.random_sample(100) * 2.0 * np.pi 

22 self.decList = (self.rng.random_sample(100) - 0.5) * np.pi 

23 self.lon = self.rng.random_sample(1)[0] * 360.0 

24 self.lat = (self.rng.random_sample(1)[0] - 0.5) * 180.0 

25 

26 def testUnitConversion(self): 

27 """ 

28 Test that arcsecFromRadians, arcsecFromDegrees, 

29 radiansFromArcsec, and degreesFromArcsec are all 

30 self-consistent 

31 """ 

32 

33 radList = self.rng.random_sample(100) * 2.0 * np.pi 

34 degList = np.degrees(radList) 

35 

36 arcsecRadList = utils.arcsecFromRadians(radList) 

37 arcsecDegList = utils.arcsecFromDegrees(degList) 

38 

39 np.testing.assert_array_equal(arcsecRadList, arcsecDegList) 

40 

41 arcsecList = self.rng.random_sample(100) * 1.0 

42 radList = utils.radiansFromArcsec(arcsecList) 

43 degList = utils.degreesFromArcsec(arcsecList) 

44 np.testing.assert_array_equal(np.radians(degList), radList) 

45 

46 def testGalacticFromEquatorial(self): 

47 raList = self.raList 

48 decList = self.decList 

49 

50 lonRad, latRad = utils._galacticFromEquatorial(raList, decList) 

51 lonDeg, latDeg = utils.galacticFromEquatorial(np.degrees(raList), 

52 np.degrees(decList)) 

53 

54 np.testing.assert_array_almost_equal(lonRad, np.radians(lonDeg), 10) 

55 np.testing.assert_array_almost_equal(latRad, np.radians(latDeg), 10) 

56 

57 for ra, dec in zip(raList, decList): 

58 lonRad, latRad = utils._galacticFromEquatorial(ra, dec) 

59 lonDeg, latDeg = utils.galacticFromEquatorial( 

60 np.degrees(ra), np.degrees(dec)) 

61 self.assertAlmostEqual(lonRad, np.radians(lonDeg), 10) 

62 self.assertAlmostEqual(latRad, np.radians(latDeg), 10) 

63 

64 def testEquaorialFromGalactic(self): 

65 lonList = self.raList 

66 latList = self.decList 

67 

68 raRad, decRad = utils._equatorialFromGalactic(lonList, latList) 

69 raDeg, decDeg = utils.equatorialFromGalactic(np.degrees(lonList), 

70 np.degrees(latList)) 

71 

72 np.testing.assert_array_almost_equal(raRad, np.radians(raDeg), 10) 

73 np.testing.assert_array_almost_equal(decRad, np.radians(decDeg), 10) 

74 

75 for lon, lat in zip(lonList, latList): 

76 raRad, decRad = utils._equatorialFromGalactic(lon, lat) 

77 raDeg, decDeg = utils.equatorialFromGalactic( 

78 np.degrees(lon), np.degrees(lat)) 

79 self.assertAlmostEqual(raRad, np.radians(raDeg), 10) 

80 self.assertAlmostEqual(decRad, np.radians(decDeg), 10) 

81 

82 def testAltAzPaFromRaDec(self): 

83 mjd = 57432.7 

84 obs = ObservationMetaData(mjd=mjd, site=Site( 

85 longitude=self.lon, latitude=self.lat, name='LSST')) 

86 

87 altRad, azRad, paRad = utils._altAzPaFromRaDec( 

88 self.raList, self.decList, obs) 

89 

90 altDeg, azDeg, paDeg = utils.altAzPaFromRaDec(np.degrees(self.raList), 

91 np.degrees(self.decList), 

92 obs) 

93 

94 np.testing.assert_array_almost_equal(altRad, np.radians(altDeg), 10) 

95 np.testing.assert_array_almost_equal(azRad, np.radians(azDeg), 10) 

96 np.testing.assert_array_almost_equal(paRad, np.radians(paDeg), 10) 

97 

98 altRad, azRad, paRad = utils._altAzPaFromRaDec( 

99 self.raList, self.decList, obs) 

100 

101 altDeg, azDeg, paDeg = utils.altAzPaFromRaDec(np.degrees(self.raList), 

102 np.degrees(self.decList), 

103 obs) 

104 

105 np.testing.assert_array_almost_equal(altRad, np.radians(altDeg), 10) 

106 np.testing.assert_array_almost_equal(azRad, np.radians(azDeg), 10) 

107 np.testing.assert_array_almost_equal(paRad, np.radians(paDeg), 10) 

108 

109 for ra, dec, in zip(self.raList, self.decList): 

110 altRad, azRad, paRad = utils._altAzPaFromRaDec(ra, dec, obs) 

111 altDeg, azDeg, paDeg = utils.altAzPaFromRaDec(np.degrees(ra), 

112 np.degrees(dec), 

113 obs) 

114 

115 self.assertAlmostEqual(altRad, np.radians(altDeg), 10) 

116 self.assertAlmostEqual(azRad, np.radians(azDeg), 10) 

117 self.assertAlmostEqual(paRad, np.radians(paDeg), 10) 

118 

119 def testRaDecFromAltAz(self): 

120 azList = self.raList 

121 altList = self.decList 

122 mjd = 47895.6 

123 obs = ObservationMetaData(mjd=mjd, site=Site( 

124 longitude=self.lon, latitude=self.lat, name='LSST')) 

125 

126 raRad, decRad = utils._raDecFromAltAz(altList, azList, obs) 

127 

128 raDeg, decDeg = utils.raDecFromAltAz(np.degrees(altList), 

129 np.degrees(azList), obs) 

130 

131 np.testing.assert_array_almost_equal(raRad, np.radians(raDeg), 10) 

132 np.testing.assert_array_almost_equal(decRad, np.radians(decDeg), 10) 

133 

134 raRad, decRad = utils._raDecFromAltAz(altList, azList, obs) 

135 

136 raDeg, decDeg = utils.raDecFromAltAz(np.degrees(altList), 

137 np.degrees(azList), obs) 

138 

139 np.testing.assert_array_almost_equal(raRad, np.radians(raDeg), 10) 

140 np.testing.assert_array_almost_equal(decRad, np.radians(decDeg), 10) 

141 

142 for alt, az in zip(altList, azList): 

143 raRad, decRad = utils._raDecFromAltAz(alt, az, obs) 

144 raDeg, decDeg = utils.raDecFromAltAz(np.degrees(alt), 

145 np.degrees(az), obs) 

146 

147 self.assertAlmostEqual(raRad, np.radians(raDeg), 10) 

148 self.assertAlmostEqual(decRad, np.radians(decDeg), 10) 

149 

150 def testGetRotSkyPos(self): 

151 rotTelList = self.rng.random_sample(len(self.raList)) * 2.0 * np.pi 

152 mjd = 56321.8 

153 

154 obsTemp = ObservationMetaData(mjd=mjd, site=Site( 

155 longitude=self.lon, latitude=self.lat, name='LSST')) 

156 

157 rotSkyRad = utils._getRotSkyPos(self.raList, self.decList, 

158 obsTemp, rotTelList) 

159 

160 rotSkyDeg = utils.getRotSkyPos(np.degrees(self.raList), 

161 np.degrees(self.decList), 

162 obsTemp, np.degrees(rotTelList)) 

163 

164 np.testing.assert_array_almost_equal( 

165 rotSkyRad, np.radians(rotSkyDeg), 10) 

166 

167 rotSkyRad = utils._getRotSkyPos(self.raList, self.decList, 

168 obsTemp, rotTelList[0]) 

169 

170 rotSkyDeg = utils.getRotSkyPos(np.degrees(self.raList), 

171 np.degrees(self.decList), 

172 obsTemp, np.degrees(rotTelList[0])) 

173 

174 np.testing.assert_array_almost_equal( 

175 rotSkyRad, np.radians(rotSkyDeg), 10) 

176 

177 for ra, dec, rotTel in \ 

178 zip(self.raList, self.decList, rotTelList): 

179 

180 rotSkyRad = utils._getRotSkyPos(ra, dec, obsTemp, rotTel) 

181 

182 rotSkyDeg = utils.getRotSkyPos(np.degrees(ra), np.degrees(dec), 

183 obsTemp, np.degrees(rotTel)) 

184 

185 self.assertAlmostEqual(rotSkyRad, np.radians(rotSkyDeg), 10) 

186 

187 def testGetRotTelPos(self): 

188 rotSkyList = self.rng.random_sample(len(self.raList)) * 2.0 * np.pi 

189 mjd = 56789.3 

190 obsTemp = ObservationMetaData(mjd=mjd, site=Site(longitude=self.lon, 

191 latitude=self.lat, name='LSST')) 

192 

193 rotTelRad = utils._getRotTelPos(self.raList, self.decList, 

194 obsTemp, rotSkyList) 

195 

196 rotTelDeg = utils.getRotTelPos(np.degrees(self.raList), 

197 np.degrees(self.decList), 

198 obsTemp, np.degrees(rotSkyList)) 

199 

200 np.testing.assert_array_almost_equal( 

201 rotTelRad, np.radians(rotTelDeg), 10) 

202 

203 rotTelRad = utils._getRotTelPos(self.raList, self.decList, 

204 obsTemp, rotSkyList[0]) 

205 

206 rotTelDeg = utils.getRotTelPos(np.degrees(self.raList), 

207 np.degrees(self.decList), 

208 obsTemp, np.degrees(rotSkyList[0])) 

209 

210 np.testing.assert_array_almost_equal( 

211 rotTelRad, np.radians(rotTelDeg), 10) 

212 

213 for ra, dec, rotSky in \ 

214 zip(self.raList, self.decList, rotSkyList): 

215 

216 obsTemp = ObservationMetaData(mjd=mjd, site=Site( 

217 longitude=self.lon, latitude=self.lat, name='LSST')) 

218 

219 rotTelRad = utils._getRotTelPos(ra, dec, obsTemp, rotSky) 

220 

221 rotTelDeg = utils.getRotTelPos(np.degrees(ra), np.degrees(dec), 

222 obsTemp, np.degrees(rotSky)) 

223 

224 self.assertAlmostEqual(rotTelRad, np.radians(rotTelDeg), 10) 

225 

226 

227class AstrometryDegreesTest(unittest.TestCase): 

228 

229 def setUp(self): 

230 self.nStars = 10 

231 self.rng = np.random.RandomState(8273) 

232 self.raList = self.rng.random_sample(self.nStars) * 2.0 * np.pi 

233 self.decList = (self.rng.random_sample(self.nStars) - 0.5) * np.pi 

234 self.mjdList = self.rng.random_sample(10) * 5000.0 + 52000.0 

235 self.pm_raList = utils.radiansFromArcsec( 

236 self.rng.random_sample(self.nStars) * 10.0 - 5.0) 

237 self.pm_decList = utils.radiansFromArcsec( 

238 self.rng.random_sample(self.nStars) * 10.0 - 5.0) 

239 self.pxList = utils.radiansFromArcsec( 

240 self.rng.random_sample(self.nStars) * 2.0) 

241 self.v_radList = self.rng.random_sample(self.nStars) * 500.0 - 250.0 

242 

243 def testApplyPrecession(self): 

244 for mjd in self.mjdList: 

245 raRad, decRad = utils._applyPrecession(self.raList, 

246 self.decList, 

247 mjd=ModifiedJulianDate(TAI=mjd)) 

248 

249 raDeg, decDeg = utils.applyPrecession(np.degrees(self.raList), 

250 np.degrees(self.decList), 

251 mjd=ModifiedJulianDate(TAI=mjd)) 

252 

253 dRa = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

254 np.testing.assert_array_almost_equal(dRa, np.zeros(self.nStars), 9) 

255 

256 dDec = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

257 np.testing.assert_array_almost_equal( 

258 dDec, np.zeros(self.nStars), 9) 

259 

260 def testApplyProperMotion(self): 

261 for mjd in self.mjdList: 

262 raRad, decRad = utils._applyProperMotion(self.raList, self.decList, 

263 self.pm_raList, self.pm_decList, 

264 self.pxList, self.v_radList, 

265 mjd=ModifiedJulianDate(TAI=mjd)) 

266 

267 raDeg, decDeg = utils.applyProperMotion(np.degrees(self.raList), 

268 np.degrees(self.decList), 

269 utils.arcsecFromRadians( 

270 self.pm_raList), 

271 utils.arcsecFromRadians( 

272 self.pm_decList), 

273 utils.arcsecFromRadians( 

274 self.pxList), 

275 self.v_radList, 

276 mjd=ModifiedJulianDate(TAI=mjd)) 

277 

278 dRa = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

279 np.testing.assert_array_almost_equal(dRa, np.zeros(self.nStars), 9) 

280 

281 dDec = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

282 np.testing.assert_array_almost_equal( 

283 dDec, np.zeros(self.nStars), 9) 

284 

285 for ra, dec, pm_ra, pm_dec, px, v_rad in \ 

286 zip(self.raList, self.decList, self.pm_raList, self.pm_decList, 

287 self.pxList, self.v_radList): 

288 

289 raRad, decRad = utils._applyProperMotion(ra, dec, pm_ra, pm_dec, px, v_rad, 

290 mjd=ModifiedJulianDate(TAI=self.mjdList[0])) 

291 

292 raDeg, decDeg = utils.applyProperMotion(np.degrees(ra), np.degrees(dec), 

293 utils.arcsecFromRadians(pm_ra), 

294 utils.arcsecFromRadians(pm_dec), 

295 utils.arcsecFromRadians(px), v_rad, 

296 mjd=ModifiedJulianDate(TAI=self.mjdList[0])) 

297 

298 self.assertAlmostEqual(utils.arcsecFromRadians( 

299 raRad - np.radians(raDeg)), 0.0, 9) 

300 self.assertAlmostEqual(utils.arcsecFromRadians( 

301 decRad - np.radians(decDeg)), 0.0, 9) 

302 

303 def testAppGeoFromICRS(self): 

304 mjd = 42350.0 

305 for pmRaList in [self.pm_raList, None]: 

306 for pmDecList in [self.pm_decList, None]: 

307 for pxList in [self.pxList, None]: 

308 for vRadList in [self.v_radList, None]: 

309 raRad, decRad = utils._appGeoFromICRS(self.raList, self.decList, 

310 pmRaList, pmDecList, 

311 pxList, vRadList, 

312 mjd=ModifiedJulianDate(TAI=mjd)) 

313 

314 raDeg, decDeg = utils.appGeoFromICRS(np.degrees(self.raList), 

315 np.degrees(self.decList), 

316 utils.arcsecFromRadians(pmRaList), 

317 utils.arcsecFromRadians(pmDecList), 

318 utils.arcsecFromRadians(pxList), 

319 vRadList, 

320 mjd=ModifiedJulianDate(TAI=mjd)) 

321 

322 dRa = utils.arcsecFromRadians( 

323 raRad - np.radians(raDeg)) 

324 np.testing.assert_array_almost_equal( 

325 dRa, np.zeros(self.nStars), 9) 

326 

327 dDec = utils.arcsecFromRadians( 

328 raRad - np.radians(raDeg)) 

329 np.testing.assert_array_almost_equal( 

330 dDec, np.zeros(self.nStars), 9) 

331 

332 def testObservedFromAppGeo(self): 

333 obs = ObservationMetaData(pointingRA=35.0, pointingDec=-45.0, 

334 mjd=43572.0) 

335 

336 for includeRefraction in [True, False]: 

337 raRad, decRad = utils._observedFromAppGeo(self.raList, self.decList, 

338 includeRefraction=includeRefraction, 

339 altAzHr=False, obs_metadata=obs) 

340 

341 raDeg, decDeg = utils.observedFromAppGeo(np.degrees(self.raList), 

342 np.degrees(self.decList), 

343 includeRefraction=includeRefraction, 

344 altAzHr=False, obs_metadata=obs) 

345 

346 dRa = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

347 np.testing.assert_array_almost_equal(dRa, np.zeros(self.nStars), 9) 

348 

349 dDec = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

350 np.testing.assert_array_almost_equal( 

351 dDec, np.zeros(self.nStars), 9) 

352 

353 raDec, altAz = utils._observedFromAppGeo(self.raList, self.decList, 

354 includeRefraction=includeRefraction, 

355 altAzHr=True, obs_metadata=obs) 

356 

357 raRad = raDec[0] 

358 altRad = altAz[0] 

359 azRad = altAz[1] 

360 

361 raDec, altAz = utils.observedFromAppGeo(np.degrees(self.raList), 

362 np.degrees(self.decList), 

363 includeRefraction=includeRefraction, 

364 altAzHr=True, obs_metadata=obs) 

365 

366 raDeg = raDec[0] 

367 altDeg = altAz[0] 

368 azDeg = altAz[1] 

369 

370 dRa = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

371 np.testing.assert_array_almost_equal(dRa, np.zeros(self.nStars), 9) 

372 

373 dDec = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

374 np.testing.assert_array_almost_equal( 

375 dDec, np.zeros(self.nStars), 9) 

376 

377 dAz = utils.arcsecFromRadians(azRad - np.radians(azDeg)) 

378 np.testing.assert_array_almost_equal(dAz, np.zeros(self.nStars), 9) 

379 

380 dAlt = utils.arcsecFromRadians(altRad - np.radians(altDeg)) 

381 np.testing.assert_array_almost_equal( 

382 dAlt, np.zeros(self.nStars), 9) 

383 

384 def testAppGeoFromObserved(self): 

385 obs = ObservationMetaData(pointingRA=35.0, pointingDec=-45.0, 

386 mjd=43572.0) 

387 

388 for includeRefraction in (True, False): 

389 for wavelength in (0.5, 0.2, 0.3): 

390 

391 raRad, decRad = utils._appGeoFromObserved(self.raList, self.decList, 

392 includeRefraction=includeRefraction, 

393 wavelength=wavelength, 

394 obs_metadata=obs) 

395 

396 raDeg, decDeg = utils.appGeoFromObserved(np.degrees(self.raList), np.degrees(self.decList), 

397 includeRefraction=includeRefraction, 

398 wavelength=wavelength, 

399 obs_metadata=obs) 

400 

401 dRa = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

402 np.testing.assert_array_almost_equal(dRa, np.zeros(len(dRa)), 9) 

403 

404 dDec = utils.arcsecFromRadians(decRad - np.radians(decDeg)) 

405 np.testing.assert_array_almost_equal(dDec, np.zeros(len(dDec)), 9) 

406 

407 def testIcrsFromAppGeo(self): 

408 

409 for mjd in (53525.0, 54316.3, 58463.7): 

410 for epoch in(2000.0, 1950.0, 2010.0): 

411 

412 raRad, decRad = utils._icrsFromAppGeo(self.raList, self.decList, 

413 epoch=epoch, 

414 mjd=ModifiedJulianDate(TAI=mjd)) 

415 

416 raDeg, decDeg = utils.icrsFromAppGeo(np.degrees(self.raList), 

417 np.degrees(self.decList), 

418 epoch=epoch, mjd=ModifiedJulianDate(TAI=mjd)) 

419 

420 dRa = utils.arcsecFromRadians(np.abs(raRad - np.radians(raDeg))) 

421 self.assertLess(dRa.max(), 1.0e-9) 

422 

423 dDec = utils.arcsecFromRadians(np.abs(decRad - np.radians(decDeg))) 

424 self.assertLess(dDec.max(), 1.0e-9) 

425 

426 def testObservedFromICRS(self): 

427 obs = ObservationMetaData(pointingRA=35.0, pointingDec=-45.0, mjd=43572.0) 

428 for pmRaList in [self.pm_raList, None]: 

429 for pmDecList in [self.pm_decList, None]: 

430 for pxList in [self.pxList, None]: 

431 for vRadList in [self.v_radList, None]: 

432 for includeRefraction in [True, False]: 

433 

434 raRad, decRad = utils._observedFromICRS(self.raList, self.decList, 

435 pm_ra=pmRaList, pm_dec=pmDecList, 

436 parallax=pxList, v_rad=vRadList, 

437 obs_metadata=obs, epoch=2000.0, 

438 includeRefraction=includeRefraction) 

439 

440 raDeg, decDeg = utils.observedFromICRS(np.degrees(self.raList), 

441 np.degrees(self.decList), 

442 pm_ra=utils.arcsecFromRadians(pmRaList), 

443 pm_dec=utils.arcsecFromRadians(pmDecList), 

444 parallax=utils.arcsecFromRadians(pxList), 

445 v_rad=vRadList, 

446 obs_metadata=obs, epoch=2000.0, 

447 includeRefraction=includeRefraction) 

448 

449 dRa = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

450 np.testing.assert_array_almost_equal(dRa, np.zeros(self.nStars), 9) 

451 

452 dDec = utils.arcsecFromRadians(decRad - np.radians(decDeg)) 

453 np.testing.assert_array_almost_equal(dDec, np.zeros(self.nStars), 9) 

454 

455 def testIcrsFromObserved(self): 

456 obs = ObservationMetaData(pointingRA=35.0, pointingDec=-45.0, 

457 mjd=43572.0) 

458 

459 for includeRefraction in [True, False]: 

460 

461 raRad, decRad = utils._icrsFromObserved(self.raList, self.decList, 

462 obs_metadata=obs, epoch=2000.0, 

463 includeRefraction=includeRefraction) 

464 

465 raDeg, decDeg = utils.icrsFromObserved(np.degrees(self.raList), np.degrees(self.decList), 

466 obs_metadata=obs, epoch=2000.0, 

467 includeRefraction=includeRefraction) 

468 

469 dRa = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

470 np.testing.assert_array_almost_equal(dRa, np.zeros(self.nStars), 9) 

471 

472 dDec = utils.arcsecFromRadians(decRad - np.radians(decDeg)) 

473 np.testing.assert_array_almost_equal(dDec, np.zeros(self.nStars), 9) 

474 

475 def testraDecFromPupilCoords(self): 

476 obs = ObservationMetaData(pointingRA=23.5, pointingDec=-115.0, mjd=42351.0, rotSkyPos=127.0) 

477 

478 xpList = self.rng.random_sample(100) * 0.25 * np.pi 

479 ypList = self.rng.random_sample(100) * 0.25 * np.pi 

480 

481 raRad, decRad = utils._raDecFromPupilCoords(xpList, ypList, obs_metadata=obs, epoch=2000.0) 

482 raDeg, decDeg = utils.raDecFromPupilCoords(xpList, ypList, obs_metadata=obs, epoch=2000.0) 

483 

484 dRa = utils.arcsecFromRadians(raRad - np.radians(raDeg)) 

485 np.testing.assert_array_almost_equal(dRa, np.zeros(len(xpList)), 9) 

486 

487 dDec = utils.arcsecFromRadians(decRad - np.radians(decDeg)) 

488 np.testing.assert_array_almost_equal(dDec, np.zeros(len(xpList)), 9) 

489 

490 def testpupilCoordsFromRaDec(self): 

491 obs = ObservationMetaData(pointingRA=23.5, pointingDec=-115.0, mjd=42351.0, rotSkyPos=127.0) 

492 

493 # need to make sure the test points are tightly distributed around the bore site, or 

494 # PALPY will throw an error 

495 raList = self.rng.random_sample(self.nStars) * np.radians(1.0) + np.radians(23.5) 

496 decList = self.rng.random_sample(self.nStars) * np.radians(1.0) + np.radians(-115.0) 

497 

498 xpControl, ypControl = utils._pupilCoordsFromRaDec(raList, decList, 

499 obs_metadata=obs, epoch=2000.0) 

500 

501 xpTest, ypTest = utils.pupilCoordsFromRaDec(np.degrees(raList), np.degrees(decList), 

502 obs_metadata=obs, epoch=2000.0) 

503 

504 dx = utils.arcsecFromRadians(xpControl - xpTest) 

505 np.testing.assert_array_almost_equal(dx, np.zeros(self.nStars), 9) 

506 

507 dy = utils.arcsecFromRadians(ypControl - ypTest) 

508 np.testing.assert_array_almost_equal(dy, np.zeros(self.nStars), 9) 

509 

510 

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

512 pass 

513 

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

515 lsst.utils.tests.init() 

516 unittest.main()