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 unittest 

3 

4from lsst.ts.observatory.model import ObservatoryModelParameters 

5import lsst.utils.tests 

6 

7class ObservatoryModelParametersTest(unittest.TestCase): 

8 

9 def setUp(self): 

10 self.params = ObservatoryModelParameters() 

11 

12 def test_some_basic_information_after_creation(self): 

13 self.assertEqual(self.params.telalt_minpos_rad, 0.0) 

14 self.assertEqual(self.params.telaz_maxpos_rad, 0.0) 

15 self.assertFalse(self.params.rotator_followsky) 

16 self.assertEqual(self.params.filter_darktime, "u") 

17 self.assertListEqual(self.params.filter_init_unmounted_list, []) 

18 self.assertDictEqual(self.params.prerequisites, {}) 

19 

20 def test_configure_telescope(self): 

21 truth = { 

22 "telescope": { 

23 "altitude_minpos": 15.0, 

24 "altitude_maxpos": 85.0, 

25 "azimuth_minpos": -90.0, 

26 "azimuth_maxpos": 90.0, 

27 "altitude_maxspeed": 10.0, 

28 "altitude_accel": 3.0, 

29 "altitude_decel": 3.0, 

30 "azimuth_maxspeed": 8.0, 

31 "azimuth_accel": 2.0, 

32 "azimuth_decel": 2.0, 

33 "settle_time": 1.0 

34 } 

35 } 

36 self.params.configure_telescope(truth) 

37 self.assertEqual(self.params.telalt_minpos_rad, 

38 math.radians(truth["telescope"]["altitude_minpos"])) 

39 self.assertEqual(self.params.telalt_maxpos_rad, 

40 math.radians(truth["telescope"]["altitude_maxpos"])) 

41 self.assertEqual(self.params.telaz_minpos_rad, 

42 math.radians(truth["telescope"]["azimuth_minpos"])) 

43 self.assertEqual(self.params.telaz_maxpos_rad, 

44 math.radians(truth["telescope"]["azimuth_maxpos"])) 

45 self.assertEqual(self.params.telalt_maxspeed_rad, 

46 math.radians(truth["telescope"]["altitude_maxspeed"])) 

47 self.assertEqual(self.params.telalt_accel_rad, 

48 math.radians(truth["telescope"]["altitude_accel"])) 

49 self.assertEqual(self.params.telalt_decel_rad, 

50 math.radians(truth["telescope"]["altitude_decel"])) 

51 self.assertEqual(self.params.telaz_maxspeed_rad, 

52 math.radians(truth["telescope"]["azimuth_maxspeed"])) 

53 self.assertEqual(self.params.telaz_accel_rad, 

54 math.radians(truth["telescope"]["azimuth_accel"])) 

55 self.assertEqual(self.params.telaz_decel_rad, 

56 math.radians(truth["telescope"]["azimuth_decel"])) 

57 self.assertEqual(self.params.mount_settletime, 

58 truth["telescope"]["settle_time"]) 

59 

60 def test_configure_rotator(self): 

61 truth = { 

62 "rotator": { 

63 "minpos": -90.0, 

64 "maxpos": 90.0, 

65 "maxspeed": 4.0, 

66 "accel": 1.0, 

67 "decel": 1.0, 

68 "filter_change_pos": 45.0, 

69 "follow_sky": True, 

70 "resume_angle": False 

71 } 

72 } 

73 self.params.configure_rotator(truth) 

74 self.assertEqual(self.params.telrot_minpos_rad, 

75 math.radians(truth["rotator"]["minpos"])) 

76 self.assertEqual(self.params.telrot_maxpos_rad, 

77 math.radians(truth["rotator"]["maxpos"])) 

78 self.assertEqual(self.params.telrot_maxspeed_rad, 

79 math.radians(truth["rotator"]["maxspeed"])) 

80 self.assertEqual(self.params.telrot_accel_rad, 

81 math.radians(truth["rotator"]["accel"])) 

82 self.assertEqual(self.params.telrot_decel_rad, 

83 math.radians(truth["rotator"]["decel"])) 

84 self.assertEqual(self.params.telrot_filterchangepos_rad, 

85 math.radians(truth["rotator"]["filter_change_pos"])) 

86 self.assertTrue(self.params.rotator_followsky) 

87 self.assertFalse(self.params.rotator_resumeangle) 

88 

89 def test_configure_dome(self): 

90 truth = { 

91 "dome": { 

92 "altitude_maxspeed": 6.0, 

93 "altitude_accel": 1.5, 

94 "altitude_decel": 1.5, 

95 "altitude_freerange": 0., 

96 "azimuth_maxspeed": 4.0, 

97 "azimuth_accel": 0.5, 

98 "azimuth_decel": 0.5, 

99 "azimuth_freerange": 0., 

100 "settle_time": 3.0 

101 } 

102 } 

103 self.params.configure_dome(truth) 

104 self.assertEqual(self.params.domalt_maxspeed_rad, 

105 math.radians(truth["dome"]["altitude_maxspeed"])) 

106 self.assertEqual(self.params.domalt_accel_rad, 

107 math.radians(truth["dome"]["altitude_accel"])) 

108 self.assertEqual(self.params.domalt_decel_rad, 

109 math.radians(truth["dome"]["altitude_decel"])) 

