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

1from __future__ import with_statement 

2 

3import numpy as np 

4import unittest 

5import lsst.utils.tests 

6from lsst.sims.utils import SpatialBounds, CircleBounds, BoxBounds 

7 

8 

9def setup_module(module): 

10 lsst.utils.tests.init() 

11 

12 

13class SpatialBoundsTest(unittest.TestCase): 

14 

15 def testExceptions(self): 

16 """ 

17 Test that the spatial bound classes raise exceptions when you 

18 give them improperly formatted arguments 

19 """ 

20 

21 with self.assertRaises(RuntimeError): 

22 CircleBounds(1.0, 2.0, [3.0, 4.0]) 

23 

24 with self.assertRaises(RuntimeError): 

25 CircleBounds('a', 2.0, 3.0) 

26 

27 with self.assertRaises(RuntimeError): 

28 CircleBounds(1.0, 'b', 4.0) 

29 

30 CircleBounds(1.0, 2.0, 3) 

31 

32 with self.assertRaises(RuntimeError): 

33 BoxBounds(1.0, 2.0, 'abcde') 

34 

35 with self.assertRaises(RuntimeError): 

36 BoxBounds('a', 2, 3.0) 

37 

38 with self.assertRaises(RuntimeError): 

39 BoxBounds(1.0, 'b', 4.0) 

40 

41 BoxBounds(1, 2, 3) 

42 BoxBounds(1, 2, [3, 5]) 

43 

44 def testCircle(self): 

45 myFov = SpatialBounds.getSpatialBounds('circle', 1.0, 2.0, 1.0) 

46 self.assertEqual(myFov.RA, 1.0) 

47 self.assertEqual(myFov.DEC, 2.0) 

48 self.assertEqual(myFov.radius, 1.0) 

49 

50 def testSquare(self): 

51 myFov1 = SpatialBounds.getSpatialBounds('box', 1.0, 2.0, 1.0) 

52 self.assertEqual(myFov1.RA, 1.0) 

53 self.assertEqual(myFov1.DEC, 2.0) 

54 self.assertEqual(myFov1.RAmaxDeg, np.degrees(2.0)) 

55 self.assertEqual(myFov1.RAminDeg, np.degrees(0.0)) 

56 self.assertEqual(myFov1.DECmaxDeg, np.degrees(3.0)) 

57 self.assertEqual(myFov1.DECminDeg, np.degrees(1.0)) 

58 

59 length = [1.0] 

60 myFov2 = SpatialBounds.getSpatialBounds('box', 1.0, 2.0, length) 

61 self.assertEqual(myFov2.RA, 1.0) 

62 self.assertEqual(myFov2.DEC, 2.0) 

63 self.assertEqual(myFov2.RAmaxDeg, np.degrees(2.0)) 

64 self.assertEqual(myFov2.RAminDeg, np.degrees(0.0)) 

65 self.assertEqual(myFov2.DECmaxDeg, np.degrees(3.0)) 

66 self.assertEqual(myFov2.DECminDeg, np.degrees(1.0)) 

67 

68 length = (1.0) 

69 myFov3 = SpatialBounds.getSpatialBounds('box', 1.0, 2.0, length) 

70 self.assertEqual(myFov3.RA, 1.0) 

71 self.assertEqual(myFov3.DEC, 2.0) 

72 self.assertEqual(myFov3.RAmaxDeg, np.degrees(2.0)) 

73 self.assertEqual(myFov3.RAminDeg, np.degrees(0.0)) 

74 self.assertEqual(myFov3.DECmaxDeg, np.degrees(3.0)) 

75 self.assertEqual(myFov3.DECminDeg, np.degrees(1.0)) 

76 

77 length = np.array([1.0]) 

78 myFov4 = SpatialBounds.getSpatialBounds('box', 1.0, 2.0, length) 

79 self.assertEqual(myFov4.RA, 1.0) 

80 self.assertEqual(myFov4.DEC, 2.0) 

