def test_spemd(self):
from lenstronomy.LensModel.Profiles.spep import SPEP
from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa
spep = SPEP()
mge_kappa = MultiGaussianKappa()
n_comp = 8
theta_E = 1.41
kwargs = {'theta_E': theta_E, 'e1': 0, 'e2': 0, 'gamma': 1.61}
rs = np.logspace(-2., 1., 100) * theta_E
f_xx, f_yy, f_xy = spep.hessian(rs, 0, **kwargs)
kappa = 1 / 2. * (f_xx + f_yy)
amplitudes, sigmas, norm = mge.mge_1d(rs, kappa, N=n_comp)
kappa_mge = self.multiGaussian.function(rs,
np.zeros_like(rs),
amp=amplitudes,
sigma=sigmas)
f_xx_mge, f_yy_mge, f_xy_mge = mge_kappa.hessian(rs,
np.zeros_like(rs),
amp=amplitudes,
sigma=sigmas)
for i in range(0, 80):
npt.assert_almost_equal(kappa_mge[i],
1. / 2 * (f_xx_mge[i] + f_yy_mge[i]),
decimal=1)
npt.assert_almost_equal((kappa[i] - kappa_mge[i]) / kappa[i],
0,
decimal=1)
f_ = spep.function(theta_E, 0, **kwargs)
f_mge = mge_kappa.function(theta_E, 0, sigma=sigmas, amp=amplitudes)
npt.assert_almost_equal(f_mge / f_, 1, decimal=2)
class TestNIE_POTENTIAL(object):
"""
tests the NIE_POTENTIAL profile for different rotations
"""
def setup(self):
self.nie_potential = NIE_POTENTIAL()
self.spep = SPEP()
def test_function(self):
y = np.array([1., 2])
x = np.array([0., 0.])
theta_E = 1.
theta_c = 0.
#############
# no rotation
#############
e1, e2 = 0.05, 0.0
eps = np.sqrt(e1**2 + e2**2)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
# map the nie_potential input to the spep input
gamma_spep = 2.
q_spep = np.sqrt(q)
e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep)
theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q)
theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) /
(1 + eps))**0.25
# compare the non-rotated output
values = self.nie_potential.function(x, y, theta_E, theta_c, e1, e2)
delta_pot = values[1] - values[0]
values = self.spep.function(x, y, theta_E_spep, gamma_spep, e1_spep,
e2_spep)
delta_pot_spep = values[1] - values[0]
npt.assert_almost_equal(delta_pot, delta_pot_spep, decimal=4)
############
# rotation 1
############
e1, e2 = 0.05, 0.1
eps = np.sqrt(e1**2 + e2**2)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
# map the nie_potential input to the spep input
gamma_spep = 2.
q_spep = np.sqrt(q)
e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep)
theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q)
theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) /
(1 + eps))**0.25
# compare the rotated output
values = self.nie_potential.function(x, y, theta_E, theta_c, e1, e2)
delta_pot = values[1] - values[0]
values = self.spep.function(x, y, theta_E_spep, gamma_spep, e1_spep,
e2_spep)
delta_pot_spep = values[1] - values[0]
npt.assert_almost_equal(delta_pot, delta_pot_spep, decimal=4)
############
# rotation 2
############
e1, e2 = 0.15, 0.13
eps = np.sqrt(e1**2 + e2**2)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
# map the nie_potential input to the spep input
gamma_spep = 2.
q_spep = np.sqrt(q)
e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep)
theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q)
theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) /
(1 + eps))**0.25
# compare the rotated output
values = self.nie_potential.function(x, y, theta_E, theta_c, e1, e2)
delta_pot = values[1] - values[0]
values = self.spep.function(x, y, theta_E_spep, gamma_spep, e1_spep,
e2_spep)
delta_pot_spep = values[1] - values[0]
npt.assert_almost_equal(delta_pot, delta_pot_spep, decimal=4)
def test_derivatives(self):
x = np.array([1])
y = np.array([2])
theta_E = 1.
theta_c = 0.
#############
# no rotation
#############
e1, e2 = 0.05, 0.0
eps = np.sqrt(e1**2 + e2**2)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
# map the nie_potential input to the spep input
gamma_spep = 2.
q_spep = np.sqrt(q)
e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep)
theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q)
theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) /
(1 + eps))**0.25
# compare the non-rotated output
f_x, f_y = self.nie_potential.derivatives(x, y, theta_E, theta_c, e1,
e2)
f_x_nie, f_y_nie = self.spep.derivatives(x, y, theta_E_spep,
gamma_spep, e1_spep, e2_spep)
npt.assert_almost_equal(f_x, f_x_nie, decimal=4)
npt.assert_almost_equal(f_y, f_y_nie, decimal=4)
############
# rotation 1
############
e1, e2 = 0.05, 0.1
eps = np.sqrt(e1**2 + e2**2)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
# map the nie_potential input to the spep input
gamma_spep = 2.
q_spep = np.sqrt(q)
e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep)
theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q)
theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) /
(1 + eps))**0.25
# compare the rotated output
f_x, f_y = self.nie_potential.derivatives(x, y, theta_E, theta_c, e1,
e2)
f_x_nie, f_y_nie = self.spep.derivatives(x, y, theta_E_spep,
gamma_spep, e1_spep, e2_spep)
npt.assert_almost_equal(f_x, f_x_nie, decimal=4)
npt.assert_almost_equal(f_y, f_y_nie, decimal=4)
############
# rotation 2
############
e1, e2 = 0.15, 0.13
eps = np.sqrt(e1**2 + e2**2)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
# map the nie_potential input to the spep input
gamma_spep = 2.
q_spep = np.sqrt(q)
e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep)
theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q)
theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) /
(1 + eps))**0.25
# compare the rotated output
f_x, f_y = self.nie_potential.derivatives(x, y, theta_E, theta_c, e1,
e2)
f_x_nie, f_y_nie = self.spep.derivatives(x, y, theta_E_spep,
gamma_spep, e1_spep, e2_spep)
npt.assert_almost_equal(f_x, f_x_nie, decimal=4)
npt.assert_almost_equal(f_y, f_y_nie, decimal=4)
def test_hessian(self):
x = np.array([1])
y = np.array([2])
theta_E = 1.
theta_c = 0.
#############
# no rotation
#############
e1, e2 = 0.05, 0.0
eps = np.sqrt(e1**2 + e2**2)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
# map the nie_potential input to the spep input
gamma_spep = 2.
q_spep = np.sqrt(q)
e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep)
theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q)
theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) /
(1 + eps))**0.25
# compare the non-rotated output
f_xx, f_xy, f_yx, f_yy = self.nie_potential.hessian(
x, y, theta_E, theta_c, e1, e2)
f_xx_nie, f_xy_nie, f_yx_nie, f_yy_nie = self.spep.hessian(
x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep)
npt.assert_almost_equal(f_xx, f_xx_nie, decimal=4)
npt.assert_almost_equal(f_yy, f_yy_nie, decimal=4)
npt.assert_almost_equal(f_xy, f_xy_nie, decimal=4)
npt.assert_almost_equal(f_yx, f_yx_nie, decimal=4)
############
# rotation 1
############
e1, e2 = 0.05, 0.1
eps = np.sqrt(e1**2 + e2**2)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
# map the nie_potential input to the spep input
gamma_spep = 2.
q_spep = np.sqrt(q)
e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep)
theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q)
theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) /
(1 + eps))**0.25
# compare the rotated output
f_xx, f_xy, f_yx, f_yy = self.nie_potential.hessian(
x, y, theta_E, theta_c, e1, e2)
f_xx_nie, f_xy_nie, f_yx_nie, f_yy_nie = self.spep.hessian(
x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep)
npt.assert_almost_equal(f_xx, f_xx_nie, decimal=4)
npt.assert_almost_equal(f_yy, f_yy_nie, decimal=4)
npt.assert_almost_equal(f_xy, f_xy_nie, decimal=4)
npt.assert_almost_equal(f_yx, f_yx_nie, decimal=4)
############
# rotation 2
############
e1, e2 = 0.15, 0.13
eps = np.sqrt(e1**2 + e2**2)
phi_G, q = param_util.ellipticity2phi_q(e1, e2)
# map the nie_potential input to the spep input
gamma_spep = 2.
q_spep = np.sqrt(q)
e1_spep, e2_spep = param_util.phi_q2_ellipticity(phi_G, q_spep)
theta_E_conv = self.nie_potential._theta_q_convert(theta_E, q)
theta_E_spep = theta_E_conv * np.sqrt(1 - eps) / ((1 - eps) /
(1 + eps))**0.25
# compare the rotated output
f_xx, f_xy, f_yx, f_yy = self.nie_potential.hessian(
x, y, theta_E, theta_c, e1, e2)
f_xx_nie, f_xy_nie, f_yx_nie, f_yy_nie = self.spep.hessian(
x, y, theta_E_spep, gamma_spep, e1_spep, e2_spep)
npt.assert_almost_equal(f_xx, f_xx_nie, decimal=4)
npt.assert_almost_equal(f_yy, f_yy_nie, decimal=4)
npt.assert_almost_equal(f_xy, f_xy_nie, decimal=4)
npt.assert_almost_equal(f_yx, f_yx_nie, decimal=4)
def test_static(self):
x, y = 1., 1.
phi_G, q = 0.3, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_lens = {'theta_E': 1., 'theta_c': .1, 'e1': e1, 'e2': e2}
f_ = self.nie_potential.function(x, y, **kwargs_lens)
self.nie_potential.set_static(**kwargs_lens)
f_static = self.nie_potential.function(x, y, **kwargs_lens)
npt.assert_almost_equal(f_, f_static, decimal=8)
self.nie_potential.set_dynamic()
kwargs_lens = {'theta_E': 2., 'theta_c': .1, 'e1': e1, 'e2': e2}
f_dyn = self.nie_potential.function(x, y, **kwargs_lens)
assert f_dyn != f_static
class TestSPEP(object):
"""
tests the Gaussian methods
"""
def setup(self):
self.SPEP = SPEP()
self.SIE = SIE()
def test_function(self):
x = 1
y = 2
phi_E = 1.
gamma = 1.9
q = 0.9
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
values = self.SPEP.function(x, y, phi_E, gamma, e1, e2)
npt.assert_almost_equal(values, 2.104213947346917, decimal=7)
x = np.array([0])
y = np.array([0])
values = self.SPEP.function(x, y, phi_E, gamma, e1, e2)
assert values[0] == 0
x = np.array([2, 3, 4])
y = np.array([1, 1, 1])
values = self.SPEP.function(x, y, phi_E, gamma, e1, e2)
npt.assert_almost_equal(values[0], 2.1709510681181285, decimal=7)
npt.assert_almost_equal(values[1], 3.2293397784259108, decimal=7)
npt.assert_almost_equal(values[2], 4.3624056004556948, decimal=7)
def test_derivatives(self):
x = np.array([1])
y = np.array([2])
phi_E = 1.
gamma = 1.9
q = 0.9
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_x, f_y = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2)
npt.assert_almost_equal(f_x[0], 0.43989645846696634, decimal=7)
npt.assert_almost_equal(f_y[0], 0.93736944180732129, decimal=7)
x = np.array([0])
y = np.array([0])
f_x, f_y = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2)
assert f_x[0] == 0
assert f_y[0] == 0
x = np.array([1, 3, 4])
y = np.array([2, 1, 1])
values = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2)
npt.assert_almost_equal(values[0][0], 0.43989645846696634, decimal=7)
npt.assert_almost_equal(values[1][0], 0.93736944180732129, decimal=7)
npt.assert_almost_equal(values[0][1], 1.1029501948308649, decimal=7)
npt.assert_almost_equal(values[1][1], 0.24342317177590794, decimal=7)
x = 1
y = 2
phi_E = 1.
gamma = 1.9
q = 0.9
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_x, f_y = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2)
npt.assert_almost_equal(f_x, 0.43989645846696634, decimal=7)
npt.assert_almost_equal(f_y, 0.93736944180732129, decimal=7)
x = 0
y = 0
f_x, f_y = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2)
assert f_x == 0
assert f_y == 0
def test_hessian(self):
x = np.array([1])
y = np.array([2])
phi_E = 1.
gamma = 1.9
q = 0.9
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_xx, f_yy,f_xy = self.SPEP.hessian(x, y, phi_E, gamma, e1, e2)
npt.assert_almost_equal(f_xx[0], 0.46312881977317422, decimal=7)
npt.assert_almost_equal(f_yy[0], 0.15165326557198552, decimal=7)
npt.assert_almost_equal(f_xy[0], -0.20956958696323871, decimal=7)
x = np.array([1,3,4])
y = np.array([2,1,1])
values = self.SPEP.hessian(x, y, phi_E, gamma, e1, e2)
npt.assert_almost_equal(values[0][0], 0.46312881977317422, decimal=7)
npt.assert_almost_equal(values[1][0], 0.15165326557198552, decimal=7)
npt.assert_almost_equal(values[2][0], -0.20956958696323871, decimal=7)
npt.assert_almost_equal(values[0][1], 0.070999592014527796, decimal=7)
npt.assert_almost_equal(values[1][1], 0.33245358685908111, decimal=7)
npt.assert_almost_equal(values[2][1], -0.10270375656049677, decimal=7)
def test_spep_sie_conventions(self):
x = np.array([1., 2., 0.])
y = np.array([2, 1., 1.])
phi_E = 1.
gamma = 2
q = 0.9999
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_xx, f_yy, f_xy = self.SPEP.hessian(x, y, phi_E, gamma, e1, e2)
f_xx_sie, f_yy_sie, f_xy_sie = self.SIE.hessian(x, y, phi_E, e1, e2)
npt.assert_almost_equal(f_xx, f_xx_sie, decimal=4)
npt.assert_almost_equal(f_yy, f_yy_sie, decimal=4)
npt.assert_almost_equal(f_xy, f_xy_sie, decimal=4)
class TestSPEP(object):
"""
tests the Gaussian methods
"""
def setup(self):
self.SPEP = SPEP()
self.SPP = SPP()
self.SIS = SIS()
def test_function(self):
x = np.array([1])
y = np.array([2])
phi_E = 1.
gamma = 1.9
q = 1
phi_G = 0.
E = phi_E / (((3 - gamma) / 2.)**(1. / (1 - gamma)) * np.sqrt(q))
values_spep = self.SPEP.function(x, y, E, gamma, q, phi_G)
values_spp = self.SPP.function(x, y, E, gamma)
assert values_spep[0] == values_spp[0]
x = np.array([0])
y = np.array([0])
values_spep = self.SPEP.function(x, y, E, gamma, q, phi_G)
values_spp = self.SPP.function(x, y, E, gamma)
assert values_spep[0] == values_spp[0]
x = np.array([2, 3, 4])
y = np.array([1, 1, 1])
values_spep = self.SPEP.function(x, y, E, gamma, q, phi_G)
values_spp = self.SPP.function(x, y, E, gamma)
assert values_spep[0] == values_spp[0]
assert values_spep[1] == values_spp[1]
assert values_spep[2] == values_spp[2]
def test_derivatives(self):
x = np.array([1])
y = np.array([2])
phi_E = 1.
gamma = 1.9
q = 1
phi_G = 0.
E = phi_E / (((3 - gamma) / 2.)**(1. / (1 - gamma)) * np.sqrt(q))
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, E, gamma, q, phi_G)
f_x_spp, f_y_spp = self.SPP.derivatives(x, y, E, gamma)
assert f_x_spep[0] == f_x_spp[0]
assert f_y_spep[0] == f_y_spp[0]
x = np.array([0])
y = np.array([0])
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, E, gamma, q, phi_G)
f_x_spp, f_y_spp = self.SPP.derivatives(x, y, E, gamma)
assert f_x_spep[0] == f_x_spp[0]
assert f_y_spep[0] == f_y_spp[0]
x = np.array([1, 3, 4])
y = np.array([2, 1, 1])
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, E, gamma, q, phi_G)
f_x_spp, f_y_spp = self.SPP.derivatives(x, y, E, gamma)
assert f_x_spep[0] == f_x_spp[0]
assert f_y_spep[0] == f_y_spp[0]
assert f_x_spep[1] == f_x_spp[1]
assert f_y_spep[1] == f_y_spp[1]
assert f_x_spep[2] == f_x_spp[2]
assert f_y_spep[2] == f_y_spp[2]
def test_hessian(self):
x = np.array([1])
y = np.array([2])
phi_E = 1.
gamma = 1.9
q = 1.
phi_G = 0.
E = phi_E / (((3 - gamma) / 2.)**(1. / (1 - gamma)) * np.sqrt(q))
f_xx, f_yy, f_xy = self.SPEP.hessian(x, y, E, gamma, q, phi_G)
f_xx_spep, f_yy_spep, f_xy_spep = self.SPEP.hessian(
x, y, E, gamma, q, phi_G)
f_xx_spp, f_yy_spp, f_xy_spp = self.SPP.hessian(x, y, E, gamma)
assert f_xx_spep[0] == f_xx_spp[0]
assert f_yy_spep[0] == f_yy_spp[0]
assert f_xy_spep[0] == f_xy_spp[0]
x = np.array([1, 3, 4])
y = np.array([2, 1, 1])
f_xx_spep, f_yy_spep, f_xy_spep = self.SPEP.hessian(
x, y, E, gamma, q, phi_G)
f_xx_spp, f_yy_spp, f_xy_spp = self.SPP.hessian(x, y, E, gamma)
assert f_xx_spep[0] == f_xx_spp[0]
assert f_yy_spep[0] == f_yy_spp[0]
assert f_xy_spep[0] == f_xy_spp[0]
assert f_xx_spep[1] == f_xx_spp[1]
assert f_yy_spep[1] == f_yy_spp[1]
assert f_xy_spep[1] == f_xy_spp[1]
assert f_xx_spep[2] == f_xx_spp[2]
assert f_yy_spep[2] == f_yy_spp[2]
assert f_xy_spep[2] == f_xy_spp[2]
def test_compare_sis(self):
x = np.array([1])
y = np.array([2])
theta_E = 1.
gamma = 2.
f_sis = self.SIS.function(x, y, theta_E)
f_spp = self.SPP.function(x, y, theta_E, gamma)
f_x_sis, f_y_sis = self.SIS.derivatives(x, y, theta_E)
f_x_spp, f_y_spp = self.SPP.derivatives(x, y, theta_E, gamma)
f_xx_sis, f_yy_sis, f_xy_sis = self.SIS.hessian(x, y, theta_E)
f_xx_spp, f_yy_spp, f_xy_spp = self.SPP.hessian(x, y, theta_E, gamma)
npt.assert_almost_equal(f_sis[0], f_spp[0], decimal=7)
npt.assert_almost_equal(f_x_sis[0], f_x_spp[0], decimal=7)
npt.assert_almost_equal(f_y_sis[0], f_y_spp[0], decimal=7)
npt.assert_almost_equal(f_xx_sis[0], f_xx_spp[0], decimal=7)
npt.assert_almost_equal(f_yy_sis[0], f_yy_spp[0], decimal=7)
npt.assert_almost_equal(f_xy_sis[0], f_xy_spp[0], decimal=7)
def test_unit_conversion(self):
theta_E = 2.
gamma = 2.2
rho0 = self.SPP.theta2rho(theta_E, gamma)
theta_E_out = self.SPP.rho2theta(rho0, gamma)
assert theta_E == theta_E_out
def test_mass_2d_lens(self):
r = 1
theta_E = 1
gamma = 2
m_2d = self.SPP.mass_2d_lens(r, theta_E, gamma)
npt.assert_almost_equal(m_2d, 3.1415926535897931, decimal=8)
def test_grav_pot(self):
x, y = 1, 0
rho0 = 1
gamma = 2
grav_pot = self.SPP.grav_pot(x, y, rho0, gamma, center_x=0, center_y=0)
npt.assert_almost_equal(grav_pot, 12.566370614359172, decimal=8)