Coverage for tests/testZernikeModule.py : 14%

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
5import lsst.utils.tests
7from lsst.sims.utils import _FactorialGenerator
8from lsst.sims.utils import ZernikePolynomialGenerator
11def setup_module(module):
12 lsst.utils.tests.init()
15class FactorialTestCase(unittest.TestCase):
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)
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)
27 ii = gen.evaluate(3)
28 ans = 6
29 self.assertEqual(ii, ans)
31 self.assertEqual(gen.evaluate(0), 1)
32 self.assertEqual(gen.evaluate(1), 1)
35class ZernikeTestCase(unittest.TestCase):
37 longMessage = True
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()
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()
55 def test_orthogonality(self):
56 """
57 Test that ZernikePolynomialGenerator returns
58 polynomials that are orthogonal on the unit disc
59 """
61 polynomials = {}
62 z_gen = ZernikePolynomialGenerator()
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
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)
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)
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]))
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)):
134 vv = z_gen.evaluate(rr, pp, n, m)
135 self.assertAlmostEqual(vv, val_arr[ii], 14)
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)
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)
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)
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)
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))
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)
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))
211class MemoryTestClass(lsst.utils.tests.MemoryTestCase):
212 pass
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()