Coverage for tests/testLsstCameraUtils.py : 8%

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
3import unittest
4import numpy as np
5import lsst.utils.tests
6from lsst.sims.coordUtils import (chipNameFromPupilCoords,
7 chipNameFromPupilCoordsLSST,
8 _chipNameFromRaDec, chipNameFromRaDec,
9 _chipNameFromRaDecLSST, chipNameFromRaDecLSST,
10 _pixelCoordsFromRaDec, pixelCoordsFromRaDec,
11 _pixelCoordsFromRaDecLSST, pixelCoordsFromRaDecLSST,
12 pixelCoordsFromPupilCoords)
13from lsst.sims.coordUtils import lsst_camera
14from lsst.sims.coordUtils import focalPlaneCoordsFromPupilCoordsLSST
15from lsst.sims.utils import pupilCoordsFromRaDec, radiansFromArcsec
16from lsst.sims.utils import ObservationMetaData
17from lsst.obs.lsstSim import LsstSimMapper
18from lsst.sims.utils import angularSeparation
20from lsst.sims.coordUtils import clean_up_lsst_camera
22def setup_module(module):
23 lsst.utils.tests.init()
26class ChipNameTestCase(unittest.TestCase):
28 longMessage = True
30 @classmethod
31 def setUpClass(cls):
32 cls.camera = LsstSimMapper().camera
34 @classmethod
35 def tearDownClass(cls):
36 del cls.camera
37 clean_up_lsst_camera()
39 def test_outside_radius(self):
40 """
41 Test that methods can gracefully handle points
42 outside of the focal plane
43 """
44 rng = np.random.RandomState(7123)
45 ra = 145.0
46 dec = -25.0
47 obs = ObservationMetaData(pointingRA=ra, pointingDec=dec,
48 mjd=59580.0, rotSkyPos=113.0)
50 rr = rng.random_sample(100)*5.0
51 self.assertGreater(rr.max(), 4.5)
52 theta = rng.random_sample(100)*2.0*np.pi
53 ra_vec = ra + rr*np.cos(theta)
54 dec_vec = dec + rr*np.sin(theta)
55 chip_name_list = chipNameFromRaDecLSST(ra_vec, dec_vec,
56 obs_metadata=obs,
57 band='u')
59 rr = angularSeparation(ra, dec, ra_vec, dec_vec)
61 ct_none = 0
62 for rr, name in zip(rr, chip_name_list):
63 if rr > 2.0:
64 self.assertIsNone(name)
65 ct_none += 1
66 self.assertGreater(ct_none, 0)
68 def test_chip_center(self):
69 """
70 Test that, if we ask for the chip at the bore site,
71 we get back 'R:2,2 S:1,1'
72 """
74 ra = 145.0
75 dec = -25.0
76 obs = ObservationMetaData(pointingRA=ra, pointingDec=dec,
77 mjd=59580.0, rotSkyPos=113.0)
79 name = chipNameFromRaDecLSST(ra, dec, obs_metadata=obs)
80 self.assertEqual(name, 'R:2,2 S:1,1')
82 def test_one_by_one(self):
83 """
84 test that running RA, Dec pairs in one at a time gives the same
85 results as running them in in batches
86 """
88 ra = 145.0
89 dec = -25.0
90 obs = ObservationMetaData(pointingRA=ra, pointingDec=dec,
91 mjd=59580.0, rotSkyPos=113.0)
92 rng = np.random.RandomState(100)
93 theta = rng.random_sample(100)*2.0*np.pi
94 rr = rng.random_sample(len(theta))*2.0
95 ra_list = ra + rr*np.cos(theta)
96 dec_list = dec + rr*np.sin(theta)
97 name_control = chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs)
98 is_none = 0
99 for ra, dec, name in zip(ra_list, dec_list, name_control):
100 test_name = chipNameFromRaDecLSST(ra, dec, obs_metadata=obs)
101 self.assertEqual(test_name, name)
102 if test_name is None:
103 is_none += 1
105 self.assertGreater(is_none, 0)
106 self.assertLess(is_none, (3*len(ra_list))//4)
108 def test_chip_name_from_ra_dec_radians(self):
109 """
110 test that _chipNameFromRaDecLSST agrees with _chipNameFromRaDec
111 """
113 n_obj = 1000
114 raP = 112.1
115 decP = -34.1
116 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP,
117 rotSkyPos=45.0, mjd=43000.0)
119 rng = np.random.RandomState(8731)
120 rr = rng.random_sample(n_obj)*1.75
121 theta = rng.random_sample(n_obj)*2.0*np.pi
122 ra_list = np.radians(raP + rr*np.cos(theta))
123 dec_list = np.radians(decP + rr*np.sin(theta))
124 control_name_list = _chipNameFromRaDec(ra_list, dec_list,
125 obs_metadata=obs,
126 camera=self.camera)
128 test_name_list = _chipNameFromRaDecLSST(ra_list, dec_list,
129 obs_metadata=obs)
131 try:
132 np.testing.assert_array_equal(control_name_list.astype(str),
133 test_name_list.astype(str))
134 except AssertionError:
135 n_problematic = 0
136 for ii, (c_n, t_n) in enumerate(zip(control_name_list.astype(str), test_name_list.astype(str))):
137 if c_n != t_n:
138 x_pix, y_pix = pixelCoordsFromRaDecLSST(ra_list[ii], dec_list[ii], obs_metadata=obs)
139 if c_n != 'None':
140 n_problematic += 1
141 if n_problematic > 0:
142 raise
144 self.assertLessEqual(len(np.where(np.char.rfind(test_name_list.astype(str), 'None') >= 0)[0]),
145 n_obj/10)
147 # test that exceptions are raised when incomplete ObservationMetaData are used
148 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, mjd=59580.0)
149 with self.assertRaises(RuntimeError) as context:
150 _chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs)
151 self.assertIn("rotSkyPos", context.exception.args[0])
153 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=35.0)
154 with self.assertRaises(RuntimeError) as context:
155 _chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs)
156 self.assertIn("mjd", context.exception.args[0])
158 with self.assertRaises(RuntimeError) as context:
159 _chipNameFromRaDecLSST(ra_list, dec_list)
160 self.assertIn("ObservationMetaData", context.exception.args[0])
162 # check that exceptions are raised when ra_list, dec_list are of the wrong shape
163 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=24.0, mjd=43000.0)
164 with self.assertRaises(RuntimeError) as context:
165 _chipNameFromRaDecLSST(ra_list, dec_list[:5], obs_metadata=obs)
166 self.assertIn("chipNameFromRaDecLSST", context.exception.args[0])
168 def test_chip_name_from_ra_dec_degrees(self):
169 """
170 test that chipNameFromRaDecLSST agrees with chipNameFromRaDec
171 """
173 n_obj = 1000
174 raP = 112.1
175 decP = -34.1
176 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP,
177 rotSkyPos=45.0, mjd=43000.0)
179 rng = np.random.RandomState(8731)
180 rr = rng.random_sample(n_obj)*1.75
181 theta = rng.random_sample(n_obj)*2.0*np.pi
182 ra_list = raP + rr*np.cos(theta)
183 dec_list = decP + rr*np.sin(theta)
184 control_name_list = chipNameFromRaDec(ra_list, dec_list,
185 obs_metadata=obs,
186 camera=self.camera)
188 test_name_list = chipNameFromRaDecLSST(ra_list, dec_list,
189 obs_metadata=obs)
191 try:
192 np.testing.assert_array_equal(control_name_list.astype(str),
193 test_name_list.astype(str))
194 except AssertionError:
195 n_problematic = 0
196 for ii, (c_n, t_n) in enumerate(zip(control_name_list.astype(str), test_name_list.astype(str))):
197 if c_n != t_n:
198 x_pix, y_pix = pixelCoordsFromRaDecLSST(ra_list[ii], dec_list[ii], obs_metadata=obs)
199 if c_n != 'None':
200 n_problematic += 1
201 if n_problematic > 0:
202 raise
204 self.assertLessEqual(len(np.where(np.char.rfind(test_name_list.astype(str), 'None') >= 0)[0]),
205 n_obj/10)
207 # test that exceptions are raised when incomplete ObservationMetaData are used
208 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, mjd=59580.0)
209 with self.assertRaises(RuntimeError) as context:
210 chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs)
211 self.assertIn("rotSkyPos", context.exception.args[0])
213 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=35.0)
214 with self.assertRaises(RuntimeError) as context:
215 chipNameFromRaDecLSST(ra_list, dec_list, obs_metadata=obs)
216 self.assertIn("mjd", context.exception.args[0])
218 with self.assertRaises(RuntimeError) as context:
219 chipNameFromRaDecLSST(ra_list, dec_list)
220 self.assertIn("ObservationMetaData", context.exception.args[0])
222 # check that exceptions are raised when ra_list, dec_list are of the wrong shape
223 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=24.0, mjd=43000.0)
224 with self.assertRaises(RuntimeError) as context:
225 chipNameFromRaDecLSST(ra_list, dec_list[:5], obs_metadata=obs)
226 self.assertIn("chipNameFromRaDecLSST", context.exception.args[0])
228 def test_pixel_coords_from_ra_dec_radians(self):
229 """
230 Test that _pixelCoordsFromRaDec and _pixelCoordsFromRaDecLSST agree
231 """
232 raP = 74.2
233 decP = 13.0
234 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP,
235 rotSkyPos=13.0, mjd=43441.0)
237 n_obj = 1000
238 rng = np.random.RandomState(83241)
239 rr = rng.random_sample(n_obj)*1.75
240 theta = rng.random_sample(n_obj)*2.0*np.pi
241 ra_list = np.radians(raP + rr*np.cos(theta))
242 dec_list = np.radians(decP + rr*np.sin(theta))
244 x_pix, y_pix = _pixelCoordsFromRaDec(ra_list, dec_list, obs_metadata=obs, camera=self.camera,
245 includeDistortion=False)
246 self.assertLessEqual(len(np.where(np.isnan(x_pix))[0]), n_obj/10)
247 self.assertLessEqual(len(np.where(np.isnan(y_pix))[0]), n_obj/10)
249 x_pix_test, y_pix_test = _pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs,
250 includeDistortion=False)
252 try:
253 np.testing.assert_array_equal(x_pix, x_pix_test)
254 np.testing.assert_array_equal(y_pix, y_pix_test)
255 except AssertionError:
256 n_problematic = 0
257 for xx, yy, xt, yt in zip(x_pix, y_pix, x_pix_test, y_pix_test):
258 if xx!=xt or yy!=yt:
259 if (not np.isnan(xx) and not np.isnan(xt) and
260 not np.isnan(yy) and not np.isnan(yt)):
261 print(xx,yy,xt,yt)
263 n_problematic += 1
264 if n_problematic>0:
265 raise
267 # test when we force a chipName
268 x_pix, y_pix = _pixelCoordsFromRaDec(ra_list, dec_list, chipName=['R:2,2 S:1,1'],
269 obs_metadata=obs, camera=self.camera,
270 includeDistortion=False)
271 self.assertLessEqual(len(np.where(np.isnan(x_pix))[0]), n_obj/10)
272 self.assertLessEqual(len(np.where(np.isnan(y_pix))[0]), n_obj/10)
274 x_pix_test, y_pix_test = _pixelCoordsFromRaDecLSST(ra_list, dec_list, chipName=['R:2,2 S:1,1'],
275 obs_metadata=obs,
276 includeDistortion=False)
277 np.testing.assert_array_equal(x_pix, x_pix_test)
278 np.testing.assert_array_equal(y_pix, y_pix_test)
280 # test without distortion
281 x_pix, y_pix = _pixelCoordsFromRaDec(ra_list, dec_list, obs_metadata=obs, camera=self.camera,
282 includeDistortion=False)
283 self.assertLessEqual(len(np.where(np.isnan(x_pix))[0]), n_obj/10)
284 self.assertLessEqual(len(np.where(np.isnan(y_pix))[0]), n_obj/10)
286 x_pix_test, y_pix_test = _pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs,
287 includeDistortion=False)
288 try:
289 np.testing.assert_array_equal(x_pix, x_pix_test)
290 np.testing.assert_array_equal(y_pix, y_pix_test)
291 except AssertionError:
292 n_problematic = 0
293 for xx, yy, xt, yt in zip(x_pix, y_pix, x_pix_test, y_pix_test):
294 if xx!=xt or yy!=yt:
295 if (not np.isnan(xx) and not np.isnan(xt) and
296 not np.isnan(yy) and not np.isnan(yt)):
297 print(xx,yy,xt,yt)
299 n_problematic += 1
300 if n_problematic>0:
301 raise
304 # test that exceptions are raised when incomplete ObservationMetaData are used
305 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, mjd=59580.0)
306 with self.assertRaises(RuntimeError) as context:
307 _pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs)
308 self.assertIn("rotSkyPos", context.exception.args[0])
310 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=35.0)
311 with self.assertRaises(RuntimeError) as context:
312 _pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs)
313 self.assertIn("mjd", context.exception.args[0])
315 with self.assertRaises(RuntimeError) as context:
316 _pixelCoordsFromRaDecLSST(ra_list, dec_list)
317 self.assertIn("ObservationMetaData", context.exception.args[0])
319 # check that exceptions are raised when ra_list, dec_list are of the wrong shape
320 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=24.0, mjd=43000.0)
321 with self.assertRaises(RuntimeError) as context:
322 _pixelCoordsFromRaDecLSST(ra_list, dec_list[:5], obs_metadata=obs)
323 self.assertIn("same length", context.exception.args[0])
325 def test_pixel_coords_from_ra_dec_degrees(self):
326 """
327 Test that pixelCoordsFromRaDec and pixelCoordsFromRaDecLSST agree
328 """
329 raP = 74.2
330 decP = 13.0
331 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP,
332 rotSkyPos=13.0, mjd=43441.0)
334 n_obj = 1000
335 rng = np.random.RandomState(83241)
336 rr = rng.random_sample(n_obj)*1.75
337 theta = rng.random_sample(n_obj)*2.0*np.pi
338 ra_list = raP + rr*np.cos(theta)
339 dec_list = decP + rr*np.sin(theta)
341 x_pix, y_pix = pixelCoordsFromRaDec(ra_list, dec_list, obs_metadata=obs, camera=self.camera,
342 includeDistortion=False)
343 self.assertLessEqual(len(np.where(np.isnan(x_pix))[0]), n_obj/10)
344 self.assertLessEqual(len(np.where(np.isnan(y_pix))[0]), n_obj/10)
346 x_pix_test, y_pix_test = pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs,
347 includeDistortion=False)
348 try:
349 np.testing.assert_array_equal(x_pix, x_pix_test)
350 np.testing.assert_array_equal(y_pix, y_pix_test)
351 except AssertionError:
352 n_problematic = 0
353 for xx, yy, xt, yt in zip(x_pix, y_pix, x_pix_test, y_pix_test):
354 if xx!=xt or yy!=yt:
355 if (not np.isnan(xx) and not np.isnan(xt) and
356 not np.isnan(yy) and not np.isnan(yt)):
357 print(xx,yy,xt,yt)
359 n_problematic += 1
360 if n_problematic>0:
361 raise
363 # test when we force a chipName
364 x_pix, y_pix = pixelCoordsFromRaDec(ra_list, dec_list, chipName=['R:2,2 S:1,1'],
365 obs_metadata=obs, camera=self.camera,
366 includeDistortion=False)
367 self.assertLessEqual(len(np.where(np.isnan(x_pix))[0]), n_obj/10)
368 self.assertLessEqual(len(np.where(np.isnan(y_pix))[0]), n_obj/10)
370 x_pix_test, y_pix_test = pixelCoordsFromRaDecLSST(ra_list, dec_list, chipName=['R:2,2 S:1,1'],
371 obs_metadata=obs,
372 includeDistortion=False)
373 np.testing.assert_array_equal(x_pix, x_pix_test)
374 np.testing.assert_array_equal(y_pix, y_pix_test)
376 # test without distortion
377 x_pix, y_pix = pixelCoordsFromRaDec(ra_list, dec_list, obs_metadata=obs, camera=self.camera,
378 includeDistortion=False)
379 self.assertLessEqual(len(np.where(np.isnan(x_pix))[0]), n_obj/10)
380 self.assertLessEqual(len(np.where(np.isnan(y_pix))[0]), n_obj/10)
382 x_pix_test, y_pix_test = pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs,
383 includeDistortion=False)
384 try:
385 np.testing.assert_array_equal(x_pix, x_pix_test)
386 np.testing.assert_array_equal(y_pix, y_pix_test)
387 except AssertionError:
388 n_problematic = 0
389 for xx, yy, xt, yt in zip(x_pix, y_pix, x_pix_test, y_pix_test):
390 if xx!=xt or yy!=yt:
391 if (not np.isnan(xx) and not np.isnan(xt) and
392 not np.isnan(yy) and not np.isnan(yt)):
393 print(xx,yy,xt,yt)
395 n_problematic += 1
396 if n_problematic>0:
397 raise
399 # test that exceptions are raised when incomplete ObservationMetaData are used
400 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, mjd=59580.0)
401 with self.assertRaises(RuntimeError) as context:
402 pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs)
403 self.assertIn("rotSkyPos", context.exception.args[0])
405 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=35.0)
406 with self.assertRaises(RuntimeError) as context:
407 pixelCoordsFromRaDecLSST(ra_list, dec_list, obs_metadata=obs)
408 self.assertIn("mjd", context.exception.args[0])
410 with self.assertRaises(RuntimeError) as context:
411 pixelCoordsFromRaDecLSST(ra_list, dec_list)
412 self.assertIn("ObservationMetaData", context.exception.args[0])
414 # check that exceptions are raised when ra_list, dec_list are of the wrong shape
415 obs = ObservationMetaData(pointingRA=raP, pointingDec=decP, rotSkyPos=24.0, mjd=43000.0)
416 with self.assertRaises(RuntimeError) as context:
417 pixelCoordsFromRaDecLSST(ra_list, dec_list[:5], obs_metadata=obs)
418 self.assertIn("same length", context.exception.args[0])
421class MotionTestCase(unittest.TestCase):
422 """
423 This class will contain test methods to verify that the LSST camera utils
424 work correctly when proper motion, parallax, and v_rad are non-zero
425 """
426 @classmethod
427 def setUpClass(cls):
428 cls.camera = LsstSimMapper().camera
430 @classmethod
431 def tearDownClass(cls):
432 del cls.camera
433 clean_up_lsst_camera()
435 def set_data(self, seed):
436 """
437 Accept a seed integer. Return an ObservationMetaData
438 and numpy arrays of RA, Dec (in degrees),
439 pm_ra, pm_dec, parallax (in arcsec) and v_rad (in km/s)
440 centered on that bore site.
441 """
442 rng = np.random.RandomState(seed)
443 n_obj = 30
444 ra = 23.1
445 dec = -15.6
446 rotSkyPos = 23.56
447 mjd = 59723.2
448 obs = ObservationMetaData(pointingRA=ra, pointingDec=dec,
449 rotSkyPos=rotSkyPos, mjd=mjd)
450 rr = rng.random_sample(n_obj)*1.75
451 theta = rng.random_sample(n_obj)*2.0*np.pi
452 ra_list = ra + rr*np.cos(theta)
453 dec_list = dec + rr*np.sin(theta)
454 pm_ra = rng.random_sample(n_obj)*20.0 - 10.0
455 pm_dec = rng.random_sample(n_obj)*20.0 - 10.0
456 parallax = rng.random_sample(n_obj)*1.0 - 0.5
457 v_rad = rng.random_sample(n_obj)*600.0 - 300.0
458 return obs, ra_list, dec_list, pm_ra, pm_dec, parallax, v_rad
460 def test_chip_name(self):
461 """
462 Test that chipNameFromRaDecLSST with non-zero proper motion etc.
463 agrees with chipNameFromPupilCoords when pupilCoords are
464 calculated with the same proper motion, etc.
465 """
466 (obs, ra_list, dec_list,
467 pm_ra_list, pm_dec_list,
468 parallax_list, v_rad_list) = self.set_data(11)
470 for is_none in ('pm_ra', 'pm_dec', 'parallax', 'v_rad'):
471 pm_ra = pm_ra_list
472 pm_dec = pm_dec_list
473 parallax = parallax_list
474 v_rad = v_rad_list
476 if is_none == 'pm_ra':
477 pm_ra = None
478 elif is_none == 'pm_dec':
479 pm_dec = None
480 elif is_none == 'parallax':
481 parallax = None
482 elif is_none == 'v_rad':
483 v_rad = None
485 xp, yp = pupilCoordsFromRaDec(ra_list, dec_list,
486 pm_ra=pm_ra, pm_dec=pm_dec,
487 parallax=parallax, v_rad=v_rad,
488 obs_metadata=obs)
490 name_control = chipNameFromPupilCoords(xp, yp, camera=self.camera)
492 name_test = chipNameFromRaDecLSST(ra_list, dec_list,
493 pm_ra=pm_ra, pm_dec=pm_dec,
494 parallax=parallax, v_rad=v_rad,
495 obs_metadata=obs)
497 name_radians = _chipNameFromRaDecLSST(np.radians(ra_list), np.radians(dec_list),
498 pm_ra=radiansFromArcsec(pm_ra),
499 pm_dec=radiansFromArcsec(pm_dec),
500 parallax=radiansFromArcsec(parallax), v_rad=v_rad,
501 obs_metadata=obs)
503 np.testing.assert_array_equal(name_control, name_test)
504 np.testing.assert_array_equal(name_control, name_radians)
505 self.assertGreater(len(np.unique(name_control.astype(str))), 4)
506 self.assertLess(len(np.where(np.equal(name_control, None))[0]), len(name_control)/4)
508 def test_pixel_coords(self):
509 """
510 Test that pixelCoordsFromRaDecLSST with non-zero proper motion etc.
511 agrees with pixelCoordsFromPupilCoords when pupilCoords are
512 calculated with the same proper motion, etc.
513 """
514 (obs, ra_list, dec_list,
515 pm_ra_list, pm_dec_list,
516 parallax_list, v_rad_list) = self.set_data(26)
518 for is_none in ('pm_ra', 'pm_dec', 'parallax', 'v_rad'):
519 pm_ra = pm_ra_list
520 pm_dec = pm_dec_list
521 parallax = parallax_list
522 v_rad = v_rad_list
524 if is_none == 'pm_ra':
525 pm_ra = None
526 elif is_none == 'pm_dec':
527 pm_dec = None
528 elif is_none == 'parallax':
529 parallax = None
530 elif is_none == 'v_rad':
531 v_rad = None
533 xp, yp = pupilCoordsFromRaDec(ra_list, dec_list,
534 pm_ra=pm_ra, pm_dec=pm_dec,
535 parallax=parallax, v_rad=v_rad,
536 obs_metadata=obs)
538 xpx_control, ypx_control = pixelCoordsFromPupilCoords(xp, yp, camera=self.camera,
539 includeDistortion=False)
541 xpx_test, ypx_test = pixelCoordsFromRaDecLSST(ra_list, dec_list,
542 pm_ra=pm_ra, pm_dec=pm_dec,
543 parallax=parallax, v_rad=v_rad,
544 obs_metadata=obs,
545 includeDistortion=False)
547 xpx_radians, ypx_radians = _pixelCoordsFromRaDecLSST(np.radians(ra_list), np.radians(dec_list),
548 pm_ra=radiansFromArcsec(pm_ra),
549 pm_dec=radiansFromArcsec(pm_dec),
550 parallax=radiansFromArcsec(parallax),
551 v_rad=v_rad, obs_metadata=obs,
552 includeDistortion=False)
554 np.testing.assert_array_equal(xpx_control, xpx_test)
555 np.testing.assert_array_equal(ypx_control, ypx_test)
556 np.testing.assert_array_equal(xpx_control, xpx_radians)
557 np.testing.assert_array_equal(ypx_control, ypx_radians)
558 self.assertLess(len(np.where(np.isnan(xpx_control))[0]), len(xpx_test)/4)
559 self.assertLess(len(np.where(np.isnan(ypx_control))[0]), len(ypx_test)/4)
562class MemoryTestClass(lsst.utils.tests.MemoryTestCase):
563 pass
565if __name__ == "__main__": 565 ↛ 566line 565 didn't jump to line 566, because the condition on line 565 was never true
566 lsst.utils.tests.init()
567 unittest.main()