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)
def test_density_lens(self):
r = 1
kwargs = {'theta_E': 1, 'gamma': 2, 'e1': 0, 'e2': 0}
rho = self.EPL.density_lens(r, **kwargs)
from lenstronomy.LensModel.Profiles.spep import SPEP
spep = SPEP()
rho_spep = spep.density_lens(r, **kwargs)
npt.assert_almost_equal(rho, rho_spep, decimal=7)
class TestSPEMD(object):
"""
tests the Gaussian methods
"""
def setup(self):
from lenstronomy.LensModel.Profiles.pemd import PEMD
from lenstronomy.LensModel.Profiles.spep import SPEP
self.PEMD = PEMD(suppress_fastell=True)
self.SPEP = SPEP()
def test_function(self):
phi_E = 1.
gamma = 1.9
q = 0.9
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
x = np.array([1.])
y = np.array([2])
a = np.zeros_like(x)
values = self.PEMD.function(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(values[0], 2.1571106351401803, decimal=5)
else:
assert values == 0
a += values
x = np.array(1.)
y = np.array(2.)
a = np.zeros_like(x)
values = self.PEMD.function(x, y, phi_E, gamma, e1, e2)
print(x, values)
a += values
if fastell4py_bool:
npt.assert_almost_equal(values, 2.1571106351401803, decimal=5)
else:
assert values == 0
assert type(x) == type(values)
x = np.array([2, 3, 4])
y = np.array([1, 1, 1])
values = self.PEMD.function(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(values[0], 2.180188584782964, decimal=7)
npt.assert_almost_equal(values[1], 3.2097137160951874, decimal=7)
npt.assert_almost_equal(values[2], 4.3109976673748, decimal=7)
else:
npt.assert_almost_equal(values[0], 0, decimal=7)
npt.assert_almost_equal(values[1], 0, decimal=7)
npt.assert_almost_equal(values[2], 0, 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.PEMD.derivatives(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], 0.46664118422711387, decimal=7)
npt.assert_almost_equal(f_y[0], 0.9530892465981603, decimal=7)
else:
npt.assert_almost_equal(f_x[0], 0, decimal=7)
npt.assert_almost_equal(f_y[0], 0, decimal=7)
x = np.array([1., 3, 4])
y = np.array([2., 1, 1])
a = np.zeros_like(x)
values = self.PEMD.derivatives(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(values[0][0],
0.46664118422711387,
decimal=7)
npt.assert_almost_equal(values[1][0],
0.9530892465981603,
decimal=7)
npt.assert_almost_equal(values[0][1],
1.0722265330847958,
decimal=7)
npt.assert_almost_equal(values[1][1],
0.3140067377020791,
decimal=7)
else:
npt.assert_almost_equal(values[0][0], 0, decimal=7)
npt.assert_almost_equal(values[1][0], 0, decimal=7)
npt.assert_almost_equal(values[0][1], 0, decimal=7)
npt.assert_almost_equal(values[1][1], 0, decimal=7)
a += values[0]
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.PEMD.derivatives(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x, 0.46664118422711387, decimal=7)
npt.assert_almost_equal(f_y, 0.9530892465981603, decimal=7)
else:
npt.assert_almost_equal(f_x, 0, decimal=7)
npt.assert_almost_equal(f_y, 0, decimal=7)
x = 0.
y = 0.
f_x, f_y = self.PEMD.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_xy, f_yx, f_yy = self.PEMD.hessian(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_xx, 0.4179041, decimal=7)
npt.assert_almost_equal(f_yy, 0.1404714, decimal=7)
npt.assert_almost_equal(f_xy, -0.1856134, decimal=7)
else:
npt.assert_almost_equal(f_xx, 0, decimal=7)
npt.assert_almost_equal(f_yy, 0, decimal=7)
npt.assert_almost_equal(f_xy, 0, decimal=7)
npt.assert_almost_equal(f_xy, f_yx, decimal=8)
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)
a = np.zeros_like(x)
f_xx, f_xy, f_yx, f_yy = self.PEMD.hessian(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_xx, 0.41790408341142493, decimal=7)
npt.assert_almost_equal(f_yy, 0.14047143086334482, decimal=7)
npt.assert_almost_equal(f_xy, -0.1856133848300859, decimal=7)
else:
npt.assert_almost_equal(f_xx, 0, decimal=7)
npt.assert_almost_equal(f_yy, 0, decimal=7)
npt.assert_almost_equal(f_xy, 0, decimal=7)
a += f_xx
x = np.array([1, 3, 4])
y = np.array([2, 1, 1])
values = self.PEMD.hessian(x, y, phi_E, gamma, e1, e2)
print(values, 'values')
if fastell4py_bool:
npt.assert_almost_equal(values[0][0],
0.41789957732890953,
decimal=5)
npt.assert_almost_equal(values[3][0],
0.14047593655054141,
decimal=5)
npt.assert_almost_equal(values[1][0],
-0.18560737698052343,
decimal=5)
npt.assert_almost_equal(values[0][1],
0.068359818958208918,
decimal=5)
npt.assert_almost_equal(values[3][1],
0.32494089371516482,
decimal=5)
npt.assert_almost_equal(values[1][1],
-0.097845438684594374,
decimal=5)
else:
npt.assert_almost_equal(values[0][0], 0, decimal=7)
def test_spep_spemd(self):
x = np.array([1])
y = np.array([0])
phi_E = 1.
gamma = 2.
q = 1.
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_x, f_y = self.PEMD.derivatives(x, y, phi_E, gamma, e1, e2)
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2)
else:
pass
theta_E = 2.
gamma = 2.
q = 1.
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_x, f_y = self.PEMD.derivatives(x, y, theta_E, gamma, e1, e2)
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, e1,
e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2)
else:
pass
theta_E = 2.
gamma = 1.7
q = 1.
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_x, f_y = self.PEMD.derivatives(x, y, theta_E, gamma, e1, e2)
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, e1,
e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=4)
def test_bounds(self):
from lenstronomy.LensModel.Profiles.spemd import SPEMD
profile = SPEMD(suppress_fastell=True)
compute_bool = profile._parameter_constraints(q_fastell=-1,
gam=-1,
s2=-1,
q=-1)
assert compute_bool is False
def test_is_not_empty(self):
func = self.PEMD.spemd_smooth.is_not_empty
assert func(0.1, 0.2)
assert func([0.1], [0.2])
assert func((0.1, 0.3), (0.2, 0.4))
assert func(np.array([0.1]), np.array([0.2]))
assert not func([], [])
assert not func(np.array([]), np.array([]))
def test_density_lens(self):
r = 1
kwargs = {'theta_E': 1, 'gamma': 2, 'e1': 0, 'e2': 0}
rho = self.PEMD.density_lens(r, **kwargs)
rho_spep = self.SPEP.density_lens(r, **kwargs)
npt.assert_almost_equal(rho, rho_spep, decimal=7)
def __init__(self, lens_model_list, **kwargs):
"""
:param lens_model_list: list of strings with lens model names
:param foreground_shear: bool, when True, models a foreground non-linear shear distortion
"""
self.func_list = []
self._foreground_shear = False
for i, lens_type in enumerate(lens_model_list):
if lens_type == 'SHEAR':
from lenstronomy.LensModel.Profiles.external_shear import ExternalShear
self.func_list.append(ExternalShear())
elif lens_type == 'CONVERGENCE':
from lenstronomy.LensModel.Profiles.mass_sheet import MassSheet
self.func_list.append(MassSheet())
elif lens_type == 'FLEXION':
from lenstronomy.LensModel.Profiles.flexion import Flexion
self.func_list.append(Flexion())
elif lens_type == 'POINT_MASS':
from lenstronomy.LensModel.Profiles.point_mass import PointMass
self.func_list.append(PointMass())
elif lens_type == 'SIS':
from lenstronomy.LensModel.Profiles.sis import SIS
self.func_list.append(SIS())
elif lens_type == 'SIS_TRUNCATED':
from lenstronomy.LensModel.Profiles.sis_truncate import SIS_truncate
self.func_list.append(SIS_truncate())
elif lens_type == 'SIE':
from lenstronomy.LensModel.Profiles.sie import SIE
self.func_list.append(SIE())
elif lens_type == 'SPP':
from lenstronomy.LensModel.Profiles.spp import SPP
self.func_list.append(SPP())
elif lens_type == 'NIE':
from lenstronomy.LensModel.Profiles.nie import NIE
self.func_list.append(NIE())
elif lens_type == 'NIE_SIMPLE':
from lenstronomy.LensModel.Profiles.nie import NIE_simple
self.func_list.append(NIE_simple())
elif lens_type == 'CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import Chameleon
self.func_list.append(Chameleon())
elif lens_type == 'DOUBLE_CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import DoubleChameleon
self.func_list.append(DoubleChameleon())
elif lens_type == 'SPEP':
from lenstronomy.LensModel.Profiles.spep import SPEP
self.func_list.append(SPEP())
elif lens_type == 'SPEMD':
from lenstronomy.LensModel.Profiles.spemd import SPEMD
self.func_list.append(SPEMD())
elif lens_type == 'SPEMD_SMOOTH':
from lenstronomy.LensModel.Profiles.spemd_smooth import SPEMD_SMOOTH
self.func_list.append(SPEMD_SMOOTH())
elif lens_type == 'NFW':
from lenstronomy.LensModel.Profiles.nfw import NFW
self.func_list.append(NFW(**kwargs))
elif lens_type == 'NFW_ELLIPSE':
from lenstronomy.LensModel.Profiles.nfw_ellipse import NFW_ELLIPSE
self.func_list.append(
NFW_ELLIPSE(interpol=False,
num_interp_X=1000,
max_interp_X=100))
elif lens_type == 'TNFW':
from lenstronomy.LensModel.Profiles.tnfw import TNFW
self.func_list.append(TNFW())
elif lens_type == 'SERSIC':
from lenstronomy.LensModel.Profiles.sersic import Sersic
self.func_list.append(Sersic())
elif lens_type == 'SERSIC_ELLIPSE':
from lenstronomy.LensModel.Profiles.sersic_ellipse import SersicEllipse
self.func_list.append(SersicEllipse())
elif lens_type == 'PJAFFE':
from lenstronomy.LensModel.Profiles.p_jaffe import PJaffe
self.func_list.append(PJaffe())
elif lens_type == 'PJAFFE_ELLIPSE':
from lenstronomy.LensModel.Profiles.p_jaffe_ellipse import PJaffe_Ellipse
self.func_list.append(PJaffe_Ellipse())
elif lens_type == 'HERNQUIST':
from lenstronomy.LensModel.Profiles.hernquist import Hernquist
self.func_list.append(Hernquist())
elif lens_type == 'HERNQUIST_ELLIPSE':
from lenstronomy.LensModel.Profiles.hernquist_ellipse import Hernquist_Ellipse
self.func_list.append(Hernquist_Ellipse())
elif lens_type == 'GAUSSIAN':
from lenstronomy.LensModel.Profiles.gaussian_potential import Gaussian
self.func_list.append(Gaussian())
elif lens_type == 'GAUSSIAN_KAPPA':
from lenstronomy.LensModel.Profiles.gaussian_kappa import GaussianKappa
self.func_list.append(GaussianKappa())
elif lens_type == 'GAUSSIAN_KAPPA_ELLIPSE':
from lenstronomy.LensModel.Profiles.gaussian_kappa_ellipse import GaussianKappaEllipse
self.func_list.append(GaussianKappaEllipse())
elif lens_type == 'MULTI_GAUSSIAN_KAPPA':
from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa
self.func_list.append(MultiGaussianKappa())
elif lens_type == 'MULTI_GAUSSIAN_KAPPA_ELLIPSE':
from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappaEllipse
self.func_list.append(MultiGaussianKappaEllipse())
elif lens_type == 'INTERPOL':
from lenstronomy.LensModel.Profiles.interpol import Interpol_func
self.func_list.append(
Interpol_func(grid=False, min_grid_number=100))
elif lens_type == 'INTERPOL_SCALED':
from lenstronomy.LensModel.Profiles.interpol import Interpol_func_scaled
self.func_list.append(
Interpol_func_scaled(grid=False, min_grid_number=100))
elif lens_type == 'SHAPELETS_POLAR':
from lenstronomy.LensModel.Profiles.shapelet_pot_polar import PolarShapelets
self.func_list.append(PolarShapelets())
elif lens_type == 'SHAPELETS_CART':
from lenstronomy.LensModel.Profiles.shapelet_pot_cartesian import CartShapelets
self.func_list.append(CartShapelets())
elif lens_type == 'DIPOLE':
from lenstronomy.LensModel.Profiles.dipole import Dipole
self.func_list.append(Dipole())
elif lens_type == 'FOREGROUND_SHEAR':
from lenstronomy.LensModel.Profiles.external_shear import ExternalShear
self.func_list.append(ExternalShear())
self._foreground_shear = True
self._foreground_shear_idex = i
else:
raise ValueError('%s is not a valid lens model' % lens_type)
self._model_list = lens_model_list
def setup(self):
self.nie_potential = NIE_POTENTIAL()
self.spep = SPEP()
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
def setup(self):
self.SPEP = SPEP()
self.SIE = SIE()
def setup(self):
self.SPEP = SPEP()
def _import_class(self, lens_type, i, custom_class):
if lens_type == 'SHIFT':
from lenstronomy.LensModel.Profiles.alpha_shift import Shift
return Shift()
elif lens_type == 'SHEAR':
from lenstronomy.LensModel.Profiles.shear import Shear
return Shear()
elif lens_type == 'CONVERGENCE':
from lenstronomy.LensModel.Profiles.convergence import Convergence
return Convergence()
elif lens_type == 'FLEXION':
from lenstronomy.LensModel.Profiles.flexion import Flexion
return Flexion()
elif lens_type == 'POINT_MASS':
from lenstronomy.LensModel.Profiles.point_mass import PointMass
return PointMass()
elif lens_type == 'SIS':
from lenstronomy.LensModel.Profiles.sis import SIS
return SIS()
elif lens_type == 'SIS_TRUNCATED':
from lenstronomy.LensModel.Profiles.sis_truncate import SIS_truncate
return SIS_truncate()
elif lens_type == 'SIE':
from lenstronomy.LensModel.Profiles.sie import SIE
return SIE()
elif lens_type == 'SPP':
from lenstronomy.LensModel.Profiles.spp import SPP
return SPP()
elif lens_type == 'NIE':
from lenstronomy.LensModel.Profiles.nie import NIE
return NIE()
elif lens_type == 'NIE_SIMPLE':
from lenstronomy.LensModel.Profiles.nie import NIE_simple
return NIE_simple()
elif lens_type == 'CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import Chameleon
return Chameleon()
elif lens_type == 'DOUBLE_CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import DoubleChameleon
return DoubleChameleon()
elif lens_type == 'SPEP':
from lenstronomy.LensModel.Profiles.spep import SPEP
return SPEP()
elif lens_type == 'SPEMD':
from lenstronomy.LensModel.Profiles.spemd import SPEMD
return SPEMD()
elif lens_type == 'SPEMD_SMOOTH':
from lenstronomy.LensModel.Profiles.spemd_smooth import SPEMD_SMOOTH
return SPEMD_SMOOTH()
elif lens_type == 'NFW':
from lenstronomy.LensModel.Profiles.nfw import NFW
return NFW()
elif lens_type == 'NFW_ELLIPSE':
from lenstronomy.LensModel.Profiles.nfw_ellipse import NFW_ELLIPSE
return NFW_ELLIPSE()
elif lens_type == 'TNFW':
from lenstronomy.LensModel.Profiles.tnfw import TNFW
return TNFW()
elif lens_type == 'CNFW':
from lenstronomy.LensModel.Profiles.cnfw import CNFW
return CNFW()
elif lens_type == 'SERSIC':
from lenstronomy.LensModel.Profiles.sersic import Sersic
return Sersic()
elif lens_type == 'SERSIC_ELLIPSE':
from lenstronomy.LensModel.Profiles.sersic_ellipse import SersicEllipse
return SersicEllipse()
elif lens_type == 'PJAFFE':
from lenstronomy.LensModel.Profiles.p_jaffe import PJaffe
return PJaffe()
elif lens_type == 'PJAFFE_ELLIPSE':
from lenstronomy.LensModel.Profiles.p_jaffe_ellipse import PJaffe_Ellipse
return PJaffe_Ellipse()
elif lens_type == 'HERNQUIST':
from lenstronomy.LensModel.Profiles.hernquist import Hernquist
return Hernquist()
elif lens_type == 'HERNQUIST_ELLIPSE':
from lenstronomy.LensModel.Profiles.hernquist_ellipse import Hernquist_Ellipse
return Hernquist_Ellipse()
elif lens_type == 'GAUSSIAN':
from lenstronomy.LensModel.Profiles.gaussian_potential import Gaussian
return Gaussian()
elif lens_type == 'GAUSSIAN_KAPPA':
from lenstronomy.LensModel.Profiles.gaussian_kappa import GaussianKappa
return GaussianKappa()
elif lens_type == 'GAUSSIAN_KAPPA_ELLIPSE':
from lenstronomy.LensModel.Profiles.gaussian_kappa_ellipse import GaussianKappaEllipse
return GaussianKappaEllipse()
elif lens_type == 'MULTI_GAUSSIAN_KAPPA':
from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa
return MultiGaussianKappa()
elif lens_type == 'MULTI_GAUSSIAN_KAPPA_ELLIPSE':
from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappaEllipse
return MultiGaussianKappaEllipse()
elif lens_type == 'INTERPOL':
from lenstronomy.LensModel.Profiles.interpol import Interpol
return Interpol(grid=False, min_grid_number=100)
elif lens_type == 'INTERPOL_SCALED':
from lenstronomy.LensModel.Profiles.interpol import InterpolScaled
return InterpolScaled()
elif lens_type == 'SHAPELETS_POLAR':
from lenstronomy.LensModel.Profiles.shapelet_pot_polar import PolarShapelets
return PolarShapelets()
elif lens_type == 'SHAPELETS_CART':
from lenstronomy.LensModel.Profiles.shapelet_pot_cartesian import CartShapelets
return CartShapelets()
elif lens_type == 'DIPOLE':
from lenstronomy.LensModel.Profiles.dipole import Dipole
return Dipole()
elif lens_type == 'FOREGROUND_SHEAR':
from lenstronomy.LensModel.Profiles.shear import Shear
self._foreground_shear = True
self._foreground_shear_idex = i
return Shear()
elif lens_type == 'coreBURKERT':
from lenstronomy.LensModel.Profiles.coreBurkert import coreBurkert
return coreBurkert()
elif lens_type == 'NumericalAlpha':
from lenstronomy.LensModel.Profiles.numerical_deflections import NumericalAlpha
return NumericalAlpha(custom_class[i])
else:
raise ValueError('%s is not a valid lens model' % lens_type)
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)
def setup(self):
self.SPEP = SPEP()
self.SPP = SPP()
self.SIS = SIS()
def _import_class(lens_type,
custom_class,
kwargs_interp,
z_lens=None,
z_source=None):
"""
:param lens_type: string, lens model type
:param custom_class: custom class
:param z_lens: lens redshift # currently only used in NFW_MC model as this is redshift dependent
:param z_source: source redshift # currently only used in NFW_MC model as this is redshift dependent
:param kwargs_interp: interpolation keyword arguments specifying the numerics.
See description in the Interpolate() class. Only applicable for 'INTERPOL' and 'INTERPOL_SCALED' models.
:return: class instance of the lens model type
"""
if lens_type == 'SHIFT':
from lenstronomy.LensModel.Profiles.constant_shift import Shift
return Shift()
elif lens_type == 'NIE_POTENTIAL':
from lenstronomy.LensModel.Profiles.nie_potential import NIE_POTENTIAL
return NIE_POTENTIAL()
elif lens_type == 'CONST_MAG':
from lenstronomy.LensModel.Profiles.const_mag import ConstMag
return ConstMag()
elif lens_type == 'SHEAR':
from lenstronomy.LensModel.Profiles.shear import Shear
return Shear()
elif lens_type == 'SHEAR_GAMMA_PSI':
from lenstronomy.LensModel.Profiles.shear import ShearGammaPsi
return ShearGammaPsi()
elif lens_type == 'SHEAR_REDUCED':
from lenstronomy.LensModel.Profiles.shear import ShearReduced
return ShearReduced()
elif lens_type == 'CONVERGENCE':
from lenstronomy.LensModel.Profiles.convergence import Convergence
return Convergence()
elif lens_type == 'HESSIAN':
from lenstronomy.LensModel.Profiles.hessian import Hessian
return Hessian()
elif lens_type == 'FLEXION':
from lenstronomy.LensModel.Profiles.flexion import Flexion
return Flexion()
elif lens_type == 'FLEXIONFG':
from lenstronomy.LensModel.Profiles.flexionfg import Flexionfg
return Flexionfg()
elif lens_type == 'POINT_MASS':
from lenstronomy.LensModel.Profiles.point_mass import PointMass
return PointMass()
elif lens_type == 'SIS':
from lenstronomy.LensModel.Profiles.sis import SIS
return SIS()
elif lens_type == 'SIS_TRUNCATED':
from lenstronomy.LensModel.Profiles.sis_truncate import SIS_truncate
return SIS_truncate()
elif lens_type == 'SIE':
from lenstronomy.LensModel.Profiles.sie import SIE
return SIE()
elif lens_type == 'SPP':
from lenstronomy.LensModel.Profiles.spp import SPP
return SPP()
elif lens_type == 'NIE':
from lenstronomy.LensModel.Profiles.nie import NIE
return NIE()
elif lens_type == 'NIE_SIMPLE':
from lenstronomy.LensModel.Profiles.nie import NIEMajorAxis
return NIEMajorAxis()
elif lens_type == 'CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import Chameleon
return Chameleon()
elif lens_type == 'DOUBLE_CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import DoubleChameleon
return DoubleChameleon()
elif lens_type == 'TRIPLE_CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import TripleChameleon
return TripleChameleon()
elif lens_type == 'SPEP':
from lenstronomy.LensModel.Profiles.spep import SPEP
return SPEP()
elif lens_type == 'PEMD':
from lenstronomy.LensModel.Profiles.pemd import PEMD
return PEMD()
elif lens_type == 'SPEMD':
from lenstronomy.LensModel.Profiles.spemd import SPEMD
return SPEMD()
elif lens_type == 'EPL':
from lenstronomy.LensModel.Profiles.epl import EPL
return EPL()
elif lens_type == 'EPL_NUMBA':
from lenstronomy.LensModel.Profiles.epl_numba import EPL_numba
return EPL_numba()
elif lens_type == 'SPL_CORE':
from lenstronomy.LensModel.Profiles.splcore import SPLCORE
return SPLCORE()
elif lens_type == 'NFW':
from lenstronomy.LensModel.Profiles.nfw import NFW
return NFW()
elif lens_type == 'NFW_ELLIPSE':
from lenstronomy.LensModel.Profiles.nfw_ellipse import NFW_ELLIPSE
return NFW_ELLIPSE()
elif lens_type == 'NFW_ELLIPSE_GAUSS_DEC':
from lenstronomy.LensModel.Profiles.gauss_decomposition import NFWEllipseGaussDec
return NFWEllipseGaussDec()
elif lens_type == 'NFW_ELLIPSE_CSE':
from lenstronomy.LensModel.Profiles.nfw_ellipse_cse import NFW_ELLIPSE_CSE
return NFW_ELLIPSE_CSE()
elif lens_type == 'TNFW':
from lenstronomy.LensModel.Profiles.tnfw import TNFW
return TNFW()
elif lens_type == 'TNFW_ELLIPSE':
from lenstronomy.LensModel.Profiles.tnfw_ellipse import TNFW_ELLIPSE
return TNFW_ELLIPSE()
elif lens_type == 'CNFW':
from lenstronomy.LensModel.Profiles.cnfw import CNFW
return CNFW()
elif lens_type == 'CNFW_ELLIPSE':
from lenstronomy.LensModel.Profiles.cnfw_ellipse import CNFW_ELLIPSE
return CNFW_ELLIPSE()
elif lens_type == 'CTNFW_GAUSS_DEC':
from lenstronomy.LensModel.Profiles.gauss_decomposition import CTNFWGaussDec
return CTNFWGaussDec()
elif lens_type == 'NFW_MC':
from lenstronomy.LensModel.Profiles.nfw_mass_concentration import NFWMC
return NFWMC(z_lens=z_lens, z_source=z_source)
elif lens_type == 'SERSIC':
from lenstronomy.LensModel.Profiles.sersic import Sersic
return Sersic()
elif lens_type == 'SERSIC_ELLIPSE_POTENTIAL':
from lenstronomy.LensModel.Profiles.sersic_ellipse_potential import SersicEllipse
return SersicEllipse()
elif lens_type == 'SERSIC_ELLIPSE_KAPPA':
from lenstronomy.LensModel.Profiles.sersic_ellipse_kappa import SersicEllipseKappa
return SersicEllipseKappa()
elif lens_type == 'SERSIC_ELLIPSE_GAUSS_DEC':
from lenstronomy.LensModel.Profiles.gauss_decomposition import SersicEllipseGaussDec
return SersicEllipseGaussDec()
elif lens_type == 'PJAFFE':
from lenstronomy.LensModel.Profiles.p_jaffe import PJaffe
return PJaffe()
elif lens_type == 'PJAFFE_ELLIPSE':
from lenstronomy.LensModel.Profiles.p_jaffe_ellipse import PJaffe_Ellipse
return PJaffe_Ellipse()
elif lens_type == 'HERNQUIST':
from lenstronomy.LensModel.Profiles.hernquist import Hernquist
return Hernquist()
elif lens_type == 'HERNQUIST_ELLIPSE':
from lenstronomy.LensModel.Profiles.hernquist_ellipse import Hernquist_Ellipse
return Hernquist_Ellipse()
elif lens_type == 'HERNQUIST_ELLIPSE_CSE':
from lenstronomy.LensModel.Profiles.hernquist_ellipse_cse import HernquistEllipseCSE
return HernquistEllipseCSE()
elif lens_type == 'GAUSSIAN':
from lenstronomy.LensModel.Profiles.gaussian_potential import Gaussian
return Gaussian()
elif lens_type == 'GAUSSIAN_KAPPA':
from lenstronomy.LensModel.Profiles.gaussian_kappa import GaussianKappa
return GaussianKappa()
elif lens_type == 'GAUSSIAN_ELLIPSE_KAPPA':
from lenstronomy.LensModel.Profiles.gaussian_ellipse_kappa import GaussianEllipseKappa
return GaussianEllipseKappa()
elif lens_type == 'GAUSSIAN_ELLIPSE_POTENTIAL':
from lenstronomy.LensModel.Profiles.gaussian_ellipse_potential import GaussianEllipsePotential
return GaussianEllipsePotential()
elif lens_type == 'MULTI_GAUSSIAN_KAPPA':
from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa
return MultiGaussianKappa()
elif lens_type == 'MULTI_GAUSSIAN_KAPPA_ELLIPSE':
from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappaEllipse
return MultiGaussianKappaEllipse()
elif lens_type == 'INTERPOL':
from lenstronomy.LensModel.Profiles.interpol import Interpol
return Interpol(**kwargs_interp)
elif lens_type == 'INTERPOL_SCALED':
from lenstronomy.LensModel.Profiles.interpol import InterpolScaled
return InterpolScaled(**kwargs_interp)
elif lens_type == 'SHAPELETS_POLAR':
from lenstronomy.LensModel.Profiles.shapelet_pot_polar import PolarShapelets
return PolarShapelets()
elif lens_type == 'SHAPELETS_CART':
from lenstronomy.LensModel.Profiles.shapelet_pot_cartesian import CartShapelets
return CartShapelets()
elif lens_type == 'DIPOLE':
from lenstronomy.LensModel.Profiles.dipole import Dipole
return Dipole()
elif lens_type == 'CURVED_ARC_CONST':
from lenstronomy.LensModel.Profiles.curved_arc_const import CurvedArcConst
return CurvedArcConst()
elif lens_type == 'CURVED_ARC_CONST_MST':
from lenstronomy.LensModel.Profiles.curved_arc_const import CurvedArcConstMST
return CurvedArcConstMST()
elif lens_type == 'CURVED_ARC_SPP':
from lenstronomy.LensModel.Profiles.curved_arc_spp import CurvedArcSPP
return CurvedArcSPP()
elif lens_type == 'CURVED_ARC_SIS_MST':
from lenstronomy.LensModel.Profiles.curved_arc_sis_mst import CurvedArcSISMST
return CurvedArcSISMST()
elif lens_type == 'CURVED_ARC_SPT':
from lenstronomy.LensModel.Profiles.curved_arc_spt import CurvedArcSPT
return CurvedArcSPT()
elif lens_type == 'CURVED_ARC_TAN_DIFF':
from lenstronomy.LensModel.Profiles.curved_arc_tan_diff import CurvedArcTanDiff
return CurvedArcTanDiff()
elif lens_type == 'ARC_PERT':
from lenstronomy.LensModel.Profiles.arc_perturbations import ArcPerturbations
return ArcPerturbations()
elif lens_type == 'coreBURKERT':
from lenstronomy.LensModel.Profiles.coreBurkert import CoreBurkert
return CoreBurkert()
elif lens_type == 'CORED_DENSITY':
from lenstronomy.LensModel.Profiles.cored_density import CoredDensity
return CoredDensity()
elif lens_type == 'CORED_DENSITY_2':
from lenstronomy.LensModel.Profiles.cored_density_2 import CoredDensity2
return CoredDensity2()
elif lens_type == 'CORED_DENSITY_EXP':
from lenstronomy.LensModel.Profiles.cored_density_exp import CoredDensityExp
return CoredDensityExp()
elif lens_type == 'CORED_DENSITY_MST':
from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST
return CoredDensityMST(profile_type='CORED_DENSITY')
elif lens_type == 'CORED_DENSITY_2_MST':
from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST
return CoredDensityMST(profile_type='CORED_DENSITY_2')
elif lens_type == 'CORED_DENSITY_EXP_MST':
from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST
return CoredDensityMST(profile_type='CORED_DENSITY_EXP')
elif lens_type == 'NumericalAlpha':
from lenstronomy.LensModel.Profiles.numerical_deflections import NumericalAlpha
return NumericalAlpha(custom_class)
elif lens_type == 'MULTIPOLE':
from lenstronomy.LensModel.Profiles.multipole import Multipole
return Multipole()
elif lens_type == 'CSE':
from lenstronomy.LensModel.Profiles.cored_steep_ellipsoid import CSE
return CSE()
elif lens_type == 'ElliSLICE':
from lenstronomy.LensModel.Profiles.elliptical_density_slice import ElliSLICE
return ElliSLICE()
elif lens_type == 'ULDM':
from lenstronomy.LensModel.Profiles.uldm import Uldm
return Uldm()
elif lens_type == 'CORED_DENSITY_ULDM_MST':
from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST
return CoredDensityMST(profile_type='CORED_DENSITY_ULDM')
else:
raise ValueError(
'%s is not a valid lens model. Supported are: %s.' %
(lens_type, _SUPPORTED_MODELS))
def setup(self):
from lenstronomy.LensModel.Profiles.spemd import SPEMD
from lenstronomy.LensModel.Profiles.spep import SPEP
self.SPEMD = SPEMD()
self.SPEP = SPEP()
class TestSPEMD(object):
"""
tests the Gaussian methods
"""
def setup(self):
from lenstronomy.LensModel.Profiles.spemd import SPEMD
from lenstronomy.LensModel.Profiles.spep import SPEP
self.SPEMD = SPEMD()
self.SPEP = SPEP()
def test_function(self):
phi_E = 1.
gamma = 1.9
q = 0.9
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
x = np.array([1.])
y = np.array([2])
a = np.zeros_like(x)
values = self.SPEMD.function(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
assert values == 2.1567297115381039
else:
assert values == 0
a += values
x = np.array(1.)
y = np.array(2.)
a = np.zeros_like(x)
values = self.SPEMD.function(x, y, phi_E, gamma, e1, e2)
print(x, values)
a += values
if fastell4py_bool:
assert values == 2.1567297115381039
else:
assert values == 0
assert type(x) == type(values)
x = np.array([2, 3, 4])
y = np.array([1, 1, 1])
values = self.SPEMD.function(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(values[0], 2.1798076611034141, decimal=7)
npt.assert_almost_equal(values[1], 3.209319798597186, decimal=7)
npt.assert_almost_equal(values[2], 4.3105937398856398, decimal=7)
else:
npt.assert_almost_equal(values[0], 0, decimal=7)
npt.assert_almost_equal(values[1], 0, decimal=7)
npt.assert_almost_equal(values[2], 0, 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.SPEMD.derivatives(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], 0.46663367437984204, decimal=7)
npt.assert_almost_equal(f_y[0], 0.95307422686028065, decimal=7)
else:
npt.assert_almost_equal(f_x[0], 0, decimal=7)
npt.assert_almost_equal(f_y[0], 0, decimal=7)
x = np.array([1., 3, 4])
y = np.array([2., 1, 1])
a = np.zeros_like(x)
values = self.SPEMD.derivatives(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(values[0][0],
0.46663367437984204,
decimal=7)
npt.assert_almost_equal(values[1][0],
0.95307422686028065,
decimal=7)
npt.assert_almost_equal(values[0][1],
1.0722152681324291,
decimal=7)
npt.assert_almost_equal(values[1][1],
0.31400298272329669,
decimal=7)
else:
npt.assert_almost_equal(values[0][0], 0, decimal=7)
npt.assert_almost_equal(values[1][0], 0, decimal=7)
npt.assert_almost_equal(values[0][1], 0, decimal=7)
npt.assert_almost_equal(values[1][1], 0, decimal=7)
a += values[0]
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.SPEMD.derivatives(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x, 0.46663367437984204, decimal=7)
npt.assert_almost_equal(f_y, 0.95307422686028065, decimal=7)
else:
npt.assert_almost_equal(f_x, 0, decimal=7)
npt.assert_almost_equal(f_y, 0, decimal=7)
x = 0.
y = 0.
f_x, f_y = self.SPEMD.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.SPEMD.hessian(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_xx, 0.41789957732890953, decimal=7)
npt.assert_almost_equal(f_yy, 0.14047593655054141, decimal=7)
npt.assert_almost_equal(f_xy, -0.18560737698052343, decimal=7)
else:
npt.assert_almost_equal(f_xx, 0, decimal=7)
npt.assert_almost_equal(f_yy, 0, decimal=7)
npt.assert_almost_equal(f_xy, 0, 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)
a = np.zeros_like(x)
f_xx, f_yy, f_xy = self.SPEMD.hessian(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_xx, 0.41789957732890953, decimal=7)
npt.assert_almost_equal(f_yy, 0.14047593655054141, decimal=7)
npt.assert_almost_equal(f_xy, -0.18560737698052343, decimal=7)
else:
npt.assert_almost_equal(f_xx, 0, decimal=7)
npt.assert_almost_equal(f_yy, 0, decimal=7)
npt.assert_almost_equal(f_xy, 0, decimal=7)
a += f_xx
x = np.array([1, 3, 4])
y = np.array([2, 1, 1])
values = self.SPEMD.hessian(x, y, phi_E, gamma, e1, e2)
print(values, 'values')
if fastell4py_bool:
npt.assert_almost_equal(values[0][0],
0.41789957732890953,
decimal=7)
npt.assert_almost_equal(values[1][0],
0.14047593655054141,
decimal=7)
npt.assert_almost_equal(values[2][0],
-0.18560737698052343,
decimal=7)
npt.assert_almost_equal(values[0][1],
0.068359818958208918,
decimal=7)
npt.assert_almost_equal(values[1][1],
0.32494089371516482,
decimal=7)
npt.assert_almost_equal(values[2][1],
-0.097845438684594374,
decimal=7)
else:
npt.assert_almost_equal(values[0][0], 0, decimal=7)
def test_spep_spemd(self):
x = np.array([1])
y = np.array([0])
phi_E = 1.
gamma = 2.
q = 1.
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, e1, e2)
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, phi_E, gamma, e1, e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2)
else:
pass
theta_E = 2.
gamma = 2.
q = 1.
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_x, f_y = self.SPEMD.derivatives(x, y, theta_E, gamma, e1, e2)
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, e1,
e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2)
else:
pass
theta_E = 2.
gamma = 1.7
q = 1.
phi_G = 1.
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
f_x, f_y = self.SPEMD.derivatives(x, y, theta_E, gamma, e1, e2)
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, e1,
e2)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=4)
def test_bounds(self):
from lenstronomy.LensModel.Profiles.spemd_smooth import SPEMD_SMOOTH
profile = SPEMD_SMOOTH()
theta_E, gamma, q, phi_G, s_scale = profile._parameter_constraints(
theta_E=-1, s_scale=0, gamma=3, q=2, phi_G=0)
assert theta_E == 0
def test_is_not_empty(self):
func = self.SPEMD.spemd_smooth.is_not_empty
assert func(0.1, 0.2)
assert func([0.1], [0.2])
assert func((0.1, 0.3), (0.2, 0.4))
assert func(np.array([0.1]), np.array([0.2]))
assert not func([], [])
assert not func(np.array([]), np.array([]))
def test_density_lens(self):
r = 1
kwargs = {'theta_E': 1, 'gamma': 2, 'e1': 0, 'e2': 0}
rho = self.SPEMD.density_lens(r, **kwargs)
rho_spep = self.SPEP.density_lens(r, **kwargs)
npt.assert_almost_equal(rho, rho_spep, decimal=7)
def setup(self):
from lenstronomy.LensModel.Profiles.pemd import PEMD
from lenstronomy.LensModel.Profiles.spep import SPEP
self.PEMD = PEMD(suppress_fastell=True)
self.SPEP = SPEP()
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)
def _import_class(lens_type, custom_class, z_lens=None, z_source=None):
"""
:param lens_type: string, lens model type
:param custom_class: custom class
:param z_lens: lens redshift # currently only used in NFW_MC model as this is redshift dependent
:param z_source: source redshift # currently only used in NFW_MC model as this is redshift dependent
:return: class instance of the lens model type
"""
if lens_type == 'SHIFT':
from lenstronomy.LensModel.Profiles.alpha_shift import Shift
return Shift()
elif lens_type == 'SHEAR':
from lenstronomy.LensModel.Profiles.shear import Shear
return Shear()
elif lens_type == 'SHEAR_GAMMA_PSI':
from lenstronomy.LensModel.Profiles.shear import ShearGammaPsi
return ShearGammaPsi()
elif lens_type == 'CONVERGENCE':
from lenstronomy.LensModel.Profiles.convergence import Convergence
return Convergence()
elif lens_type == 'FLEXION':
from lenstronomy.LensModel.Profiles.flexion import Flexion
return Flexion()
elif lens_type == 'FLEXIONFG':
from lenstronomy.LensModel.Profiles.flexionfg import Flexionfg
return Flexionfg()
elif lens_type == 'POINT_MASS':
from lenstronomy.LensModel.Profiles.point_mass import PointMass
return PointMass()
elif lens_type == 'SIS':
from lenstronomy.LensModel.Profiles.sis import SIS
return SIS()
elif lens_type == 'SIS_TRUNCATED':
from lenstronomy.LensModel.Profiles.sis_truncate import SIS_truncate
return SIS_truncate()
elif lens_type == 'SIE':
from lenstronomy.LensModel.Profiles.sie import SIE
return SIE()
elif lens_type == 'SPP':
from lenstronomy.LensModel.Profiles.spp import SPP
return SPP()
elif lens_type == 'NIE':
from lenstronomy.LensModel.Profiles.nie import NIE
return NIE()
elif lens_type == 'NIE_SIMPLE':
from lenstronomy.LensModel.Profiles.nie import NIEMajorAxis
return NIEMajorAxis()
elif lens_type == 'CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import Chameleon
return Chameleon()
elif lens_type == 'DOUBLE_CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import DoubleChameleon
return DoubleChameleon()
elif lens_type == 'TRIPLE_CHAMELEON':
from lenstronomy.LensModel.Profiles.chameleon import TripleChameleon
return TripleChameleon()
elif lens_type == 'SPEP':
from lenstronomy.LensModel.Profiles.spep import SPEP
return SPEP()
elif lens_type == 'SPEMD':
from lenstronomy.LensModel.Profiles.spemd import SPEMD
return SPEMD()
elif lens_type == 'SPEMD_SMOOTH':
from lenstronomy.LensModel.Profiles.spemd_smooth import SPEMD_SMOOTH
return SPEMD_SMOOTH()
elif lens_type == 'NFW':
from lenstronomy.LensModel.Profiles.nfw import NFW
return NFW()
elif lens_type == 'NFW_ELLIPSE':
from lenstronomy.LensModel.Profiles.nfw_ellipse import NFW_ELLIPSE
return NFW_ELLIPSE()
elif lens_type == 'NFW_ELLIPSE_GAUSS_DEC':
from lenstronomy.LensModel.Profiles.gauss_decomposition import NFWEllipseGaussDec
return NFWEllipseGaussDec()
elif lens_type == 'TNFW':
from lenstronomy.LensModel.Profiles.tnfw import TNFW
return TNFW()
elif lens_type == 'CNFW':
from lenstronomy.LensModel.Profiles.cnfw import CNFW
return CNFW()
elif lens_type == 'CNFW_ELLIPSE':
from lenstronomy.LensModel.Profiles.cnfw_ellipse import CNFW_ELLIPSE
return CNFW_ELLIPSE()
elif lens_type == 'CTNFW_GAUSS_DEC':
from lenstronomy.LensModel.Profiles.gauss_decomposition import CTNFWGaussDec
return CTNFWGaussDec()
elif lens_type == 'NFW_MC':
from lenstronomy.LensModel.Profiles.nfw_mass_concentration import NFWMC
return NFWMC(z_lens=z_lens, z_source=z_source)
elif lens_type == 'SERSIC':
from lenstronomy.LensModel.Profiles.sersic import Sersic
return Sersic()
elif lens_type == 'SERSIC_ELLIPSE_POTENTIAL':
from lenstronomy.LensModel.Profiles.sersic_ellipse_potential import SersicEllipse
return SersicEllipse()
elif lens_type == 'SERSIC_ELLIPSE_KAPPA':
from lenstronomy.LensModel.Profiles.sersic_ellipse_kappa import SersicEllipseKappa
return SersicEllipseKappa()
elif lens_type == 'SERSIC_ELLIPSE_GAUSS_DEC':
from lenstronomy.LensModel.Profiles.gauss_decomposition \
import SersicEllipseGaussDec
return SersicEllipseGaussDec()
elif lens_type == 'PJAFFE':
from lenstronomy.LensModel.Profiles.p_jaffe import PJaffe
return PJaffe()
elif lens_type == 'PJAFFE_ELLIPSE':
from lenstronomy.LensModel.Profiles.p_jaffe_ellipse import PJaffe_Ellipse
return PJaffe_Ellipse()
elif lens_type == 'HERNQUIST':
from lenstronomy.LensModel.Profiles.hernquist import Hernquist
return Hernquist()
elif lens_type == 'HERNQUIST_ELLIPSE':
from lenstronomy.LensModel.Profiles.hernquist_ellipse import Hernquist_Ellipse
return Hernquist_Ellipse()
elif lens_type == 'GAUSSIAN':
from lenstronomy.LensModel.Profiles.gaussian_potential import Gaussian
return Gaussian()
elif lens_type == 'GAUSSIAN_KAPPA':
from lenstronomy.LensModel.Profiles.gaussian_kappa import GaussianKappa
return GaussianKappa()
elif lens_type == 'GAUSSIAN_ELLIPSE_KAPPA':
from lenstronomy.LensModel.Profiles.gaussian_ellipse_kappa import GaussianEllipseKappa
return GaussianEllipseKappa()
elif lens_type == 'GAUSSIAN_ELLIPSE_POTENTIAL':
from lenstronomy.LensModel.Profiles.gaussian_ellipse_potential import GaussianEllipsePotential
return GaussianEllipsePotential()
elif lens_type == 'MULTI_GAUSSIAN_KAPPA':
from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappa
return MultiGaussianKappa()
elif lens_type == 'MULTI_GAUSSIAN_KAPPA_ELLIPSE':
from lenstronomy.LensModel.Profiles.multi_gaussian_kappa import MultiGaussianKappaEllipse
return MultiGaussianKappaEllipse()
elif lens_type == 'INTERPOL':
from lenstronomy.LensModel.Profiles.interpol import Interpol
return Interpol()
elif lens_type == 'INTERPOL_SCALED':
from lenstronomy.LensModel.Profiles.interpol import InterpolScaled
return InterpolScaled()
elif lens_type == 'SHAPELETS_POLAR':
from lenstronomy.LensModel.Profiles.shapelet_pot_polar import PolarShapelets
return PolarShapelets()
elif lens_type == 'SHAPELETS_CART':
from lenstronomy.LensModel.Profiles.shapelet_pot_cartesian import CartShapelets
return CartShapelets()
elif lens_type == 'DIPOLE':
from lenstronomy.LensModel.Profiles.dipole import Dipole
return Dipole()
elif lens_type == 'CURVED_ARC':
from lenstronomy.LensModel.Profiles.curved_arc import CurvedArc
return CurvedArc()
elif lens_type == 'ARC_PERT':
from lenstronomy.LensModel.Profiles.arc_perturbations import ArcPerturbations
return ArcPerturbations()
elif lens_type == 'coreBURKERT':
from lenstronomy.LensModel.Profiles.coreBurkert import CoreBurkert
return CoreBurkert()
elif lens_type == 'CORED_DENSITY':
from lenstronomy.LensModel.Profiles.cored_density import CoredDensity
return CoredDensity()
elif lens_type == 'CORED_DENSITY_2':
from lenstronomy.LensModel.Profiles.cored_density_2 import CoredDensity2
return CoredDensity2()
elif lens_type == 'CORED_DENSITY_MST':
from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST
return CoredDensityMST(profile_type='CORED_DENSITY')
elif lens_type == 'CORED_DENSITY_2_MST':
from lenstronomy.LensModel.Profiles.cored_density_mst import CoredDensityMST
return CoredDensityMST(profile_type='CORED_DENSITY_2')
elif lens_type == 'NumericalAlpha':
from lenstronomy.LensModel.Profiles.numerical_deflections import NumericalAlpha
return NumericalAlpha(custom_class)
else:
raise ValueError('%s is not a valid lens model' % lens_type)
class TestSPEMD(object):
"""
tests the Gaussian methods
"""
def setup(self):
from lenstronomy.LensModel.Profiles.spemd import SPEMD
from lenstronomy.LensModel.Profiles.spep import SPEP
self.SPEMD = SPEMD()
self.SPEP = SPEP()
def test_function(self):
phi_E = 1.
gamma = 1.9
q = 0.9
phi_G = 1.
x = np.array([1.])
y = np.array([2])
a = np.zeros_like(x)
values = self.SPEMD.function(x, y, phi_E, gamma, q, phi_G)
if fastell4py_bool:
assert values == 2.1567297115381039
else:
assert values == 0
a += values
x = np.array(1.)
y = np.array(2.)
a = np.zeros_like(x)
values = self.SPEMD.function(x, y, phi_E, gamma, q, phi_G)
print(x, values)
a += values
if fastell4py_bool:
assert values == 2.1567297115381039
else:
assert values == 0
assert type(x) == type(values)
x = np.array([2, 3, 4])
y = np.array([1, 1, 1])
values = self.SPEMD.function(x, y, phi_E, gamma, q, phi_G)
if fastell4py_bool:
npt.assert_almost_equal(values[0], 2.1798076611034141, decimal=7)
npt.assert_almost_equal(values[1], 3.209319798597186, decimal=7)
npt.assert_almost_equal(values[2], 4.3105937398856398, decimal=7)
else:
npt.assert_almost_equal(values[0], 0, decimal=7)
npt.assert_almost_equal(values[1], 0, decimal=7)
npt.assert_almost_equal(values[2], 0, 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.
f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], 0.46663367437984204, decimal=7)
npt.assert_almost_equal(f_y[0], 0.95307422686028065, decimal=7)
else:
npt.assert_almost_equal(f_x[0], 0, decimal=7)
npt.assert_almost_equal(f_y[0], 0, decimal=7)
x = np.array([1., 3, 4])
y = np.array([2., 1, 1])
a = np.zeros_like(x)
values = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G)
if fastell4py_bool:
npt.assert_almost_equal(values[0][0], 0.46663367437984204, decimal=7)
npt.assert_almost_equal(values[1][0], 0.95307422686028065, decimal=7)
npt.assert_almost_equal(values[0][1], 1.0722152681324291, decimal=7)
npt.assert_almost_equal(values[1][1], 0.31400298272329669, decimal=7)
else:
npt.assert_almost_equal(values[0][0], 0, decimal=7)
npt.assert_almost_equal(values[1][0], 0, decimal=7)
npt.assert_almost_equal(values[0][1], 0, decimal=7)
npt.assert_almost_equal(values[1][1], 0, decimal=7)
a += values[0]
x = 1.
y = 2.
phi_E = 1.
gamma = 1.9
q = 0.9
phi_G = 1.
f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G)
if fastell4py_bool:
npt.assert_almost_equal(f_x, 0.46663367437984204, decimal=7)
npt.assert_almost_equal(f_y, 0.95307422686028065, decimal=7)
else:
npt.assert_almost_equal(f_x, 0, decimal=7)
npt.assert_almost_equal(f_y, 0, decimal=7)
x = 0.
y = 0.
f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G)
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.
f_xx, f_yy,f_xy = self.SPEMD.hessian(x, y, phi_E, gamma, q, phi_G)
if fastell4py_bool:
npt.assert_almost_equal(f_xx, 0.41789957732890953, decimal=7)
npt.assert_almost_equal(f_yy, 0.14047593655054141, decimal=7)
npt.assert_almost_equal(f_xy, -0.18560737698052343, decimal=7)
else:
npt.assert_almost_equal(f_xx, 0, decimal=7)
npt.assert_almost_equal(f_yy, 0, decimal=7)
npt.assert_almost_equal(f_xy, 0, decimal=7)
x = 1.
y = 2.
phi_E = 1.
gamma = 1.9
q = 0.9
phi_G = 1.
a = np.zeros_like(x)
f_xx, f_yy,f_xy = self.SPEMD.hessian(x, y, phi_E, gamma, q, phi_G)
if fastell4py_bool:
npt.assert_almost_equal(f_xx, 0.41789957732890953, decimal=7)
npt.assert_almost_equal(f_yy, 0.14047593655054141, decimal=7)
npt.assert_almost_equal(f_xy, -0.18560737698052343, decimal=7)
else:
npt.assert_almost_equal(f_xx, 0, decimal=7)
npt.assert_almost_equal(f_yy, 0, decimal=7)
npt.assert_almost_equal(f_xy, 0, decimal=7)
a += f_xx
x = np.array([1,3,4])
y = np.array([2,1,1])
values = self.SPEMD.hessian(x, y, phi_E, gamma, q, phi_G)
print(values, 'values')
if fastell4py_bool:
npt.assert_almost_equal(values[0][0], 0.41789957732890953, decimal=7)
npt.assert_almost_equal(values[1][0], 0.14047593655054141, decimal=7)
npt.assert_almost_equal(values[2][0], -0.18560737698052343, decimal=7)
npt.assert_almost_equal(values[0][1], 0.068359818958208918, decimal=7)
npt.assert_almost_equal(values[1][1], 0.32494089371516482, decimal=7)
npt.assert_almost_equal(values[2][1], -0.097845438684594374, decimal=7)
else:
npt.assert_almost_equal(values[0][0], 0, decimal=7)
def test_spep_spemd(self):
x = np.array([1])
y = np.array([0])
phi_E = 1.
gamma = 2.
q = 1.
phi_G = 1.
f_x, f_y = self.SPEMD.derivatives(x, y, phi_E, gamma, q, phi_G)
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, phi_E, gamma, q, phi_G)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2)
else:
pass
theta_E = 2.
gamma = 2.
q = 1.
phi_G = 1.
f_x, f_y = self.SPEMD.derivatives(x, y, theta_E, gamma, q, phi_G)
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, q, phi_G)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=2)
else:
pass
theta_E = 2.
gamma = 1.7
q = 1.
phi_G = 1.
f_x, f_y = self.SPEMD.derivatives(x, y, theta_E, gamma, q, phi_G)
f_x_spep, f_y_spep = self.SPEP.derivatives(x, y, theta_E, gamma, q, phi_G)
if fastell4py_bool:
npt.assert_almost_equal(f_x[0], f_x_spep[0], decimal=4)