def test_init(self): catd = cd.catData() bms = bs.BeamOnly(catd) nt.assert_equal(bms.bm_pix, 61) nt.assert_equal(bms.cat, catd) bms = bs.BeamOnly(catd, 30) nt.assert_equal(bms.bm_pix, 30) nt.assert_equal(bms.cat, catd)
def test_flip_ps(self): bms = bs.BeamOnly(bm_pix=31) ps, ws = bms.get_weights(np.array([[np.pi/2], [np.pi/2]]), 0, -1) np.testing.assert_equal(ps, [np.array([[15], [15]]), np.array([[15], [16]]), np.array([[16], [15]]), np.array([[16], [16]])]) bms = bs.BeamOnly(bm_pix=31) ps, ws = bms.get_weights(np.array([[np.pi/4], [np.pi/4]]), 0, 1) ps_f, ws_f = bms.get_weights(np.array([[np.pi/4], [np.pi/4]]), 0, -1) for i in range(len(ps)): nt.assert_almost_equal(ps_f[i][0], ps[i][0] - 15)
def test_rotate_ps(self): bms = bs.BeamOnly(bm_pix=31) ps, ws = bms.get_weights(np.array([[np.pi/2], [np.pi/2]]), 2*np.pi, 1) np.testing.assert_equal(ps, [np.array([[15], [15]]), np.array([[15], [16]]), np.array([[16], [15]]), np.array([[16], [16]])]) bms = bs.BeamOnly(catd, 31) ps, ws = bms.get_weights(np.array([[np.pi/4], [np.pi/4]]), np.pi/2, 1) ps_270, ws_270 = bms.get_weights(np.array([[np.pi/4], [np.pi/4]]), -3 * np.pi/2, 1) np.testing.assert_almost_equal(ps, ps_270) np.testing.assert_almost_equal(ws, ws_270)
def test_unravel_pix(self): bms = bs.BeamOnly() ind = bms.unravel_pix(60, (0, 0)) nt.assert_equal(ind, 0) ind = bms.unravel_pix(60, (0, 5)) nt.assert_equal(ind, 5) bms = bs.BeamOnly(catd, bm_pix=30) ind = bms.unravel_pix(30, (0, 5)) nt.assert_equal(ind, 5) ind = bms.unravel_pix(30, (2, 5)) nt.assert_equal(ind, 65)
def test_beam_rotate(self): fluxvals = np.random.random(50) + 10 catd = gen_catdata_grid(50, fluxvals, sigma_x=0.4, sigma_y=0.2) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxvals) sol = bms.solve() obsbeam = bms.eval_sol(sol) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxvals, theta=[np.pi/2]) sol = bms.solve() obsbeam_90 = bms.eval_sol(sol) np.testing.assert_allclose(obsbeam, np.rot90(obsbeam_90), atol=1e-01)
def test_sol_values(self): fluxval = np.array([2.0]) catd = gen_catdata_zensrc(fluxval, sigma=2) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxval) sol = bms.solve() nt.assert_true(sol['b{}'.format(bms.unravel_pix(31, (15, 15)))], 1.0) fluxval = np.array([2.0]) catd = gen_catdata_zensrc(fluxval, sigma=2) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxval) sol = bms.solve(mode='pinv') nt.assert_true(sol['b{}'.format(bms.unravel_pix(31, (15, 15)))], 1.0)
def test_add_eqs(self): fluxval = np.array([2.0]) catd = gen_catdata_zensrc(fluxval, sigma=2) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxval) eq_keys = bms.eqs.keys() nt.assert_equal(len(eq_keys), 1)
def test_get_A(self): bms = bs.BeamOnly(bm_pix=31) ps, ws = bms.get_weights(np.array([[np.pi/2], [np.pi/2]]), 0, 1) bms._mk_eq(ps, ws, 1, 1, 0.1, 0, 0, equal_wgts=True) bms._build_solver() A = bms.get_A(bms.ls) np.testing.assert_almost_equal(A, np.array([[[1.], [0.], [0.], [0.]]]))
def test_get_weights(self): bms = bs.BeamOnly(bm_pix=31) ps, ws = bms.get_weights(np.array([[np.pi/2], [np.pi/2]]), 0, 1) nt.assert_equal(len(ps), 4) nt.assert_equal(len(ws), 4) np.testing.assert_equal(ps, [np.array([[15], [15]]), np.array([[15], [16]]), np.array([[16], [15]]), np.array([[16], [16]])]) nt.assert_almost_equal(np.sum(ws), 1.0) np.testing.assert_almost_equal(ws, [np.array([1.0]), np.array([0.]), np.array([0.]), np.array([0.])])
def test_consts(self): bms = bs.BeamOnly(bm_pix=31) ps, ws = bms.get_weights(np.array([[np.pi/2], [np.pi/2]]), 0, 1) bms._mk_eq(ps, ws, 1, 1, 0.1, 0, 0, equal_wgts=True) cns_keys = bms.consts.keys() nt.assert_almost_equal(len(cns_keys), 4) px0 = bms.unravel_pix(31, (15, 15)) nt.assert_almost_equal(bms.consts['w%s_s0_t0'%px0], 1.0)
def test_eval_error(self): fluxvals = np.random.random(50) + 10 catd = gen_catdata_grid(50, fluxvals, sigma_x=0.4, sigma_y=0.2) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxvals) sol = bms.solve() beam_error = bms.eval_beam_error(sol, bms.ls) nt.assert_equal(beam_error.shape, (31, 31))
def test_solve_grid(self): fluxvals = np.random.random(50) + 10 catd = gen_catdata_grid(50, fluxvals, sigma_x=0.2) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxvals) sol = bms.solve() obsbeam = bms.eval_sol(sol) gaussbeam = bt.get_gaussbeam(3, mu_x=15, mu_y=15, size=31) np.testing.assert_allclose(gaussbeam, obsbeam, atol=1e-01) # most values are equal to 1e-2, with some exceptions
def test_svd(self): bms = bs.BeamOnly(bm_pix=31) ps, ws = bms.get_weights(np.array([[np.pi/2], [np.pi/2]]), 0, 1) bms._mk_eq(ps, ws, 1, 1, 0.1, 0, 0, equal_wgts=True) bms._build_solver() A = bms.get_A(bms.ls) U, S, V = bms.svd(bms.ls, A) nt.assert_almost_equal(S[0], 1.0) np.testing.assert_almost_equal(np.dot(U, U.T), np.identity(4)) np.testing.assert_almost_equal(np.dot(V, V.T), np.identity(4))
def test_solve_src(self): fluxval = np.array([2.0]) catd = gen_catdata_zensrc(fluxval, sigma=2) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxval) sol = bms.solve() obsbeam = bms.eval_sol(sol) answer = np.zeros((31, 31)) answer[15, 15] = 1 np.testing.assert_almost_equal(obsbeam, answer)
def test_eval_sol(self): sol = {'b1': 1} bms = bs.BeamOnly(cat=catd, bm_pix=31) output = bms.eval_sol(sol) answer = np.zeros((31, 31)) answer.flat[1] = 1 np.testing.assert_equal(output, answer) sol = {'b%d'%i:1 for i in range(31**2)} output = bms.eval_sol(sol) answer = np.ones((31, 31)) np.testing.assert_equal(output, answer)
def test_sol_keys(self): fluxval = np.array([2.0]) catd = gen_catdata_zensrc(fluxval, sigma=2) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxval) sol = bms.solve() nt.assert_equal(len(sol.keys()), 4) nt.assert_true('b{}'.format(bms.unravel_pix(31, (15, 15))) in sol.keys()) nt.assert_true('b{}'.format(bms.unravel_pix(31, (15, 16))) in sol.keys()) nt.assert_true('b{}'.format(bms.unravel_pix(31, (16, 15))) in sol.keys()) nt.assert_true('b{}'.format(bms.unravel_pix(31, (16, 16))) in sol.keys())
def test_full_corr_noise_matrix(self): azalt = np.array([[[np.pi, np.pi, np.pi]], [[np.pi, np.pi, np.pi]]]) cat_sim = create_catdata(azalt, np.array([[[3.,3.,3.]]]), np.array([[[.1,.2,.1]]]), 1, 3) bms = bs.BeamOnly(cat_sim, bm_pix=31) bms.add_eqs(catalog_flux=np.array([3])) sol = bms.solve() noise_array = bms._full_corr_noise_matrix() nt.assert_equal(noise_array.shape, (3, 3)) np.testing.assert_almost_equal(np.diag(noise_array), np.array([.1,.2,.1])) ans_matrix = np.array([[0.1, 0.2, 0.1], [0.1, 0.2, 0.1], [0.1, 0.2, 0.1]]) np.testing.assert_almost_equal(noise_array, ans_matrix)
def test_noisy_sol_values(self): azalt = np.array([[[np.pi, np.pi, np.pi, np.pi]], [[np.pi, np.pi, np.pi, np.pi]]]) cat_sim = create_catdata(azalt, np.array([[[3.,3.,3., 3]]]), np.array([[[.1,.2,.1, .1]]]), 1, 4) bms = bs.BeamOnly(cat_sim, bm_pix=31) bms.add_eqs(catalog_flux=np.array([3])) sol = bms.solve(noise=True, noise_type='partial') nt.assert_true(sol['b464'], 0.5) nt.assert_true(sol['b495'], 0.5) sol = bms.solve(mode='pinv', noise=True, noise_type='partial') nt.assert_true(sol['b464'], 0.5) nt.assert_true(sol['b495'], 0.5)
def test_mk_eq(self): bms = bs.BeamOnly(bm_pix=31) ps, ws = bms.get_weights(np.array([[np.pi/2], [np.pi/2]]), 0, 1) bms._mk_eq(ps, ws, 1, 1, 0.1, 0, 0, equal_wgts=True) eq_keys = bms.eqs.keys() cns_keys = bms.consts.keys() nt.assert_almost_equal(len(eq_keys), 1) px0 = bms.unravel_pix(31, (15, 15)) px1 = bms.unravel_pix(31, (15, 16)) px2 = bms.unravel_pix(31, (16, 15)) px3 = bms.unravel_pix(31, (16, 16)) eq0 = 'w%s_s0_t0*b%s + w%s_s0_t0*b%s + w%s_s0_t0*b%s + w%s_s0_t0*b%s'%(px0, px0, px1, px1, px2, px2, px3, px3) nt.assert_equal(list(eq_keys)[0], eq0)
def test_rotate_mat(self): bms = bs.BeamOnly(bm_pix=31) theta = 0 mat0 = np.array([[np.cos(theta), -1 * np.sin(theta)], [np.sin(theta), np.cos(theta)]]) mat = bms.rotate_mat(theta) np.testing.assert_almost_equal(mat, mat0) theta = np.pi mat0 = np.array([[np.cos(theta), -1 * np.sin(theta)], [np.sin(theta), np.cos(theta)]]) mat = bms.rotate_mat(theta) np.testing.assert_almost_equal(mat, mat0) theta = np.pi/4 mat0 = np.array([[np.cos(theta), -1 * np.sin(theta)], [np.sin(theta), np.cos(theta)]]) mat = bms.rotate_mat(theta) np.testing.assert_almost_equal(mat, mat0) theta = 2 * np.pi mat0 = np.array([[np.cos(theta), -1 * np.sin(theta)], [np.sin(theta), np.cos(theta)]]) mat = np.array([[1., 0.], [0., 1.]]) np.testing.assert_almost_equal(mat, mat0)
def test_get_noise_matrix(self): azalt = np.array([[[np.pi, np.pi, np.pi]], [[np.pi, np.pi, np.pi]]]) cat_sim = create_catdata(azalt, np.array([[[3., 3., 3.]]]), np.array([[[.1,.2,.1]]]), 1, 3) bms = bs.BeamOnly(cat_sim, bm_pix=31) bms.add_eqs(catalog_flux=np.array([3])) sol = bms.solve() # uncorrelated noise noise_matrix = bms.get_noise_matrix(noise_type='uncorr') ans_matrix = np.array([[0.1, 0., 0. ], [0. , 0.2, 0. ], [0. , 0. , 0.1]]).T np.testing.assert_almost_equal(noise_matrix, ans_matrix) # partial correlated noise noise_matrix = bms.get_noise_matrix(noise_type='partial') ans_matrix = np.array([[0.1, 0.1, 0. ], [0.05 , 0.2, 0.05 ], [0. , 0.1 , 0.1]]).T np.testing.assert_almost_equal(noise_matrix, ans_matrix) # full correlated noise noise_matrix = bms.get_noise_matrix(noise_type='corr') ans_matrix = np.array([[0.1, 0.2, 0.1], [0.1, 0.2, 0.1], [0.1, 0.2, 0.1]]) np.testing.assert_almost_equal(noise_matrix, ans_matrix)
def test_mk_key(self): bms = bs.BeamOnly() key = bms._mk_key(0, 0, 0) nt.assert_equal(key, 'w0_s0_t0') key = bms._mk_key(0, 1, 4) nt.assert_equal(key, 'w0_s1_t4')
def test_eqs(self): bms = bs.BeamOnly(catd, 31) ps, ws = bms.get_weights(np.array([[np.pi/2], [np.pi/2]]), 0, 1) bms._mk_eq(ps, ws, 1, 1, 0.1, 0, 0, equal_wgts=True) eq_keys = bms.eqs.keys() nt.assert_almost_equal(bms.eqs[list(eq_keys)[0]], 1)
def test_diag_noise(self): fluxval = np.array([2.0]) catd = gen_catdata_zensrc(fluxval, sigma=2) bms = bs.BeamOnly(cat=catd, bm_pix=31) bms.add_eqs(catalog_flux=fluxval) nt.assert_equal(len(list(bms.sigma.keys())), 1)
def test_calc_catalog_flux(self): bms = bs.BeamOnly(catd, 31) beam = bt.get_fitsbeam(beamfits, 151e6) catalog_flux, catalog_error = bms.calc_catalog_flux(beam, 'xx') nt.assert_almost_equal(catalog_flux[2], 1.000, 3)
def test_build_solver(self): bms = bs.BeamOnly(bm_pix=31) ps, ws = bms.get_weights(np.array([[np.pi/2], [np.pi/2]]), 0, 1) bms._mk_eq(ps, ws, 1, 1, 0.1, 0, 0, equal_wgts=True) bms._build_solver() nt.assert_true(isinstance(bms.ls, linsolve.LinearSolver))