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

1import math 

2import numpy as np 

3import unittest 

4 

5from lsst.ts.dateloc import ObservatoryLocation 

6from lsst.ts.observatory.model import ObservatoryModel, Target 

7import lsst.utils.tests 

8 

9class ObservatoryModelTest(unittest.TestCase): 

10 

11 @classmethod 

12 def setUpClass(cls): 

13 cls.location = ObservatoryLocation() 

14 cls.location.for_lsst() 

15 

16 cls.model = ObservatoryModel(cls.location) 

17 cls.model.configure_from_module() 

18 

19 def setUp(self): 

20 self.model.park_state.filter = "r" 

21 self.model.reset() 

22 

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) 

31 

32 self.assertListEqual(model.lastslew_criticalpath, critical_path) 

33 

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) 

44 

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 

54 

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) 

60 

61 def test_configure(self): 

62 temp_model = ObservatoryModel(self.location) 

63 temp_model.configure_from_module() 

64 

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)) 

68 

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))) 

84 

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))) 

107 

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))) 

129 

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))) 

151 

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))) 

186 

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']") 

193 

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] 

199 

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']") 

210 

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']") 

222 

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']") 

238 

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']") 

249 

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 

254 

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" 

265 

266 delay, status = self.model.get_slew_delay(target) 

267 self.assertAlmostEqual(delay, 85.507, delta=1e-3) 

268 

269 self.model.slew(target) 

270 

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" 

277 

278 delay, status = self.model.get_slew_delay(target) 

279 self.assertAlmostEqual(delay, 120, delta=1e-3) 

280 

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" 

287 

288 delay, status = self.model.get_slew_delay(target) 

289 self.assertAlmostEqual(delay, 17.913, delta=1e-3) 

290 

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) 

295 

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) 

300 

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)) 

325 

326 

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) 

336 

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" 

342 

343 delay, status = self.model.get_slew_delay(target) 

344 self.assertAlmostEqual(delay, 85.507, delta=1e-3) 

345 

346 self.model.slew(target) 

347 

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" 

353 

354 delay, status = self.model.get_slew_delay(target) 

355 self.assertAlmostEqual(delay, 120, delta=1e-3) 

356 

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" 

362 

363 delay, status = self.model.get_slew_delay(target) 

364 self.assertAlmostEqual(delay, 17.913, delta=1e-3) 

365 

366 self.model.slew(target) 

367 delay, status = self.model.get_slew_delay(target) 

368 self.assertAlmostEqual(delay, 2.0, delta=1e-3) 

369 

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) 

374 

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 

380 

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']") 

385 

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" 

391 

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']") 

397 

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" 

403 

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']") 

409 

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']") 

416 

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" 

422 

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) 

430 

431 

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 

438 

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" 

444 

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)) 

456 

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" 

462 

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)) 

474 

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" 

480 

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)) 

494 

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] 

499 

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']") 

516 

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']") 

537 

538 

539 

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']") 

572 

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" 

584 

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)) 

597 

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)) 

611 

612 

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 

621 

622 ddtime = self.model.get_deep_drilling_time(target) 

623 self.assertEqual(ddtime, 3808.0) 

624 

625 

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) 

631 

632 

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

634 pass 

635 

636 

637def setup_module(module): 

638 lsst.utils.tests.init() 

639 

640 

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()