81 self.assertEqual(myFov4.RAmaxDeg, np.degrees(2.0)) 

82 self.assertEqual(myFov4.RAminDeg, np.degrees(0.0)) 

83 self.assertEqual(myFov4.DECmaxDeg, np.degrees(3.0)) 

84 self.assertEqual(myFov4.DECminDeg, np.degrees(1.0)) 

85 

86 self.assertRaises(RuntimeError, SpatialBounds.getSpatialBounds, 

87 'utterNonsense', 1.0, 2.0, length) 

88 

89 def testRectangle(self): 

90 

91 length = [1.0, 2.0] 

92 myFov2 = SpatialBounds.getSpatialBounds('box', 1.0, 2.0, length) 

93 self.assertEqual(myFov2.RA, 1.0) 

94 self.assertEqual(myFov2.DEC, 2.0) 

95 self.assertEqual(myFov2.RAmaxDeg, np.degrees(2.0)) 

96 self.assertEqual(myFov2.RAminDeg, np.degrees(0.0)) 

97 self.assertEqual(myFov2.DECmaxDeg, np.degrees(4.0)) 

98 self.assertEqual(myFov2.DECminDeg, np.degrees(0.0)) 

99 

100 length = (1.0, 2.0) 

101 myFov3 = SpatialBounds.getSpatialBounds('box', 1.0, 2.0, length) 

102 self.assertEqual(myFov3.RA, 1.0) 

103 self.assertEqual(myFov3.DEC, 2.0) 

104 self.assertEqual(myFov3.RAmaxDeg, np.degrees(2.0)) 

105 self.assertEqual(myFov3.RAminDeg, np.degrees(0.0)) 

106 self.assertEqual(myFov3.DECmaxDeg, np.degrees(4.0)) 

107 self.assertEqual(myFov3.DECminDeg, np.degrees(0.0)) 

108 

109 length = np.array([1.0, 2.0]) 

110 myFov4 = SpatialBounds.getSpatialBounds('box', 1.0, 2.0, length) 

111 self.assertEqual(myFov4.RA, 1.0) 

112 self.assertEqual(myFov4.DEC, 2.0) 

113 self.assertEqual(myFov4.RAmaxDeg, np.degrees(2.0)) 

114 self.assertEqual(myFov4.RAminDeg, np.degrees(0.0)) 

115 self.assertEqual(myFov4.DECmaxDeg, np.degrees(4.0)) 

116 self.assertEqual(myFov4.DECminDeg, np.degrees(0.0)) 

117 

118 self.assertRaises(RuntimeError, SpatialBounds.getSpatialBounds, 

119 'box', 1.0, 2.0, 'moreUtterNonsense') 

120 

121 def test_eq(self): 

122 """ 

123 Test that we have implemented __eq__and __ne__ correctly 

124 """ 

125 ref_circle = CircleBounds(113.1, -20.1, 1.56) 

126 other_circle = CircleBounds(113.1, -20.1, 1.56) 

127 self.assertEqual(ref_circle, other_circle) 

128 self.assertTrue(ref_circle == other_circle) 

129 self.assertFalse(ref_circle != other_circle) 

130 

131 other_circle = CircleBounds(113.2, -20.1, 1.56) 

132 self.assertNotEqual(ref_circle, other_circle) 

133 self.assertFalse(ref_circle == other_circle) 

134 self.assertTrue(ref_circle != other_circle) 

135 

136 other_circle = CircleBounds(113.1, -20.2, 1.56) 

137 self.assertNotEqual(ref_circle, other_circle) 

138 self.assertFalse(ref_circle == other_circle) 

139 self.assertTrue(ref_circle != other_circle) 

140 

141 other_circle = CircleBounds(113.1, -20.1, 1.57) 

142 self.assertNotEqual(ref_circle, other_circle) 

143 self.assertFalse(ref_circle == other_circle) 

144 self.assertTrue(ref_circle != other_circle) 

145 

146 ref_square = BoxBounds(113.1, -20.1, 1.56) 

