def test_distortions(self):
# test whether inverse ellipticity distrotions can be fully described by reduced shear distortions
# elliptical gaussian
x, y = util.make_grid(numPix=10, deltapix=0.1)
gauss = GaussianEllipse()
shear = ShearReduced()
flux_round = gauss.function(x, y, amp=1, sigma=0.1, e1=0, e2=0)
e1, e2, = 0, 0.1
f_x, f_y = shear.derivatives(x, y, gamma1=-e1, gamma2=-e2)
flux_distorted = gauss.function(x - f_x, y - f_y, amp=1, sigma=0.1, e1=e1, e2=e2)
npt.assert_almost_equal(flux_round, flux_distorted, decimal=9)
e1, e2, = 0.2, 0
f_x, f_y = shear.derivatives(x, y, gamma1=-e1, gamma2=-e2)
flux_distorted = gauss.function(x - f_x, y - f_y, amp=1, sigma=0.1, e1=e1, e2=e2)
npt.assert_almost_equal(flux_round, flux_distorted, decimal=9)
e1, e2, = -0.2, 0.1
f_x, f_y = shear.derivatives(x, y, gamma1=-e1, gamma2=-e2)
flux_distorted = gauss.function(x - f_x, y - f_y, amp=1, sigma=0.1, e1=e1, e2=e2)
npt.assert_almost_equal(flux_round, flux_distorted, decimal=9)
class TestShearReduced(object):
def setup(self):
self.shear = ShearReduced()
def test_magnification(self):
# test whether magnification is unity
x, y = 1, 1
f_xx, f_xy, f_yx, f_yy = self.shear.hessian(x, y, gamma1=0.1, gamma2=-0.1)
det_A = (1 - f_xx) * (1 - f_yy) - f_xy * f_yx
npt.assert_almost_equal(det_A, 1, decimal=8)
def test_distortions(self):
# test whether inverse ellipticity distrotions can be fully described by reduced shear distortions
# elliptical gaussian
x, y = util.make_grid(numPix=10, deltapix=0.1)
gauss = GaussianEllipse()
shear = ShearReduced()
flux_round = gauss.function(x, y, amp=1, sigma=0.1, e1=0, e2=0)
e1, e2, = 0, 0.1
f_x, f_y = shear.derivatives(x, y, gamma1=-e1, gamma2=-e2)
flux_distorted = gauss.function(x - f_x, y - f_y, amp=1, sigma=0.1, e1=e1, e2=e2)
npt.assert_almost_equal(flux_round, flux_distorted, decimal=9)
e1, e2, = 0.2, 0
f_x, f_y = shear.derivatives(x, y, gamma1=-e1, gamma2=-e2)
flux_distorted = gauss.function(x - f_x, y - f_y, amp=1, sigma=0.1, e1=e1, e2=e2)
npt.assert_almost_equal(flux_round, flux_distorted, decimal=9)
e1, e2, = -0.2, 0.1
f_x, f_y = shear.derivatives(x, y, gamma1=-e1, gamma2=-e2)
flux_distorted = gauss.function(x - f_x, y - f_y, amp=1, sigma=0.1, e1=e1, e2=e2)
npt.assert_almost_equal(flux_round, flux_distorted, decimal=9)
def setup(self):
self.shear = ShearReduced()
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 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__()