110 self.assertEqual(self.params.domaz_maxspeed_rad, 

111 math.radians(truth["dome"]["azimuth_maxspeed"])) 

112 self.assertEqual(self.params.domaz_accel_rad, 

113 math.radians(truth["dome"]["azimuth_accel"])) 

114 self.assertEqual(self.params.domaz_decel_rad, 

115 math.radians(truth["dome"]["azimuth_decel"])) 

116 self.assertEqual(self.params.domaz_settletime, 

117 truth["dome"]["settle_time"]) 

118 

119 def test_configure_optics(self): 

120 truth = { 

121 "optics_loop_corr": { 

122 "tel_optics_ol_slope": 3.0 / 2.0, 

123 "tel_optics_cl_delay": [0.0, 34.0], 

124 "tel_optics_cl_alt_limit": [0.0, 7.0, 90.0] 

125 } 

126 } 

127 self.params.configure_optics(truth) 

128 olc = truth["optics_loop_corr"] 

129 self.assertEqual(self.params.optics_ol_slope, 

130 olc["tel_optics_ol_slope"] / math.radians(1)) 

131 self.assertListEqual(self.params.optics_cl_delay, 

132 olc["tel_optics_cl_delay"]) 

133 olc_altlims = [math.radians(x) for x in olc["tel_optics_cl_alt_limit"]] 

134 self.assertListEqual(self.params.optics_cl_altlimit, olc_altlims) 

135 

136 def test_configure_camera(self): 

137 truth = { 

138 "camera": { 

139 "readout_time": 2.0, 

140 "shutter_time": 1.0, 

141 "filter_change_time": 90.0, 

142 "filter_removable": ['y', 'z'], 

143 "filter_max_changes_burst_num": 10, 

144 "filter_max_changes_burst_time": 20 * 60.0, 

145 "filter_max_changes_avg_num": 2000, 

146 "filter_max_changes_avg_time": 365 * 24 * 60 * 60.0, 

147 "filter_mounted": ['g', 'r', 'i', 'z', 'y'], 

148 "filter_unmounted": ['u'] 

149 } 

150 } 

151 self.params.configure_camera(truth) 

152 cam = truth["camera"] 

153 self.assertEqual(self.params.readouttime, cam["readout_time"]) 

154 self.assertEqual(self.params.shuttertime, cam["shutter_time"]) 

155 self.assertEqual(self.params.filter_changetime, 

156 cam["filter_change_time"]) 

157 self.assertListEqual(self.params.filter_removable_list, 

158 cam["filter_removable"]) 

159 self.assertEqual(self.params.filter_max_changes_burst_num, 

160 cam["filter_max_changes_burst_num"]) 

161 self.assertEqual(self.params.filter_max_changes_burst_time, 

162 cam["filter_max_changes_burst_time"]) 

163 self.assertEqual(self.params.filter_max_changes_avg_num, 

164 cam["filter_max_changes_avg_num"]) 

165 self.assertEqual(self.params.filter_max_changes_avg_time, 

166 cam["filter_max_changes_avg_time"]) 

167 ratio = cam["filter_max_changes_avg_time"] /\ 

168 cam["filter_max_changes_avg_num"] 

169 self.assertEqual(self.params.filter_max_changes_avg_interval, 

170 ratio) 

171 self.assertListEqual(self.params.filter_init_mounted_list, 

172 cam["filter_mounted"]) 

173 self.assertListEqual(self.params.filter_init_unmounted_list, 

174 cam["filter_unmounted"]) 

175 

176 truth["camera"]["filter_max_changes_avg_num"] = 0 

177 self.params.configure_camera(truth) 

178 self.assertEqual(self.params.filter_max_changes_avg_interval, 

179 0.0) 

180 

181 def test_configure_slew(self): 

182 truth_activities = ["telalt", "telaz", "domalt", "domaz", 

183 "telopticsclosedloop", "exposures"] 

184 truth = { 

185 "slew": { 

186 "prereq_telalt": [], 

187 "prereq_telaz": [], 

188 "prereq_domalt": [], 

189 "prereq_domaz": [], 

190 "prereq_exposures": ["telopticsclosedloop"], 

191 "prereq_telopticsclosedloop": ["domalt", "domazsettle", 

192 "telsettle", "readout", 

193 "telopticsopenloop", 

194 "filter", "telrot"] 

195 } 

196 } 

197 self.params.configure_slew(truth, truth_activities) 

198 slew = truth["slew"] 

199 self.assertListEqual(self.params.prerequisites["telalt"], 

200 slew["prereq_telalt"]) 

201 self.assertListEqual(self.params.prerequisites["telaz"], 

202 slew["prereq_telaz"]) 

203 self.assertListEqual(self.params.prerequisites["domalt"], 

204 slew["prereq_domalt"]) 

205 self.assertListEqual(self.params.prerequisites["domaz"], 

206 slew["prereq_domaz"]) 

207 self.assertListEqual(self.params.prerequisites["exposures"], 

208 slew["prereq_exposures"]) 

209 self.assertListEqual(self.params.prerequisites["telopticsclosedloop"], 

210 slew["prereq_telopticsclosedloop"]) 

211 

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

213 pass 

214 

215def setup_module(module): 

216 lsst.utils.tests.init() 

217 

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

219 lsst.utils.tests.init() 

220 unittest.main()