def test_kwargs_interpolation(self):
numPix = 101
deltaPix = 0.1
x_grid_interp, y_grid_interp = util.make_grid(numPix, deltaPix)
sis = SIS()
kwargs_SIS = {'theta_E': 1., 'center_x': 0.5, 'center_y': -0.5}
f_sis = sis.function(x_grid_interp, y_grid_interp, **kwargs_SIS)
f_x_sis, f_y_sis = sis.derivatives(x_grid_interp, y_grid_interp,
**kwargs_SIS)
f_xx_sis, f_yy_sis, f_xy_sis = sis.hessian(x_grid_interp,
y_grid_interp, **kwargs_SIS)
x_axes, y_axes = util.get_axes(x_grid_interp, y_grid_interp)
interp_func = Interpol_func()
kwargs_interp = {
'grid_interp_x': x_axes,
'grid_interp_y': y_axes,
'f_': util.array2image(f_sis),
'f_x': util.array2image(f_x_sis),
'f_y': util.array2image(f_y_sis),
'f_xx': util.array2image(f_xx_sis),
'f_yy': util.array2image(f_yy_sis),
'f_xy': util.array2image(f_xy_sis)
}
x, y = 1., 1.
alpha_x, alpha_y = interp_func.derivatives(x, y, **kwargs_interp)
assert alpha_x == 0.31622776601683794
f_ = interp_func.function(x, y, **kwargs_interp)
npt.assert_almost_equal(f_, 1.5811388300841898)
def test_hessian_finite_differential(self):
numPix = 101
deltaPix = 0.1
x_grid_interp, y_grid_interp = util.make_grid(numPix, deltaPix)
sis = SIS()
kwargs_SIS = {'theta_E': 1., 'center_x': 0.5, 'center_y': -0.5}
f_sis = sis.function(x_grid_interp, y_grid_interp, **kwargs_SIS)
f_x_sis, f_y_sis = sis.derivatives(x_grid_interp, y_grid_interp,
**kwargs_SIS)
x_axes, y_axes = util.get_axes(x_grid_interp, y_grid_interp)
interp_func = Interpol()
kwargs_interp = {
'grid_interp_x': x_axes,
'grid_interp_y': y_axes,
'f_': util.array2image(f_sis),
'f_x': util.array2image(f_x_sis),
'f_y': util.array2image(f_y_sis)
}
x, y = 1., 0.
f_xx, f_xy, f_yx, f_yy = interp_func.hessian(x, y, **kwargs_interp)
f_xx_true, f_xy_true, f_yx_true, f_yy_true = sis.hessian(
x, y, **kwargs_SIS)
npt.assert_almost_equal(f_xx, f_xx_true, decimal=1)
npt.assert_almost_equal(f_xy, f_xy_true, decimal=1)
npt.assert_almost_equal(f_yx, f_yx_true, decimal=1)
npt.assert_almost_equal(f_yy, f_yy_true, decimal=1)
def test_density(self):
theta_E = 1
r = 1
lensModel = SinglePlane(lens_model_list=['SIS'])
density = lensModel.density(r=r, kwargs=[{'theta_E': theta_E}])
sis = SIS()
density_model = sis.density_lens(r=r, theta_E=theta_E)
npt.assert_almost_equal(density, density_model, decimal=8)
def test_do_interpol(self):
numPix = 101
deltaPix = 0.1
x_grid_interp, y_grid_interp = util.make_grid(numPix, deltaPix)
sis = SIS()
kwargs_SIS = {'theta_E': 1., 'center_x': 0.5, 'center_y': -0.5}
f_sis = sis.function(x_grid_interp, y_grid_interp, **kwargs_SIS)
f_x_sis, f_y_sis = sis.derivatives(x_grid_interp, y_grid_interp,
**kwargs_SIS)
f_xx_sis, f_yy_sis, f_xy_sis = sis.hessian(x_grid_interp,
y_grid_interp, **kwargs_SIS)
x_axes, y_axes = util.get_axes(x_grid_interp, y_grid_interp)
interp_func = Interpol_func()
interp_func_loop = Interpol_func(grid=False)
interp_func.do_interp(x_axes, y_axes, util.array2image(f_sis),
util.array2image(f_x_sis),
util.array2image(f_y_sis),
util.array2image(f_xx_sis),
util.array2image(f_yy_sis),
util.array2image(f_xy_sis))
interp_func_loop.do_interp(x_axes, y_axes, util.array2image(f_sis),
util.array2image(f_x_sis),
util.array2image(f_y_sis),
util.array2image(f_xx_sis),
util.array2image(f_yy_sis),
util.array2image(f_xy_sis))
# test derivatives
assert interp_func.derivatives(1, 0) == sis.derivatives(
1, 0, **kwargs_SIS)
assert interp_func.derivatives(1, 0) == interp_func_loop.derivatives(
1, 0)
alpha1_interp, alpha2_interp = interp_func.derivatives(
np.array([0, 1, 0, 1]), np.array([1, 1, 2, 2]))
alpha1_interp_loop, alpha2_interp_loop = interp_func_loop.derivatives(
np.array([0, 1, 0, 1]), np.array([1, 1, 2, 2]))
alpha1_true, alpha2_true = sis.derivatives(np.array([0, 1, 0, 1]),
np.array([1, 1, 2, 2]),
**kwargs_SIS)
assert alpha1_interp[0] == alpha1_true[0]
assert alpha1_interp[1] == alpha1_true[1]
assert alpha1_interp[0] == alpha1_interp_loop[0]
assert alpha1_interp[1] == alpha1_interp_loop[1]
# test hessian
assert interp_func.hessian(1, 0) == sis.hessian(1, 0, **kwargs_SIS)
f_xx_interp, f_yy_interp, f_xy_interp = interp_func.hessian(
np.array([0, 1, 0, 1]), np.array([1, 1, 2, 2]))
f_xx_interp_loop, f_yy_interp_loop, f_xy_interp_loop = interp_func_loop.hessian(
np.array([0, 1, 0, 1]), np.array([1, 1, 2, 2]))
f_xx_true, f_yy_true, f_xy_true = sis.hessian(np.array([0, 1, 0, 1]),
np.array([1, 1, 2, 2]),
**kwargs_SIS)
assert f_xx_interp[0] == f_xx_true[0]
assert f_xx_interp[1] == f_xx_true[1]
assert f_xy_interp[0] == f_xy_true[0]
assert f_xy_interp[1] == f_xy_true[1]
assert f_xx_interp[0] == f_xx_interp_loop[0]
assert f_xx_interp[1] == f_xx_interp_loop[1]
assert f_xy_interp[0] == f_xy_interp_loop[0]
assert f_xy_interp[1] == f_xy_interp_loop[1]
def test_interp_func_scaled(self):
numPix = 101
deltaPix = 0.1
x_grid_interp, y_grid_interp = util.make_grid(numPix, deltaPix)
sis = SIS()
kwargs_SIS = {'theta_E': 1., 'center_x': 0.5, 'center_y': -0.5}
f_sis = sis.function(x_grid_interp, y_grid_interp, **kwargs_SIS)
f_x_sis, f_y_sis = sis.derivatives(x_grid_interp, y_grid_interp,
**kwargs_SIS)
f_xx_sis, f_xy_sis, f_yx_sis, f_yy_sis = sis.hessian(
x_grid_interp, y_grid_interp, **kwargs_SIS)
x_axes, y_axes = util.get_axes(x_grid_interp, y_grid_interp)
kwargs_interp = {
'grid_interp_x': x_axes,
'grid_interp_y': y_axes,
'f_': util.array2image(f_sis),
'f_x': util.array2image(f_x_sis),
'f_y': util.array2image(f_y_sis),
'f_xx': util.array2image(f_xx_sis),
'f_yy': util.array2image(f_yy_sis),
'f_xy': util.array2image(f_xy_sis)
}
interp_func = InterpolScaled(grid=False)
x, y = 1., 1.
alpha_x, alpha_y = interp_func.derivatives(x,
y,
scale_factor=1,
**kwargs_interp)
assert alpha_x == 0.31622776601683794
f_ = interp_func.function(x, y, scale_factor=1., **kwargs_interp)
npt.assert_almost_equal(f_, 1.5811388300841898)
f_xx, f_xy, f_yx, f_yy = interp_func.hessian(x,
y,
scale_factor=1.,
**kwargs_interp)
npt.assert_almost_equal(f_xx, 0.56920997883030822, decimal=8)
npt.assert_almost_equal(f_yy, 0.063245553203367583, decimal=8)
npt.assert_almost_equal(f_xy, -0.18973665961010275, decimal=8)
npt.assert_almost_equal(f_xy, f_yx, decimal=8)
x_grid, y_grid = util.make_grid(10, deltaPix)
f_xx, f_xy, f_yx, f_yy = interp_func.hessian(x_grid,
y_grid,
scale_factor=1.,
**kwargs_interp)
npt.assert_almost_equal(f_xx[0], 0, decimal=2)
def test_shift(self):
numPix = 101
deltaPix = 0.1
x_grid_interp, y_grid_interp = util.make_grid(numPix, deltaPix)
sis = SIS()
kwargs_SIS = {'theta_E': 1., 'center_x': 0.5, 'center_y': -0.5}
f_sis = sis.function(x_grid_interp, y_grid_interp, **kwargs_SIS)
f_x_sis, f_y_sis = sis.derivatives(x_grid_interp, y_grid_interp,
**kwargs_SIS)
f_xx_sis, f_yy_sis, f_xy_sis = sis.hessian(x_grid_interp,
y_grid_interp, **kwargs_SIS)
x_axes, y_axes = util.get_axes(x_grid_interp, y_grid_interp)
kwargs_interp = {
'grid_interp_x': x_axes,
'grid_interp_y': y_axes,
'f_': util.array2image(f_sis),
'f_x': util.array2image(f_x_sis),
'f_y': util.array2image(f_y_sis),
'f_xx': util.array2image(f_xx_sis),
'f_yy': util.array2image(f_yy_sis),
'f_xy': util.array2image(f_xy_sis)
}
interp_func = Interpol(grid=False)
x, y = 1., 1.
alpha_x, alpha_y = interp_func.derivatives(x, y, **kwargs_interp)
assert alpha_x == 0.31622776601683794
interp_func = Interpol(grid=False)
x_shift = 1.
kwargs_shift = {
'grid_interp_x': x_axes + x_shift,
'grid_interp_y': y_axes,
'f_': util.array2image(f_sis),
'f_x': util.array2image(f_x_sis),
'f_y': util.array2image(f_y_sis),
'f_xx': util.array2image(f_xx_sis),
'f_yy': util.array2image(f_yy_sis),
'f_xy': util.array2image(f_xy_sis)
}
alpha_x_shift, alpha_y_shift = interp_func.derivatives(
x + x_shift, y, **kwargs_shift)
npt.assert_almost_equal(alpha_x_shift, alpha_x, decimal=10)
def test_potenial_from_kappa(self):
sis = SIS()
deltaPix = 0.01
x_grid, y_grid = util.make_grid(numPix=1000, deltapix=deltaPix)
kwargs_sis = {'theta_E': 1., 'center_x': 0, 'center_y': 0}
f_xx, f_yy, _ = sis.hessian(x_grid, y_grid, **kwargs_sis)
f_ = sis.function(x_grid, y_grid, **kwargs_sis)
f_ = util.array2image(f_)
kappa = (f_xx + f_yy) / 2.
potential_num = self.integral.potential_from_kappa(
kappa, x_grid, y_grid, deltaPix)
x1, y1 = 550, 550
x2, y2 = 550, 450
# test relative potential at two different point way inside the kappa map
npt.assert_almost_equal(potential_num[x1, y1] - potential_num[x2, y2],
f_[x1, y1] - f_[x2, y2],
decimal=2)
def test_function(self):
"""
:return:
"""
profile = PowerLaw()
spp = SPP()
sis = SIS()
x = np.linspace(0.1, 10, 10)
kwargs_light = {'amp': 1., 'gamma': 2, 'e1': 0, 'e2': 0}
kwargs_spp = {'theta_E': 1., 'gamma': 2}
kwargs_sis = {'theta_E': 1.}
flux = profile.function(x=x, y=1., **kwargs_light)
f_xx, f_xy, f_yx, f_yy = spp.hessian(x=x, y=1., **kwargs_spp)
kappa_spp = 1 / 2. * (f_xx + f_yy)
f_xx, f_xy, f_yx, f_yy = sis.hessian(x=x, y=1., **kwargs_sis)
kappa_sis = 1 / 2. * (f_xx + f_yy)
npt.assert_almost_equal(kappa_sis, kappa_spp, decimal=5)
npt.assert_almost_equal(flux / flux[0],
kappa_sis / kappa_sis[0],
decimal=5)
def test_call(self):
numPix = 101
deltaPix = 0.1
x_grid_interp, y_grid_interp = util.make_grid(numPix, deltaPix)
sis = SIS()
kwargs_SIS = {'theta_E': 1., 'center_x': 0.5, 'center_y': -0.5}
f_sis = sis.function(x_grid_interp, y_grid_interp, **kwargs_SIS)
f_x_sis, f_y_sis = sis.derivatives(x_grid_interp, y_grid_interp,
**kwargs_SIS)
f_xx_sis, f_yy_sis, f_xy_sis = sis.hessian(x_grid_interp,
y_grid_interp, **kwargs_SIS)
x_axes, y_axes = util.get_axes(x_grid_interp, y_grid_interp)
interp_func = Interpol(grid=True)
interp_func.do_interp(x_axes, y_axes, util.array2image(f_sis),
util.array2image(f_x_sis),
util.array2image(f_y_sis),
util.array2image(f_xx_sis),
util.array2image(f_yy_sis),
util.array2image(f_xy_sis))
x, y = 1., 1.
alpha_x, alpha_y = interp_func.derivatives(x, y, **{})
assert alpha_x == 0.31622776601683794
def setup(self):
self.SPEP = SPEP()
self.SPP = SPP()
self.SIS = SIS()
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 _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):
self.nie = NIE()
self.spemd = SPEMD_SMOOTH()
self.sis = SIS()
class TestCurvedArcSISMST(object):
"""
tests the source model routines
"""
def setup(self):
self.model = CurvedArcSISMST()
self.sis = SIS()
self.mst = Convergence()
def test_spp2stretch(self):
center_x, center_y = 1, 1
theta_E = 1
kappa = 0.1
center_x_spp, center_y_spp = 0., 0
tangential_stretch, radial_stretch, curvature, direction = self.model.sis_mst2stretch(
theta_E, kappa, center_x_spp, center_y_spp, center_x, center_y)
theta_E_new, kappa_new, center_x_spp_new, center_y_spp_new = self.model.stretch2sis_mst(
tangential_stretch, radial_stretch, curvature, direction, center_x,
center_y)
npt.assert_almost_equal(center_x_spp_new, center_x_spp, decimal=8)
npt.assert_almost_equal(center_y_spp_new, center_y_spp, decimal=8)
npt.assert_almost_equal(theta_E_new, theta_E, decimal=8)
npt.assert_almost_equal(kappa_new, kappa, decimal=8)
center_x, center_y = -1, 1
tangential_stretch, radial_stretch, curvature, direction = self.model.sis_mst2stretch(
theta_E, kappa, center_x_spp, center_y_spp, center_x, center_y)
theta_E_new, kappa_new, center_x_spp_new, center_y_spp_new = self.model.stretch2sis_mst(
tangential_stretch, radial_stretch, curvature, direction, center_x,
center_y)
npt.assert_almost_equal(center_x_spp_new, center_x_spp, decimal=8)
npt.assert_almost_equal(center_y_spp_new, center_y_spp, decimal=8)
npt.assert_almost_equal(theta_E_new, theta_E, decimal=8)
npt.assert_almost_equal(kappa_new, kappa, decimal=8)
center_x, center_y = 0, 0.5
tangential_stretch, radial_stretch, curvature, direction = self.model.sis_mst2stretch(
theta_E, kappa, center_x_spp, center_y_spp, center_x, center_y)
theta_E_new, kappa_new, center_x_spp_new, center_y_spp_new = self.model.stretch2sis_mst(
tangential_stretch, radial_stretch, curvature, direction, center_x,
center_y)
npt.assert_almost_equal(center_x_spp_new, center_x_spp, decimal=8)
npt.assert_almost_equal(center_y_spp_new, center_y_spp, decimal=8)
npt.assert_almost_equal(theta_E_new, theta_E, decimal=8)
npt.assert_almost_equal(kappa_new, kappa, decimal=8)
center_x, center_y = 0, -1.5
tangential_stretch, radial_stretch, r_curvature, direction = self.model.sis_mst2stretch(
theta_E, kappa, center_x_spp, center_y_spp, center_x, center_y)
print(tangential_stretch, radial_stretch, r_curvature, direction)
theta_E_new, kappa_new, center_x_spp_new, center_y_spp_new = self.model.stretch2sis_mst(
tangential_stretch, radial_stretch, r_curvature, direction,
center_x, center_y)
npt.assert_almost_equal(center_x_spp_new, center_x_spp, decimal=8)
npt.assert_almost_equal(center_y_spp_new, center_y_spp, decimal=8)
npt.assert_almost_equal(theta_E_new, theta_E, decimal=8)
npt.assert_almost_equal(kappa_new, kappa, decimal=8)
def test_function(self):
center_x, center_y = 0., 0.
x, y = 1, 1
radial_stretch = 1
output = self.model.function(x,
y,
tangential_stretch=2,
radial_stretch=radial_stretch,
curvature=1. / 2,
direction=0,
center_x=center_x,
center_y=center_y)
theta_E, kappa_ext, center_x_sis, center_y_sis = self.model.stretch2sis_mst(
tangential_stretch=2,
radial_stretch=radial_stretch,
curvature=1. / 2,
direction=0,
center_x=center_x,
center_y=center_y)
f_sis_out = self.sis.function(
1, 1, theta_E, center_x_sis, center_y_sis
) # - self.sis.function(0, 0, theta_E, center_x_sis, center_y_sis)
alpha_x, alpha_y = self.sis.derivatives(center_x, center_y, theta_E,
center_x_sis, center_y_sis)
f_sis_0_out = alpha_x * (x - center_x) + alpha_y * (y - center_y)
f_mst_out = self.mst.function(x,
y,
kappa_ext,
ra_0=center_x,
dec_0=center_y)
lambda_mst = 1. / radial_stretch
f_out = lambda_mst * (f_sis_out - f_sis_0_out) + f_mst_out
npt.assert_almost_equal(output, f_out, decimal=8)
def test_derivatives(self):
tangential_stretch = 5
radial_stretch = 1
curvature = 1. / 10
direction = 0.3
center_x = 0
center_y = 0
x, y = 1, 1
theta_E, kappa, center_x_spp, center_y_spp = self.model.stretch2sis_mst(
tangential_stretch, radial_stretch, curvature, direction, center_x,
center_y)
f_x_sis, f_y_sis = self.sis.derivatives(x, y, theta_E, center_x_spp,
center_y_spp)
f_x_mst, f_y_mst = self.mst.derivatives(x,
y,
kappa,
ra_0=center_x,
dec_0=center_y)
f_x0, f_y0 = self.sis.derivatives(center_x, center_y, theta_E,
center_x_spp, center_y_spp)
f_x_new, f_y_new = self.model.derivatives(x, y, tangential_stretch,
radial_stretch, curvature,
direction, center_x,
center_y)
npt.assert_almost_equal(f_x_new, f_x_sis + f_x_mst - f_x0, decimal=8)
npt.assert_almost_equal(f_y_new, f_y_sis + f_y_mst - f_y0, decimal=8)
def test_hessian(self):
lens = LensModel(lens_model_list=['CURVED_ARC_SIS_MST'])
center_x, center_y = 0, 0
tangential_stretch = 10
radial_stretch = 1
kwargs_lens = [{
'tangential_stretch': tangential_stretch,
'radial_stretch': radial_stretch,
'curvature': 1. / 10.5,
'direction': 0.,
'center_x': center_x,
'center_y': center_y
}]
mag = lens.magnification(center_x, center_y, kwargs=kwargs_lens)
npt.assert_almost_equal(mag,
tangential_stretch * radial_stretch,
decimal=8)
center_x, center_y = 2, 3
tangential_stretch = 10
radial_stretch = 1
kwargs_lens = [{
'tangential_stretch': tangential_stretch,
'radial_stretch': radial_stretch,
'curvature': 1. / 10.5,
'direction': 0.,
'center_x': center_x,
'center_y': center_y
}]
mag = lens.magnification(center_x, center_y, kwargs=kwargs_lens)
npt.assert_almost_equal(mag,
tangential_stretch * radial_stretch,
decimal=8)
center_x, center_y = 0, 0
tangential_stretch = 5
radial_stretch = 1.2
kwargs_lens = [{
'tangential_stretch': tangential_stretch,
'radial_stretch': radial_stretch,
'curvature': 1. / 10.5,
'direction': 0.,
'center_x': center_x,
'center_y': center_y
}]
mag = lens.magnification(center_x, center_y, kwargs=kwargs_lens)
npt.assert_almost_equal(mag,
tangential_stretch * radial_stretch,
decimal=8)
center_x, center_y = 0, 0
tangential_stretch = 3
radial_stretch = -1
kwargs_lens = [{
'tangential_stretch': tangential_stretch,
'radial_stretch': radial_stretch,
'curvature': 1. / 10.5,
'direction': 0.,
'center_x': center_x,
'center_y': center_y
}]
mag = lens.magnification(center_x, center_y, kwargs=kwargs_lens)
print(tangential_stretch, radial_stretch, 'stretches')
npt.assert_almost_equal(mag,
tangential_stretch * radial_stretch,
decimal=8)
center_x, center_y = 0, 0
tangential_stretch = -3
radial_stretch = -1
kwargs_lens = [{
'tangential_stretch': tangential_stretch,
'radial_stretch': radial_stretch,
'curvature': 1. / 10.5,
'direction': 0.,
'center_x': center_x,
'center_y': center_y
}]
mag = lens.magnification(center_x, center_y, kwargs=kwargs_lens)
npt.assert_almost_equal(mag,
tangential_stretch * radial_stretch,
decimal=8)
center_x, center_y = 0, 0
tangential_stretch = 10.4
radial_stretch = 0.6
kwargs_lens = [{
'tangential_stretch': tangential_stretch,
'radial_stretch': radial_stretch,
'curvature': 1. / 10.5,
'direction': 0.,
'center_x': center_x,
'center_y': center_y
}]
mag = lens.magnification(center_x, center_y, kwargs=kwargs_lens)
npt.assert_almost_equal(mag,
tangential_stretch * radial_stretch,
decimal=8)
class CurvedArcSISMST(LensProfileBase):
"""
lens model that describes a section of a highly magnified deflector region.
The parameterization is chosen to describe local observables efficient.
Observables are:
- curvature radius (basically bending relative to the center of the profile)
- radial stretch (plus sign) thickness of arc with parity (more generalized than the power-law slope)
- tangential stretch (plus sign). Infinity means at critical curve
- direction of curvature
- position of arc
Requirements:
- Should work with other perturbative models without breaking its meaning (say when adding additional shear terms)
- Must best reflect the observables in lensing
- minimal covariances between the parameters, intuitive parameterization.
"""
param_names = [
'tangential_stretch', 'radial_stretch', 'curvature', 'direction',
'center_x', 'center_y'
]
lower_limit_default = {
'tangential_stretch': -100,
'radial_stretch': -5,
'curvature': 0.000001,
'direction': -np.pi,
'center_x': -100,
'center_y': -100
}
upper_limit_default = {
'tangential_stretch': 100,
'radial_stretch': 5,
'curvature': 100,
'direction': np.pi,
'center_x': 100,
'center_y': 100
}
def __init__(self):
self._sis = SIS()
self._mst = Convergence()
super(CurvedArcSISMST, self).__init__()
@staticmethod
def stretch2sis_mst(tangential_stretch, radial_stretch, curvature,
direction, center_x, center_y):
"""
:param tangential_stretch: float, stretch of intrinsic source in tangential direction
:param radial_stretch: float, stretch of intrinsic source in radial direction
:param curvature: 1/curvature radius
:param direction: float, angle in radian
:param center_x: center of source in image plane
:param center_y: center of source in image plane
:return: parameters in terms of a spherical SIS + MST resulting in the same observables
"""
center_x_sis, center_y_sis = center_deflector(curvature, direction,
center_x, center_y)
r_curvature = 1. / curvature
lambda_mst = 1. / radial_stretch
kappa_ext = 1 - lambda_mst
theta_E = r_curvature * (1. - radial_stretch / tangential_stretch)
return theta_E, kappa_ext, center_x_sis, center_y_sis
@staticmethod
def sis_mst2stretch(theta_E, kappa_ext, center_x_sis, center_y_sis,
center_x, center_y):
"""
turn Singular power-law lens model into stretch parameterization at position (center_x, center_y)
This is the inverse function of stretch2spp()
:param theta_E: Einstein radius of SIS profile
:param kappa_ext: external convergence (MST factor 1 - kappa_ext)
:param center_x_sis: center of SPP model
:param center_y_sis: center of SPP model
:param center_x: center of curved model definition
:param center_y: center of curved model definition
:return: tangential_stretch, radial_stretch, curvature, direction
:return:
"""
r_curvature = np.sqrt((center_x_sis - center_x)**2 +
(center_y_sis - center_y)**2)
direction = np.arctan2(center_y - center_y_sis,
center_x - center_x_sis)
radial_stretch = 1. / (1 - kappa_ext)
tangential_stretch = 1 / (1 - (theta_E / r_curvature)) * radial_stretch
curvature = 1. / r_curvature
return tangential_stretch, radial_stretch, curvature, direction
def function(self, x, y, tangential_stretch, radial_stretch, curvature,
direction, center_x, center_y):
"""
ATTENTION: there may not be a global lensing potential!
:param x:
:param y:
:param tangential_stretch: float, stretch of intrinsic source in tangential direction
:param radial_stretch: float, stretch of intrinsic source in radial direction
:param curvature: 1/curvature radius
:param direction: float, angle in radian
:param center_x: center of source in image plane
:param center_y: center of source in image plane
:return:
"""
lambda_mst = 1. / radial_stretch
theta_E, kappa_ext, center_x_sis, center_y_sis = self.stretch2sis_mst(
tangential_stretch, radial_stretch, curvature, direction, center_x,
center_y)
f_sis = self._sis.function(
x, y, theta_E, center_x_sis, center_y_sis
) # - self._sis.function(center_x, center_y, theta_E, center_x_sis, center_y_sis)
alpha_x, alpha_y = self._sis.derivatives(center_x, center_y, theta_E,
center_x_sis, center_y_sis)
f_sis_0 = alpha_x * (x - center_x) + alpha_y * (y - center_y)
f_mst = self._mst.function(x,
y,
kappa_ext,
ra_0=center_x,
dec_0=center_y)
return lambda_mst * (f_sis - f_sis_0) + f_mst
def derivatives(self, x, y, tangential_stretch, radial_stretch, curvature,
direction, center_x, center_y):
"""
:param x:
:param y:
:param tangential_stretch: float, stretch of intrinsic source in tangential direction
:param radial_stretch: float, stretch of intrinsic source in radial direction
:param curvature: 1/curvature radius
:param direction: float, angle in radian
:param center_x: center of source in image plane
:param center_y: center of source in image plane
:return:
"""
lambda_mst = 1. / radial_stretch
theta_E, kappa_ext, center_x_sis, center_y_sis = self.stretch2sis_mst(
tangential_stretch, radial_stretch, curvature, direction, center_x,
center_y)
f_x_sis, f_y_sis = self._sis.derivatives(x, y, theta_E, center_x_sis,
center_y_sis)
f_x0, f_y0 = self._sis.derivatives(center_x, center_y, theta_E,
center_x_sis, center_y_sis)
f_x_mst, f_y_mst = self._mst.derivatives(x,
y,
kappa_ext,
ra_0=center_x,
dec_0=center_y)
f_x = lambda_mst * (f_x_sis - f_x0) + f_x_mst
f_y = lambda_mst * (f_y_sis - f_y0) + f_y_mst
return f_x, f_y
def hessian(self, x, y, tangential_stretch, radial_stretch, curvature,
direction, center_x, center_y):
"""
:param x:
:param y:
:param tangential_stretch: float, stretch of intrinsic source in tangential direction
:param radial_stretch: float, stretch of intrinsic source in radial direction
:param curvature: 1/curvature radius
:param direction: float, angle in radian
:param center_x: center of source in image plane
:param center_y: center of source in image plane
:return:
"""
lambda_mst = 1. / radial_stretch
theta_E, kappa_ext, center_x_sis, center_y_sis = self.stretch2sis_mst(
tangential_stretch, radial_stretch, curvature, direction, center_x,
center_y)
f_xx_sis, f_yy_sis, f_xy_sis = self._sis.hessian(
x, y, theta_E, center_x_sis, center_y_sis)
f_xx_mst, f_yy_mst, f_xy_mst = self._mst.hessian(x,
y,
kappa_ext,
ra_0=center_x,
dec_0=center_y)
return lambda_mst * f_xx_sis + f_xx_mst, lambda_mst * f_yy_sis + f_yy_mst, lambda_mst * f_xy_sis + f_xy_mst
def __init__(self):
self._sis = SIS()
self._mst = Convergence()
super(CurvedArcSISMST, self).__init__()
