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))
