def setup(self):
self.model = CurvedArcSISMST()
self.sis = SIS()
self.mst = Convergence()
def setup(self):
self.arc_sis = CurvedArcSISMST()
self.arc_const = CurvedArcConst()
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)
def test_curved_arc_recovery(self):
"""
test whether the curved arc parameters are satisfied in differential form
"""
ext = LensModelExtensions(LensModel(lens_model_list=['CURVED_ARC_SIS_MST']))
center_x, center_y = 1, 1. # test works except at (0,0) where the direction angle is not well defined
tangential_stretch = 10.
radial_stretch = 1.2
curvature, direction = 0.02, 0.5
kwargs_lens = {'tangential_stretch': tangential_stretch, 'radial_stretch': radial_stretch,
'curvature': curvature, 'direction': direction, 'center_x': center_x, 'center_y': center_y}
self._test_curved_arc_recovery(kwargs_lens)
def _test_curved_arc_recovery(self, kwargs_arc_init):
ext = LensModelExtensions(LensModel(lens_model_list=['CURVED_ARC_SIS_MST']))
center_x, center_y = kwargs_arc_init['center_x'], kwargs_arc_init['center_y']
kwargs_arc = ext.curved_arc_estimate(center_x, center_y, [kwargs_arc_init])
lambda_rad, lambda_tan, orientation_angle, dlambda_tan_dtan, dlambda_tan_drad, dlambda_rad_drad, dlambda_rad_dtan, dphi_tan_dtan, dphi_tan_drad, dphi_rad_drad, dphi_rad_dtan = ext.radial_tangential_differentials(center_x, center_y, [kwargs_arc_init])
npt.assert_almost_equal(kwargs_arc['tangential_stretch'], kwargs_arc_init['tangential_stretch'], decimal=3)
npt.assert_almost_equal(kwargs_arc['radial_stretch'], kwargs_arc_init['radial_stretch'], decimal=3)
npt.assert_almost_equal(kwargs_arc['curvature'], kwargs_arc_init['curvature'], decimal=3)
npt.assert_almost_equal(dphi_tan_dtan, kwargs_arc_init['curvature'], decimal=3)
npt.assert_almost_equal(kwargs_arc['direction'], kwargs_arc_init['direction'], decimal=3)
npt.assert_almost_equal(dlambda_tan_dtan, 0, decimal=3)
def setup(self):
self._curve_spt = CurvedArcSPT()
self._curve_regular = CurvedArcSISMST()
class TestCurvedArcConst(object):
"""
tests the source model routines
"""
def setup(self):
self.arc_sis = CurvedArcSISMST()
self.arc_const = CurvedArcConst()
def test_function(self):
kwargs_arc = {
'tangential_stretch': 5,
#'radial_stretch': 1,
'curvature': 1. / 10,
'direction': 0,
'center_x': 0,
'center_y': 0
}
npt.assert_raises(Exception, self.arc_const.function, 0., 0.,
**kwargs_arc)
def test_derivatives(self):
kwargs_arc = {
'tangential_stretch': 3,
#'radial_stretch': 1.,
'curvature': 0.8,
'direction': 0,
'center_x': 0,
'center_y': 0
}
kwargs_arc_sis = {
'tangential_stretch': 3,
'radial_stretch': 1.,
'curvature': 0.8,
'direction': 0,
'center_x': 0,
'center_y': 0
}
x, y = util.make_grid(numPix=100, deltapix=0.01)
f_x_sis, f_y_sis = self.arc_sis.derivatives(x, y, **kwargs_arc_sis)
beta_x_sis = x - f_x_sis
beta_y_sis = y - f_y_sis
f_x_const, f_y_const = self.arc_const.derivatives(x, y, **kwargs_arc)
beta_x_const = x - f_x_const
beta_y_const = y - f_y_const
from lenstronomy.LightModel.light_model import LightModel
gauss = LightModel(['GAUSSIAN'])
kwargs_source = [{
'amp': 1,
'sigma': 0.05,
'center_x': 0,
'center_y': 0
}]
flux_sis = gauss.surface_brightness(beta_x_sis, beta_y_sis,
kwargs_source)
flux_const = gauss.surface_brightness(beta_x_const, beta_y_const,
kwargs_source)
npt.assert_almost_equal((flux_const - flux_sis) / np.max(flux_const),
0,
decimal=2)
# check for stability outside the defined bounds of curvature
f_x_const, f_y_const = self.arc_const.derivatives(x=0,
y=1000,
**kwargs_arc)
npt.assert_almost_equal(f_x_const, 0)
npt.assert_almost_equal(f_y_const, 0)
def test_hessian(self):
kwargs_arc = {
'tangential_stretch': 5,
#'radial_stretch': 1,
'curvature': 1. / 10,
'direction': 0.5,
'center_x': 0,
'center_y': 0
}
x, y = 0., 1.
f_xx, f_xy, f_yx, f_yy = self.arc_const.hessian(x, y, **kwargs_arc)
alpha_ra, alpha_dec = self.arc_const.derivatives(x, y, **kwargs_arc)
diff = 0.0000001
alpha_ra_dx, alpha_dec_dx = self.arc_const.derivatives(
x + diff, y, **kwargs_arc)
alpha_ra_dy, alpha_dec_dy = self.arc_const.derivatives(
x, y + diff, **kwargs_arc)
f_xx_num = (alpha_ra_dx - alpha_ra) / diff
f_xy_num = (alpha_ra_dy - alpha_ra) / diff
f_yx_num = (alpha_dec_dx - alpha_dec) / diff
f_yy_num = (alpha_dec_dy - alpha_dec) / diff
print(f_xx, f_xx_num)
print(f_xy, f_xy_num)
print(f_yx, f_yx_num)
print(f_yy, f_yy_num)
npt.assert_almost_equal(f_xx, f_xx_num)
npt.assert_almost_equal(f_xy, f_xy_num)
npt.assert_almost_equal(f_yx, f_yx_num)
npt.assert_almost_equal(f_yy, f_yy_num)
class TestCurvedArcSPT(object):
def setup(self):
self._curve_spt = CurvedArcSPT()
self._curve_regular = CurvedArcSISMST()
def test_function(self):
kwargs_arc = {
'tangential_stretch': 5,
'radial_stretch': 1,
'curvature': 1. / 10,
'direction': 0,
'center_x': 0,
'center_y': 0,
'gamma1': 0,
'gamma2': 0
}
npt.assert_raises(Exception, self._curve_spt.function, 0., 0.,
**kwargs_arc)
def test_spt_mapping(self):
e1, e2 = 0.1, -0.2
kwargs_arc_sis_mst = {
'tangential_stretch': 3,
'radial_stretch': 1.2,
'curvature': 0.8,
'direction': 0,
'center_x': 0,
'center_y': 0
}
# inverse reduced shear transform as SPT
kwargs_arc_spt = copy.deepcopy(kwargs_arc_sis_mst)
kwargs_arc_spt['gamma1'] = -e1
kwargs_arc_spt['gamma2'] = -e2
x, y = util.make_grid(numPix=100, deltapix=0.01)
f_x_sis, f_y_sis = self._curve_regular.derivatives(
x, y, **kwargs_arc_sis_mst)
beta_x_sis = x - f_x_sis
beta_y_sis = y - f_y_sis
f_x_spt, f_y_spt = self._curve_spt.derivatives(x, y, **kwargs_arc_spt)
beta_x_spt = x - f_x_spt
beta_y_spt = y - f_y_spt
from lenstronomy.LightModel.light_model import LightModel
gauss = LightModel(['GAUSSIAN_ELLIPSE'])
kwargs_source = [{
'amp': 1,
'sigma': 0.05,
'center_x': 0,
'center_y': 0,
'e1': 0,
'e2': 0
}]
kwargs_source_spt = copy.deepcopy(kwargs_source)
kwargs_source_spt[0]['e1'] = e1
kwargs_source_spt[0]['e2'] = e2
flux_sis = gauss.surface_brightness(beta_x_sis, beta_y_sis,
kwargs_source)
flux_spt = gauss.surface_brightness(beta_x_spt, beta_y_spt,
kwargs_source_spt)
npt.assert_almost_equal(flux_sis, flux_spt)
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))
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 CurvedArcSPT(LensProfileBase):
"""
Curved arc model based on SIS+MST with an additional non-linear shear distortions applied on the source coordinates
around the center.
This profile is effectively a Source Position Transform of a curved arc and a shear distortion.
"""
param_names = [
'tangential_stretch', 'radial_stretch', 'curvature', 'direction',
'gamma1', 'gamma2', 'center_x', 'center_y'
]
lower_limit_default = {
'tangential_stretch': -100,
'radial_stretch': -5,
'curvature': 0.000001,
'direction': -np.pi,
'gamma1': -0.5,
'gamma2': -0.5,
'center_x': -100,
'center_y': -100
}
upper_limit_default = {
'tangential_stretch': 100,
'radial_stretch': 5,
'curvature': 100,
'direction': np.pi,
'gamma1': 0.5,
'gamma2': 0.5,
'center_x': 100,
'center_y': 100
}
def __init__(self):
self._curve = CurvedArcSISMST()
self._distort = ShearReduced()
super(CurvedArcSPT, self).__init__()
def function(self, x, y, tangential_stretch, radial_stretch, curvature,
direction, gamma1, gamma2, 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 gamma1: non-linear reduced shear distortion in the source plane
:param gamma2: non-linear reduced shear distortion in the source plane
:param center_x: center of source in image plane
:param center_y: center of source in image plane
:return:
"""
raise NotImplemented(
'lensing potential for regularly curved arc is not implemented')
def derivatives(self, x, y, tangential_stretch, radial_stretch, curvature,
direction, gamma1, gamma2, 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 gamma1: non-linear reduced shear distortion in the source plane
:param gamma2: non-linear reduced shear distortion in the source plane
:param center_x: center of source in image plane
:param center_y: center of source in image plane
:return:
"""
# computed regular curved arc deflection
f_x_c, f_y_c = self._curve.derivatives(x, y, tangential_stretch,
radial_stretch, curvature,
direction, center_x, center_y)
# map to source plane coordinate system
beta_x, beta_y = x - f_x_c, y - f_y_c
# distort source plane coordinate system around (center_x, center_y)
f_x_b, f_y_b = self._distort.derivatives(beta_x,
beta_y,
gamma1,
gamma2,
ra_0=center_x,
dec_0=center_y)
beta_x_, beta_y_ = beta_x - f_x_b, beta_y - f_y_b
# compute total deflection between initial coordinate and final source coordinate to match lens equation
# beta = theta - alpha
f_x, f_y = x - beta_x_, y - beta_y_
return f_x, f_y
def hessian(self, x, y, tangential_stretch, radial_stretch, curvature,
direction, gamma1, gamma2, 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 gamma1: non-linear reduced shear distortion in the source plane
:param gamma2: non-linear reduced shear distortion in the source plane
:param center_x: center of source in image plane
:param center_y: center of source in image plane
:return:
"""
alpha_ra, alpha_dec = self.derivatives(x, y, tangential_stretch,
radial_stretch, curvature,
direction, gamma1, gamma2,
center_x, center_y)
diff = 0.0000001
alpha_ra_dx, alpha_dec_dx = self.derivatives(x + diff, y,
tangential_stretch,
radial_stretch, curvature,
direction, gamma1, gamma2,
center_x, center_y)
alpha_ra_dy, alpha_dec_dy = self.derivatives(x, y + diff,
tangential_stretch,
radial_stretch, curvature,
direction, gamma1, gamma2,
center_x, center_y)
f_xx = (alpha_ra_dx - alpha_ra) / diff
f_xy = (alpha_ra_dy - alpha_ra) / diff
f_yx = (alpha_dec_dx - alpha_dec) / diff
f_yy = (alpha_dec_dy - alpha_dec) / diff
return f_xx, f_xy, f_yx, f_yy
def __init__(self):
self._curve = CurvedArcSISMST()
self._distort = ShearReduced()
super(CurvedArcSPT, self).__init__()