147 self.assertNotEqual(ref_circle, ref_square) 

148 self.assertFalse(ref_circle == ref_square) 

149 self.assertTrue(ref_circle != ref_square) 

150 

151 other_square = BoxBounds(113.1, -20.1, 1.56) 

152 self.assertEqual(ref_square, other_square) 

153 self.assertTrue(ref_square == other_square) 

154 self.assertFalse(ref_square != other_square) 

155 

156 other_square = BoxBounds(113.2, -20.1, 1.56) 

157 self.assertNotEqual(ref_square, other_square) 

158 self.assertFalse(ref_square == other_square) 

159 self.assertTrue(ref_square != other_square) 

160 

161 other_square = BoxBounds(113.1, -20.2, 1.56) 

162 self.assertNotEqual(ref_square, other_square) 

163 self.assertFalse(ref_square == other_square) 

164 self.assertTrue(ref_square != other_square) 

165 

166 other_square = BoxBounds(113.1, -20.1, 1.57) 

167 self.assertNotEqual(ref_square, other_square) 

168 self.assertFalse(ref_square == other_square) 

169 self.assertTrue(ref_square != other_square) 

170 

171 ref_rect = BoxBounds(113.1, -20.1, [1.56, 1.56]) 

172 self.assertEqual(ref_rect, ref_square) 

173 self.assertTrue(ref_rect == ref_square) 

174 self.assertFalse(ref_rect != ref_square) 

175 

176 self.assertNotEqual(ref_rect, ref_circle) 

177 self.assertFalse(ref_rect == ref_circle) 

178 self.assertTrue(ref_rect != ref_circle) 

179 

180 ref_rect = BoxBounds(113.1, -20.1, [1.56, 1.52]) 

181 self.assertNotEqual(ref_rect, ref_square) 

182 self.assertFalse(ref_rect == ref_square) 

183 self.assertTrue(ref_rect != ref_square) 

184 

185 other_rect = BoxBounds(113.1, -20.1, [1.56, 1.52]) 

186 self.assertEqual(ref_rect, other_rect) 

187 self.assertTrue(ref_rect == other_rect) 

188 self.assertFalse(ref_rect != other_rect) 

189 

190 other_rect = BoxBounds(113.1, -20.1, np.array([1.56, 1.52])) 

191 self.assertEqual(ref_rect, other_rect) 

192 self.assertTrue(ref_rect == other_rect) 

193 self.assertFalse(ref_rect != other_rect) 

194 

195 other_rect = BoxBounds(113.1, -20.1, (1.56, 1.52)) 

196 self.assertEqual(ref_rect, other_rect) 

197 self.assertTrue(ref_rect == other_rect) 

198 self.assertFalse(ref_rect != other_rect) 

199 

200 other_rect = BoxBounds(113.2, -20.1, (1.56, 1.52)) 

201 self.assertNotEqual(ref_rect, other_rect) 

202 self.assertFalse(ref_rect == other_rect) 

203 self.assertTrue(ref_rect != other_rect) 

204 

205 other_rect = BoxBounds(113.1, -20.2, (1.56, 1.52)) 

206 self.assertNotEqual(ref_rect, other_rect) 

207 self.assertFalse(ref_rect == other_rect) 

208 self.assertTrue(ref_rect != other_rect) 

209 

210 other_rect = BoxBounds(113.1, -20.1, (1.57, 1.52)) 

211 self.assertNotEqual(ref_rect, other_rect) 

212 self.assertFalse(ref_rect == other_rect) 

213 self.assertTrue(ref_rect != other_rect) 

214 

215 other_rect = BoxBounds(113.1, -20.1, (1.56, 1.51)) 

216 self.assertNotEqual(ref_rect, other_rect) 

217 self.assertFalse(ref_rect == other_rect) 

218 self.assertTrue(ref_rect != other_rect) 

219 

220 

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

222 pass 

223 

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

225 lsst.utils.tests.init() 

226 unittest.main()