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 unittest 

2import numpy as np 

3import numbers 

4 

5import lsst.utils.tests 

6 

7from lsst.sims.utils import _FactorialGenerator 

8from lsst.sims.utils import ZernikePolynomialGenerator 

9 

10 

11def setup_module(module): 

12 lsst.utils.tests.init() 

13 

14 

15class FactorialTestCase(unittest.TestCase): 

16 

17 def test_factorial(self): 

18 gen = _FactorialGenerator() 

19 ii = gen.evaluate(9) 

20 ans = 9*8*7*6*5*4*3*2 

21 self.assertEqual(ii, ans) 

22 

23 ii = gen.evaluate(15) 

24 ans = 15*14*13*12*11*10*9*8*7*6*5*4*3*2 

25 self.assertEqual(ii, ans) 

26 

27 ii = gen.evaluate(3) 

28 ans = 6 

29 self.assertEqual(ii, ans) 

30 

31 self.assertEqual(gen.evaluate(0), 1) 

32 self.assertEqual(gen.evaluate(1), 1) 

33 

34 

35class ZernikeTestCase(unittest.TestCase): 

36 

37 longMessage = True 

38 

39 @classmethod 

40 def setUpClass(cls): 

41 cls.d_r = 0.01 

42 cls.d_phi = 0.005*np.pi 

43 r_grid = np.arange(0.0, 1.0, cls.d_r) 

44 phi_grid = np.arange(0.0, 2.0*np.pi, cls.d_phi) 

45 mesh = np.meshgrid(r_grid, phi_grid) 

46 cls.r_grid = mesh[0].flatten() 

47 cls.phi_grid = mesh[1].flatten() 

48 

49 r_grid = np.arange(0.0, 1.0, 0.1) 

50 phi_grid =np.arange(0.0, 2.0*np.pi, 0.05*np.pi) 

51 mesh=np.meshgrid(r_grid, phi_grid) 

52 cls.r_grid_small = mesh[0].flatten() 

53 cls.phi_grid_small = mesh[1].flatten() 

54 

55 def test_orthogonality(self): 

56 """ 

57 Test that ZernikePolynomialGenerator returns 

58 polynomials that are orthogonal on the unit disc 

59 """ 

60 

61 polynomials = {} 

62 z_gen = ZernikePolynomialGenerator() 

63 

64 for n in range(3): 

65 for m in range(-n, n+1, 2): 

66 vals = np.zeros(len(self.r_grid), dtype=float) 

67 for ii, (rr, pp) in enumerate(zip(self.r_grid, self.phi_grid)): 

68 vals[ii] = z_gen.evaluate(rr, pp, n, m) 

69 nm_tuple = (n,m) 

70 polynomials[nm_tuple] = vals 

71 

72 p_keys = list(polynomials.keys()) 

73 for ii in range(len(p_keys)): 

74 p1_name = p_keys[ii] 

75 p1 = polynomials[p1_name] 

76 integral = (p1*p1*self.r_grid*self.d_r*self.d_phi).sum() 

77 normed_integral = integral/z_gen.norm(p1_name[0], p1_name[1]) 

78 self.assertLess(np.abs(normed_integral-1.0), 0.04) 

79 for jj in range(ii+1, len(p_keys)): 

80 p2_name = p_keys[jj] 

81 p2 = polynomials[p2_name] 

82 dot = (p1*p2*self.r_grid*self.d_r*self.d_phi).sum() 

83 msg = '\n%s norm %e\n dot %e\n' % (p1_name, integral, dot) 

84 self.assertLess(np.abs(dot/integral), 0.01, msg=msg) 

85 

86 def test_zeros(self): 

87 """ 

88 Test that ZernikePolynomialGenerator returns zero 

89 when values of n and m require it. 

90 """ 

91 rng = np.random.RandomState(88) 

92 z_gen = ZernikePolynomialGenerator() 

93 for n in range(4): 

94 for m in range(-(n-1), n, 2): 

95 r = rng.random_sample() 

96 phi = rng.random_sample()*2.0*np.pi 

97 self.assertAlmostEqual(0.0, z_gen.evaluate(r, phi, n, m), 10) 

98 

99 def test_r_greater_than_one(self): 

100 """ 

101 Test that the expected error is raised if we try to evaluate 

102 the Zernike polynomial with r>1 

103 """ 

104 z_gen = ZernikePolynomialGenerator() 

105 vv = z_gen.evaluate(1.2, 2.1, 2, 0) 

106 self.assertTrue(np.isnan(vv)) 

107 vv = z_gen.evaluate(np.array([0.1, 0.5, 1.2]), 

108 np.array([0.1, 0.2, 0.3]), 

109 2, -2) 

110 self.assertTrue(np.isnan(vv[2])) 

111 self.assertFalse(np.isnan(vv[0])) 

112 self.assertFalse(np.isnan(vv[1])) 

