Coverage for tests/test_model.py : 10%

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
1import math
2import numpy as np
3import unittest
5from lsst.ts.dateloc import ObservatoryLocation
6from lsst.ts.observatory.model import ObservatoryModel, Target
7import lsst.utils.tests
9class ObservatoryModelTest(unittest.TestCase):
11 @classmethod
12 def setUpClass(cls):
13 cls.location = ObservatoryLocation()
14 cls.location.for_lsst()
16 cls.model = ObservatoryModel(cls.location)
17 cls.model.configure_from_module()
19 def setUp(self):
20 self.model.park_state.filter = "r"
21 self.model.reset()
23 def check_delay_and_state(self, model, delays, critical_path, state):
24 lastslew_delays_dict = model.lastslew_delays_dict
25 for key in lastslew_delays_dict:
26 # This activity was not recorded in truth arrays.
27 if key == "telsettle":
28 continue
29 self.assertAlmostEqual(lastslew_delays_dict[key], delays[key],
30 delta=1e-3)
32 self.assertListEqual(model.lastslew_criticalpath, critical_path)
34 self.assertAlmostEqual(model.current_state.telalt_peakspeed,
35 state[0], delta=1e-3)
36 self.assertAlmostEqual(model.current_state.telaz_peakspeed,
37 state[1], delta=1e-3)
38 self.assertAlmostEqual(model.current_state.telrot_peakspeed,
39 state[2], delta=1e-3)
40 self.assertAlmostEqual(model.current_state.domalt_peakspeed,
41 state[3], delta=1e-3)
42 self.assertAlmostEqual(model.current_state.domaz_peakspeed,
43 state[4], delta=1e-3)
45 def make_slewact_dict(self, delays):
46 slewacts = ("telalt", "telaz", "telrot", "telopticsopenloop",
47 "telopticsclosedloop", "domalt", "domaz", "domazsettle",
48 "filter", "readout")
49 delay_map = {}
50 for i, slew in enumerate(slewacts):
51 if delays[i] > 0.0:
52 delay_map[slew] = delays[i]
53 return delay_map
55 def test_init(self):
56 temp_model = ObservatoryModel(self.location)
57 self.assertIsNotNone(temp_model.log)
58 self.assertAlmostEqual(temp_model.location.longitude_rad, -1.23480, delta=1e6)
59 self.assertEqual(temp_model.current_state.telalt_rad, 1.5)
61 def test_configure(self):
62 temp_model = ObservatoryModel(self.location)
63 temp_model.configure_from_module()
65 self.assertEqual(temp_model.location.longitude_rad, math.radians(-70.7494))
66 self.assertEqual(temp_model.location.longitude, -70.7494)
67 self.assertEqual(temp_model.current_state.telalt_rad, math.radians(86.5))
69 def test_get_closest_angle_distance_unlimited(self):
70 self.assertEqual(self.model.get_closest_angle_distance(math.radians(0), math.radians(0)),
71 (math.radians(0), math.radians(0)))
72 self.assertEqual(self.model.get_closest_angle_distance(math.radians(90), math.radians(0)),
73 (math.radians(90), math.radians(90)))
74 self.assertEqual(self.model.get_closest_angle_distance(math.radians(180), math.radians(0)),
75 (math.radians(180), math.radians(180)))
76 self.assertEqual(self.model.get_closest_angle_distance(math.radians(360), math.radians(0)),
77 (math.radians(0), math.radians(0)))
78 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-90), math.radians(0)),
79 (math.radians(-90), math.radians(-90)))
80 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-180), math.radians(0)),
81 (math.radians(180), math.radians(180)))
82 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-360), math.radians(0)),
83 (math.radians(0), math.radians(0)))
85 def test_get_closest_angle_distance_cable_wrap270(self):
86 self.assertEqual(self.model.get_closest_angle_distance(math.radians(0), math.radians(0),
87 math.radians(-270), math.radians(270)),
88 (math.radians(0), math.radians(0)))
89 self.assertEqual(self.model.get_closest_angle_distance(math.radians(90), math.radians(0),
90 math.radians(-270), math.radians(270)),
91 (math.radians(90), math.radians(90)))
92 self.assertEqual(self.model.get_closest_angle_distance(math.radians(180), math.radians(0),
93 math.radians(-270), math.radians(270)),
94 (math.radians(180), math.radians(180)))
95 self.assertEqual(self.model.get_closest_angle_distance(math.radians(360), math.radians(0),
96 math.radians(-270), math.radians(270)),
97 (math.radians(0), math.radians(0)))
98 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-90), math.radians(0),
99 math.radians(-270), math.radians(270)),
100 (math.radians(-90), math.radians(-90)))
101 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-180), math.radians(0),
102 math.radians(-270), math.radians(270)),
103 (math.radians(180), math.radians(180)))
104 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-360), math.radians(0),
105 math.radians(-270), math.radians(270)),
106 (math.radians(0), math.radians(0)))
108 self.assertEqual(self.model.get_closest_angle_distance(math.radians(0), math.radians(180),
109 math.radians(-270), math.radians(270)),
110 (math.radians(0), math.radians(-180)))
111 self.assertEqual(self.model.get_closest_angle_distance(math.radians(90), math.radians(180),
112 math.radians(-270), math.radians(270)),
113 (math.radians(90), math.radians(-90)))
114 self.assertEqual(self.model.get_closest_angle_distance(math.radians(180), math.radians(180),
115 math.radians(-270), math.radians(270)),
116 (math.radians(180), math.radians(0)))
117 self.assertEqual(self.model.get_closest_angle_distance(math.radians(360), math.radians(180),
118 math.radians(-270), math.radians(270)),
119 (math.radians(0), math.radians(-180)))
120 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-90), math.radians(180),
121 math.radians(-270), math.radians(270)),
122 (math.radians(270), math.radians(90)))
123 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-180), math.radians(180),
124 math.radians(-270), math.radians(270)),
125 (math.radians(180), math.radians(0)))
126 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-360), math.radians(180),
127 math.radians(-270), math.radians(270)),
128 (math.radians(0), math.radians(-180)))
130 self.assertEqual(self.model.get_closest_angle_distance(math.radians(0), math.radians(-180),
131 math.radians(-270), math.radians(270)),
132 (math.radians(0), math.radians(180)))
133 self.assertEqual(self.model.get_closest_angle_distance(math.radians(90), math.radians(-180),
134 math.radians(-270), math.radians(270)),
135 (math.radians(-270), math.radians(-90)))
136 self.assertEqual(self.model.get_closest_angle_distance(math.radians(180), math.radians(-180),
137 math.radians(-270), math.radians(270)),
138 (math.radians(-180), math.radians(0)))
139 self.assertEqual(self.model.get_closest_angle_distance(math.radians(360), math.radians(-180),
140 math.radians(-270), math.radians(270)),
141 (math.radians(0), math.radians(180)))
142 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-90), math.radians(-180),
143 math.radians(-270), math.radians(270)),
144 (math.radians(-90), math.radians(90)))
145 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-180), math.radians(-180),
146 math.radians(-270), math.radians(270)),
147 (math.radians(-180), math.radians(0)))
148 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-360), math.radians(-180),
149 math.radians(-270), math.radians(270)),
150 (math.radians(0), math.radians(180)))
152 def test_get_closest_angle_distance_cable_wrap90(self):
153 self.assertEqual(self.model.get_closest_angle_distance(math.radians(0), math.radians(0),
154 math.radians(-90), math.radians(90)),
155 (math.radians(0), math.radians(0)))
156 self.assertEqual(self.model.get_closest_angle_distance(math.radians(45), math.radians(0),
157 math.radians(-90), math.radians(90)),
158 (math.radians(45), math.radians(45)))
159 self.assertEqual(self.model.get_closest_angle_distance(math.radians(90), math.radians(0),
160 math.radians(-90), math.radians(90)),
161 (math.radians(90), math.radians(90)))
162 self.assertEqual(self.model.get_closest_angle_distance(math.radians(180), math.radians(0),
163 math.radians(-90), math.radians(90)),
164 (math.radians(0), math.radians(0)))
165 self.assertEqual(self.model.get_closest_angle_distance(math.radians(270), math.radians(0),
166 math.radians(-90), math.radians(90)),
167 (math.radians(-90), math.radians(-90)))
168 self.assertEqual(self.model.get_closest_angle_distance(math.radians(360), math.radians(0),
169 math.radians(-90), math.radians(90)),
170 (math.radians(0), math.radians(0)))
171 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-45), math.radians(0),
172 math.radians(-90), math.radians(90)),
173 (math.radians(-45), math.radians(-45)))
174 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-90), math.radians(0),
175 math.radians(-90), math.radians(90)),
176 (math.radians(-90), math.radians(-90)))
177 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-180), math.radians(0),
178 math.radians(-90), math.radians(90)),
179 (math.radians(0), math.radians(0)))
180 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-270), math.radians(0),
181 math.radians(-90), math.radians(90)),
182 (math.radians(90), math.radians(90)))
183 self.assertEqual(self.model.get_closest_angle_distance(math.radians(-360), math.radians(0),
184 math.radians(-90), math.radians(90)),
185 (math.radians(0), math.radians(0)))
187 def test_reset(self):
188 self.model.reset()
189 self.assertEqual(str(self.model.current_state), "t=0.0 ra=0.000 dec=0.000 ang=0.000 "
190 "filter=r track=False alt=86.500 az=0.000 pa=0.000 rot=0.000 "
191 "telaz=0.000 telrot=0.000 "
192 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
194 def test_slew_altaz(self):
195 self.model.update_state(0)
196 # Use old values, to avoid updating final states.
197 self.model.params.domaz_free_range = 0
198 self.model.params.optics_cl_delay = [0, 20.0]
200 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
201 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
202 "telaz=0.000 telrot=0.000 "
203 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
204 self.model.slew_altaz(0, math.radians(80), math.radians(0), math.radians(0), "r")
205 self.model.start_tracking(0)
206 self.assertEqual(str(self.model.current_state), "t=7.7 ra=29.510 dec=-20.244 ang=180.000 "
207 "filter=r track=True alt=80.000 az=0.000 pa=180.000 rot=0.000 "
208 "telaz=0.000 telrot=0.000 "
209 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
211 self.model.update_state(100)
212 self.assertEqual(str(self.model.current_state), "t=100.0 ra=29.510 dec=-20.244 ang=180.000 "
213 "filter=r track=True alt=79.994 az=357.901 pa=178.068 rot=358.068 "
214 "telaz=-2.099 telrot=-1.932 "
215 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
216 self.model.slew_altaz(100, math.radians(70), math.radians(30), math.radians(15), "r")
217 self.model.start_tracking(0)
218 self.assertEqual(str(self.model.current_state), "t=144.4 ra=40.172 dec=-12.558 ang=191.265 "
219 "filter=r track=True alt=70.000 az=30.000 pa=206.265 rot=15.000 "
220 "telaz=30.000 telrot=15.000 "
221 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
223 def test_slew_radec(self):
224 self.model.update_state(0)
225 # Use old values, to avoid updating final states.
226 self.model.params.domaz_free_range = 0
227 self.model.params.optics_cl_delay = [0, 20.0]
228 self.model.params.rotator_followsky = True
229 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
230 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
231 "telaz=0.000 telrot=0.000 "
232 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
233 self.model.slew_radec(0, math.radians(80), math.radians(0), math.radians(0), "r")
234 self.assertEqual(str(self.model.current_state), "t=68.0 ra=80.000 dec=0.000 ang=180.000 "
235 "filter=r track=True alt=33.540 az=67.263 pa=232.821 rot=52.821 "
236 "telaz=67.263 telrot=52.821 "
237 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
239 self.model.update_state(100)
240 self.assertEqual(str(self.model.current_state), "t=100.0 ra=80.000 dec=0.000 ang=180.000 "
241 "filter=r track=True alt=33.650 az=67.163 pa=232.766 rot=52.766 "
242 "telaz=67.163 telrot=52.766 "
243 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
244 self.model.slew_radec(100, math.radians(70), math.radians(-30), math.radians(15), "r")
245 self.assertEqual(str(self.model.current_state), "t=144.9 ra=70.000 dec=-30.000 ang=195.000 "
246 "filter=r track=True alt=55.654 az=99.940 pa=259.282 rot=64.282 "
247 "telaz=99.940 telrot=64.282 "
248 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
250 def test_get_slew_delay(self):
251 self.model.update_state(0)
252 # Use old values, to avoid updating final states.
253 self.model.params.rotator_followsky = True
255 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
256 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
257 "telaz=0.000 telrot=0.000 "
258 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
259 # This slew will include a CL optics correction.
260 target = Target()
261 target.ra_rad = math.radians(60)
262 target.dec_rad = math.radians(-20)
263 target.ang_rad = math.radians(0)
264 target.filter = "r"
266 delay, status = self.model.get_slew_delay(target)
267 self.assertAlmostEqual(delay, 85.507, delta=1e-3)
269 self.model.slew(target)
271 # This slew simply includes a filter change.
272 target = Target()
273 target.ra_rad = math.radians(60)
274 target.dec_rad = math.radians(-20)
275 target.ang_rad = math.radians(0)
276 target.filter = "g"
278 delay, status = self.model.get_slew_delay(target)
279 self.assertAlmostEqual(delay, 120, delta=1e-3)
281 # This slew does not include OL correction, but does involve dome crawl.
282 target = Target()
283 target.ra_rad = math.radians(50)
284 target.dec_rad = math.radians(-10)
285 target.ang_rad = math.radians(10)
286 target.filter = "r"
288 delay, status = self.model.get_slew_delay(target)
289 self.assertAlmostEqual(delay, 17.913, delta=1e-3)
291 # This slew is only readout.
292 self.model.slew(target)
293 delay, status = self.model.get_slew_delay(target)
294 self.assertAlmostEqual(delay, 2.0, delta=1e-3)
296 # This slew involves rotator.
297 target.ang_rad = math.radians(15)
298 delay, status = self.model.get_slew_delay(target)
299 self.assertAlmostEqual(delay, 4.472, delta=1e-3)
301 def test_get_approximateSlewTime(self):
302 self.model.update_state(0)
303 alt = np.array([self.model.current_state.telalt_rad])
304 az = np.array([self.model.current_state.telaz_rad])
305 f = self.model.current_state.filter
306 # Check that slew time is == readout time for no motion
307 slewtime = self.model.get_approximate_slew_delay(alt, az, f)
308 self.assertEqual(slewtime, 2.0)
309 # Check that slew time is == filter change time for filter change
310 newfilter = 'u'
311 if f == newfilter:
312 newfilter = 'g'
313 slewtime = self.model.get_approximate_slew_delay(alt, az, newfilter)
314 self.assertEqual(slewtime, 120.0)
315 # Check that get nan when attempting to slew out of bounds
316 alt = np.array([np.radians(90), np.radians(0), np.radians(-20)], float)
317 az = np.zeros(len(alt), float)
318 slewtime = self.model.get_approximate_slew_delay(alt, az, f)
319 self.assertTrue(np.all(slewtime < 0))
320 # Check that we can calculate slew times with an array.
321 alt = np.radians(np.arange(0, 90, 1))
322 az = np.radians(np.arange(0, 180, 2))
323 slewtime = self.model.get_approximate_slew_delay(alt, az, f)
324 self.assertEqual(len(slewtime), len(alt))
327 def test_get_slew_delay_followsky_false(self):
328 # Test slew time without followsky option. Similar to test_get_slew_delay above.
329 self.model.update_state(0)
330 self.model.params.rotator_followsky = False
331 expected_state = "t=0.0 ra=29.480 dec=-26.744 ang=180.000 " \
332 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 " \
333 "telaz=0.000 telrot=0.000 " \
334 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']"
335 self.assertEqual(str(self.model.current_state), expected_state)
337 target = Target()
338 target.ra_rad = math.radians(60)
339 target.dec_rad = math.radians(-20)
340 target.ang_rad = math.radians(0)
341 target.filter = "r"
343 delay, status = self.model.get_slew_delay(target)
344 self.assertAlmostEqual(delay, 85.507, delta=1e-3)
346 self.model.slew(target)
348 target = Target()
349 target.ra_rad = math.radians(60)
350 target.dec_rad = math.radians(-20)
351 target.ang_rad = math.radians(0)
352 target.filter = "g"
354 delay, status = self.model.get_slew_delay(target)
355 self.assertAlmostEqual(delay, 120, delta=1e-3)
357 target = Target()
358 target.ra_rad = math.radians(50)
359 target.dec_rad = math.radians(-10)
360 target.ang_rad = math.radians(10)
361 target.filter = "r"
363 delay, status = self.model.get_slew_delay(target)
364 self.assertAlmostEqual(delay, 17.913, delta=1e-3)
366 self.model.slew(target)
367 delay, status = self.model.get_slew_delay(target)
368 self.assertAlmostEqual(delay, 2.0, delta=1e-3)
370 # Here is the difference when using followsky = False
371 target.ang_rad = math.radians(15)
372 delay, status = self.model.get_slew_delay(target)
373 self.assertAlmostEqual(delay, 2.0, delta=1e-3)
375 def test_slew(self):
376 self.model.update_state(0)
377 self.model.params.domaz_free_range = 0
378 self.model.params.optics_cl_delay = [0, 20.0]
379 self.model.params.rotator_followsky = True
381 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
382 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
383 "telaz=0.000 telrot=0.000 "
384 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
386 target = Target()
387 target.ra_rad = math.radians(60)
388 target.dec_rad = math.radians(-20)
389 target.ang_rad = math.radians(0)
390 target.filter = "r"
392 self.model.slew(target)
393 self.assertEqual(str(self.model.current_state), "t=74.2 ra=60.000 dec=-20.000 ang=180.000 "
394 "filter=r track=True alt=60.904 az=76.495 pa=243.368 rot=63.368 "
395 "telaz=76.495 telrot=63.368 "
396 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
398 target = Target()
399 target.ra_rad = math.radians(60)
400 target.dec_rad = math.radians(-20)
401 target.ang_rad = math.radians(0)
402 target.filter = "i"
404 self.model.slew(target)
405 self.assertEqual(str(self.model.current_state), "t=194.2 ra=60.000 dec=-20.000 ang=180.000 "
406 "filter=i track=True alt=61.324 az=76.056 pa=243.156 rot=63.156 "
407 "telaz=76.056 telrot=63.156 "
408 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
410 def test_domecrawl(self):
411 self.model.update_state(0)
412 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
413 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
414 "telaz=0.000 telrot=0.000 "
415 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
417 target = Target()
418 target.ra_rad = math.radians(35)
419 target.dec_rad = math.radians(-27)
420 target.ang_rad = math.radians(0)
421 target.filter = "r"
423 # Just test whether dome crawl is faster or not.
424 # If we test the final slew state, this is including other aspects of slew model (such as CLoptics).
425 self.model.params.domaz_free_range = 0
426 delay_nocrawl = self.model.get_slew_delay(target)
427 self.model.params.domaz_free_range = np.radians(4.0)
428 delay_crawl = self.model.get_slew_delay(target)
429 self.assertTrue( delay_crawl < delay_nocrawl)
432 def test_slewdata(self):
433 self.model.update_state(0)
434 # Use old values, to avoid updating final states.
435 self.model.params.domaz_free_range = 0
436 self.model.params.optics_cl_delay = [0, 20.0]
437 self.model.params.rotator_followsky = True
439 target = Target()
440 target.ra_rad = math.radians(60)
441 target.dec_rad = math.radians(-20)
442 target.ang_rad = math.radians(0)
443 target.filter = "r"
445 self.model.slew(target)
446 self.assertEqual(str(self.model.current_state), "t=74.2 ra=60.000 dec=-20.000 ang=180.000 "
447 "filter=r track=True alt=60.904 az=76.495 pa=243.368 rot=63.368 "
448 "telaz=76.495 telrot=63.368 "
449 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
450 self.check_delay_and_state(self.model,
451 self.make_slewact_dict((8.387, 11.966, 21.641, 7.387, 20.0,
452 18.775, 53.174, 1.0, 0.0, 2.0)),
453 ['telopticsclosedloop', 'domazsettle',
454 'domaz'],
455 (-3.50, 7.00, 3.50, -1.75, 1.50))
457 target = Target()
458 target.ra_rad = math.radians(60)
459 target.dec_rad = math.radians(-20)
460 target.ang_rad = math.radians(0)
461 target.filter = "i"
463 self.model.slew(target)
464 self.assertEqual(str(self.model.current_state), "t=194.2 ra=60.000 dec=-20.000 ang=180.000 "
465 "filter=i track=True alt=61.324 az=76.056 pa=243.156 rot=63.156 "
466 "telaz=76.056 telrot=63.156 "
467 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
468 self.check_delay_and_state(self.model,
469 self.make_slewact_dict((0.0, 0.0, 0.0, 0.0,
470 0.0, 0.0, 0.0, 0.0,
471 120.0, 2.0)),
472 ['filter'],
473 (0, 0, 0, 0, 0))
475 target = Target()
476 target.ra_rad = math.radians(61)
477 target.dec_rad = math.radians(-21)
478 target.ang_rad = math.radians(1)
479 target.filter = "i"
481 self.model.slew(target)
482 self.assertEqual(str(self.model.current_state), "t=199.0 ra=61.000 dec=-21.000 ang=181.000 "
483 "filter=i track=True alt=60.931 az=78.751 pa=245.172 rot=64.172 "
484 "telaz=78.751 telrot=64.172 "
485 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
486 self.check_delay_and_state(self.model,
487 self.make_slewact_dict((0.683, 1.244,
488 2.022, 0.117,
489 0.0, 1.365,
490 3.801, 1.0,
491 0.000, 2.000)),
492 ['domazsettle', 'domaz'],
493 (-1.194, 4.354, 1.011, -0.598, 1.425))
495 def test_rotator_followsky_true(self):
496 # Use old values, to avoid updating final states.
497 self.model.params.domaz_free_range = 0
498 self.model.params.optics_cl_delay = [0, 20.0]
500 self.model.update_state(0)
501 self.model.params.rotator_followsky = True
502 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
503 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
504 "telaz=0.000 telrot=0.000 "
505 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
506 self.model.slew_radec(0, math.radians(80), math.radians(0), math.radians(0), "r")
507 self.assertEqual(str(self.model.current_state), "t=68.0 ra=80.000 dec=0.000 ang=180.000 "
508 "filter=r track=True alt=33.540 az=67.263 pa=232.821 rot=52.821 "
509 "telaz=67.263 telrot=52.821 "
510 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
511 self.model.slew_radec(0, math.radians(83.5), math.radians(0), math.radians(0), "r")
512 self.assertEqual(str(self.model.current_state), "t=72.8 ra=83.500 dec=0.000 ang=180.000 "
513 "filter=r track=True alt=30.744 az=69.709 pa=234.123 rot=54.123 "
514 "telaz=69.709 telrot=54.123 "
515 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
517 def test_rotator_followsky_false(self):
518 # Use old values, to avoid updating final states.
519 self.model.update_state(0)
520 self.model.params.domaz_free_range = 0
521 self.model.params.optics_cl_delay = [0, 20.0]
522 self.model.params.rotator_followsky = False
523 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
524 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
525 "telaz=0.000 telrot=0.000 "
526 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
527 self.model.slew_radec(0, math.radians(80), math.radians(0), math.radians(0), "r")
528 self.assertEqual(str(self.model.current_state), "t=68.0 ra=80.000 dec=0.000 ang=232.933 "
529 "filter=r track=True alt=33.540 az=67.263 pa=232.821 rot=359.888 "
530 "telaz=67.263 telrot=-0.112 "
531 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
532 self.model.slew_radec(0, math.radians(83.5), math.radians(0), math.radians(0), "r")
533 self.assertEqual(str(self.model.current_state), "t=72.8 ra=83.500 dec=0.000 ang=234.241 "
534 "filter=r track=True alt=30.744 az=69.709 pa=234.123 rot=359.881 "
535 "telaz=69.709 telrot=-0.119 "
536 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
540 def test_swap_filter(self):
541 # Use old values, to avoid updating final states.
542 self.model.params.domaz_free_range = 0
543 self.model.params.optics_cl_delay = [0, 20.0]
544 self.model.params.rotator_followsky = True
545 self.model.update_state(0)
546 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
547 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
548 "telaz=0.000 telrot=0.000 "
549 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
550 self.assertEqual(str(self.model.park_state), "t=0.0 ra=0.000 dec=0.000 ang=0.000 "
551 "filter=r track=False alt=86.500 az=0.000 pa=0.000 rot=0.000 "
552 "telaz=0.000 telrot=0.000 "
553 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']")
554 self.model.swap_filter("z")
555 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
556 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
557 "telaz=0.000 telrot=0.000 "
558 "mounted=['g', 'r', 'i', 'y', 'u'] unmounted=['z']")
559 self.assertEqual(str(self.model.park_state), "t=0.0 ra=0.000 dec=0.000 ang=0.000 "
560 "filter=r track=False alt=86.500 az=0.000 pa=0.000 rot=0.000 "
561 "telaz=0.000 telrot=0.000 "
562 "mounted=['g', 'r', 'i', 'y', 'u'] unmounted=['z']")
563 self.model.swap_filter("u")
564 self.assertEqual(str(self.model.current_state), "t=0.0 ra=29.480 dec=-26.744 ang=180.000 "
565 "filter=r track=False alt=86.500 az=0.000 pa=180.000 rot=0.000 "
566 "telaz=0.000 telrot=0.000 "
567 "mounted=['g', 'r', 'i', 'y', 'z'] unmounted=['u']")
568 self.assertEqual(str(self.model.park_state), "t=0.0 ra=0.000 dec=0.000 ang=0.000 "
569 "filter=r track=False alt=86.500 az=0.000 pa=0.000 rot=0.000 "
570 "telaz=0.000 telrot=0.000 "
571 "mounted=['g', 'r', 'i', 'y', 'z'] unmounted=['u']")
573 def test_park(self):
574 self.model.update_state(0)
575 self.model.params.rotator_followsky = False
576 self.model.params.rotator_resume_angle = False
577 # Start at park, slew to target.
578 # Use default configuration (dome crawl, CL updates, etc.)
579 target = Target()
580 target.ra_rad = math.radians(60)
581 target.dec_rad = math.radians(-20)
582 target.ang_rad = math.radians(0)
583 target.filter = "z"
585 self.model.slew(target)
586 expected_state = "t=156.0 ra=60.000 dec=-20.000 ang=243.495 filter=z track=True " \
587 "alt=61.191 az=76.196 pa=243.224 rot=359.729 telaz=76.196 telrot=-0.271 " \
588 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']"
589 self.assertEqual(str(self.model.current_state), expected_state)
590 self.check_delay_and_state(self.model,
591 self.make_slewact_dict((8.387, 11.966, 0.0,
592 7.387, 36.0, 18.775,
593 48.507, 1.0, 120.0,
594 2.0)),
595 ['telopticsclosedloop', 'filter'],
596 (-3.50, 7.00, 0.0, -1.75, 1.50))
598 self.model.park()
599 expected_state = "t=241.1 ra=30.487 dec=-26.744 ang=180.000 filter=z track=False " \
600 "alt=86.500 az=0.000 pa=180.000 rot=0.000 telaz=0.000 telrot=0.000 " \
601 "mounted=['g', 'r', 'i', 'z', 'y'] unmounted=['u']"
602 self.assertEqual(str(self.model.current_state), expected_state)
603 self.check_delay_and_state(self.model,
604 self.make_slewact_dict((8.231, 11.885,
605 1.041, 7.231, 36.0,
606 18.462, 48.130,
607 1.0, 0.0, 2.0)),
608 ['telopticsclosedloop', 'domazsettle',
609 'domaz'],
610 (3.50, -7.00, 0.520, 1.75, -1.50))
613 def test_get_deep_drilling_time(self):
614 target = Target()
615 target.is_deep_drilling = True
616 target.is_dd_firstvisit = True
617 target.remaining_dd_visits = 96
618 target.dd_exposures = 2 * 96
619 target.dd_filterchanges = 3
620 target.dd_exptime = 96 * 2 * 15.0
622 ddtime = self.model.get_deep_drilling_time(target)
623 self.assertEqual(ddtime, 3808.0)
626 def test_get_configure_dict(self):
627 cd = ObservatoryModel.get_configure_dict()
628 self.assertEqual(len(cd), 7)
629 self.assertEqual(len(cd["telescope"]), 11)
630 self.assertEqual(len(cd["camera"]), 10)
633class MemoryTestClass(lsst.utils.tests.MemoryTestCase):
634 pass
637def setup_module(module):
638 lsst.utils.tests.init()
641if __name__ == "__main__": 641 ↛ 642line 641 didn't jump to line 642, because the condition on line 641 was never true
642 lsst.utils.tests.init()
643 unittest.main()