113 vv = z_gen.evaluate_xy(1.1, 1.2, 4, -2) 

114 self.assertTrue(np.isnan(vv)) 

115 vv = z_gen.evaluate_xy(np.array([0.1, 0.2, 0.3]), 

116 np.array([0.1, 1.0, 0.1]), 

117 4, 2) 

118 self.assertTrue(np.isnan(vv[1])) 

119 self.assertFalse(np.isnan(vv[0])) 

120 self.assertFalse(np.isnan(vv[2])) 

121 

122 def test_array(self): 

123 """ 

124 Test that ZernikePolynomialGenerator can handle arrays of inputs 

125 """ 

126 z_gen = ZernikePolynomialGenerator() 

127 n = 2 

128 m = -2 

129 val_arr = z_gen.evaluate(self.r_grid_small, self.phi_grid_small, n, m) 

130 self.assertEqual(len(val_arr), len(self.r_grid_small)) 

131 for ii, (rr, pp) in enumerate(zip(self.r_grid_small, 

132 self.phi_grid_small)): 

133 

134 vv = z_gen.evaluate(rr, pp, n, m) 

135 self.assertAlmostEqual(vv, val_arr[ii], 14) 

136 

137 def test_xy(self): 

138 """ 

139 Test that ZernikePolynomialGenerator can handle Cartesian coordinates 

140 """ 

141 n = 4 

142 m = 2 

143 z_gen = ZernikePolynomialGenerator() 

144 x = self.r_grid_small*np.cos(self.phi_grid_small) 

145 y = self.r_grid_small*np.sin(self.phi_grid_small) 

146 val_arr = z_gen.evaluate_xy(x, y, n, m) 

147 self.assertGreater(np.abs(val_arr).max(), 1.0e-6) 

148 for ii, (rr, pp) in enumerate(zip(self.r_grid_small, 

149 self.phi_grid_small)): 

150 vv = z_gen.evaluate(rr, pp, n, m) 

151 self.assertAlmostEqual(vv, val_arr[ii], 14) 

152 

153 def test_xy_one_at_a_time(self): 

154 """ 

155 Test that ZernikePolynomialGenerator can handle 

156 scalar Cartesian coordinates (as opposed to arrays 

157 of Cartesian coordinates) 

158 """ 

159 n = 4 

160 m = 2 

161 z_gen = ZernikePolynomialGenerator() 

162 x = self.r_grid_small*np.cos(self.phi_grid_small) 

163 y = self.r_grid_small*np.sin(self.phi_grid_small) 

164 

165 for ii in range(len(self.r_grid_small)): 

166 vv_r = z_gen.evaluate(self.r_grid_small[ii], 

167 self.phi_grid_small[ii], n, m) 

168 vv_xy = z_gen.evaluate_xy(x[ii], y[ii], n, m) 

169 self.assertAlmostEqual(vv_r, vv_xy, 14) 

170 self.assertIsInstance(vv_xy, numbers.Number) 

171 

172 def test_Zernike_origin(self): 

173 """ 

174 Test that ZernikePolynomialGenerator is well-behaved 

175 at r=0 

176 """ 

177 n = 4 

178 m = 2 

179 z_gen = ZernikePolynomialGenerator() 

180 ans = z_gen.evaluate(0.0, 1.2, n, m) 

181 self.assertEqual(ans, 0.0) 

182 ans = z_gen.evaluate(np.array([0.0, 0.0]), 

183 np.array([1.2, 2.1]), 

184 n, m) 

185 

186 np.testing.assert_array_equal(ans, np.zeros(2, dtype=float)) 

187 ans = z_gen.evaluate_xy(0.0, 0.0, n, m) 

188 self.assertEqual(ans, 0.0) 

189 ans = z_gen.evaluate_xy(np.zeros(2, dtype=float), 

190 np.zeros(2, dtype=float), 

191 n, m) 

192 np.testing.assert_array_equal(ans, np.zeros(2, dtype=float)) 

193 

194 n = 0 

195 m = 0 

196 ans = z_gen.evaluate(0.0, 1.2, n, m) 

197 self.assertEqual(ans, 1.0) 

198 ans = z_gen.evaluate(np.array([0.0, 0.0]), 

199 np.array([1.2, 2.1]), 

200 n, m) 

201 

202 np.testing.assert_array_equal(ans, np.ones(2, dtype=float)) 

203 ans = z_gen.evaluate_xy(0.0, 0.0, n, m) 

204 self.assertEqual(ans, 1.0) 

205 ans = z_gen.evaluate_xy(np.zeros(2, dtype=float), 

206 np.zeros(2, dtype=float), 

207 n, m) 

208 np.testing.assert_array_equal(ans, np.ones(2, dtype=float)) 

209 

210 

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

212 pass 

213 

214 

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

216 lsst.utils.tests.init() 

217 unittest.main()