def psf_configure_simple(psf_type="GAUSSIAN",
fwhm=1,
kernelsize=11,
deltaPix=1,
truncate=6,
kernel=None):
"""
this routine generates keyword arguments to initialize a PSF() class in lenstronomy. Have a look at the PSF class
documentation to see the full possibilities.
:param psf_type: string, type of PSF model
:param fwhm: Full width at half maximum of PSF (if GAUSSIAN psf)
:param kernelsize: size in pixel of kernel (use odd numbers), only applicable for PIXEL kernels
:param deltaPix: pixel size in angular units (only needed for GAUSSIAN kernel
:param truncate: how many sigmas out is the truncation happening
:param kernel: 2d numpy arra centered PSF (odd number per axis)
:return: keyword arguments
"""
if psf_type == 'GAUSSIAN':
sigma = util.fwhm2sigma(fwhm)
sigma_axis = sigma
gaussian = Gaussian()
x_grid, y_grid = util.make_grid(kernelsize, deltaPix)
kernel_large = gaussian.function(x_grid,
y_grid,
amp=1.,
sigma_x=sigma_axis,
sigma_y=sigma_axis,
center_x=0,
center_y=0)
kernel_large /= np.sum(kernel_large)
kernel_large = util.array2image(kernel_large)
kernel_pixel = kernel_util.pixel_kernel(kernel_large)
kwargs_psf = {
'psf_type': psf_type,
'fwhm': fwhm,
'truncation': truncate * fwhm,
'kernel_point_source': kernel_large,
'kernel_pixel': kernel_pixel,
'pixel_size': deltaPix
}
elif psf_type == 'PIXEL':
kernel_large = copy.deepcopy(kernel)
kernel_large = kernel_util.cut_psf(kernel_large, psf_size=kernelsize)
kwargs_psf = {'psf_type': "PIXEL", 'kernel_point_source': kernel_large}
elif psf_type == 'NONE':
kwargs_psf = {'psf_type': 'NONE'}
else:
raise ValueError("psf type %s not supported!" % psf_type)
return kwargs_psf
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)
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
class Simulation(object):
"""
simulation class that querries the major class of lenstronomy
"""
def __init__(self):
self.gaussian = Gaussian()
def data_configure(self, numPix, deltaPix, exposure_time=1, sigma_bkg=1):
"""
configures the data keyword arguments with a coordinate grid centered at zero.
:param numPix: number of pixel (numPix x numPix)
:param deltaPix: pixel size
:param exposure_time: exposure time
:param sigma_bkg: background noise (Gaussian sigma)
:return:
"""
mean = 0. # background mean flux (default zero)
# 1d list of coordinates (x,y) of a numPix x numPix square grid, centered to zero
x_grid, y_grid, ra_at_xy_0, dec_at_xy_0, x_at_radec_0, y_at_radec_0, Mpix2coord, Mcoord2pix = util.make_grid_with_coordtransform(numPix=numPix, deltapix=deltaPix, subgrid_res=1)
# mask (1= model this pixel, 0= leave blanck)
exposure_map = np.ones((numPix, numPix)) * exposure_time # individual exposure time/weight per pixel
kwargs_data = {
'background_rms': sigma_bkg,
'exposure_map': exposure_map
, 'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0, 'transform_pix2angle': Mpix2coord
, 'image_data': np.zeros((numPix, numPix))
}
return kwargs_data
def psf_configure(self, psf_type="GAUSSIAN", fwhm=1, kernelsize=11, deltaPix=1, truncate=6, kernel=None):
"""
:param psf_type:
:param fwhm:
:param pixel_grid:
:return:
"""
# psf_type: 'NONE', 'gaussian', 'pixel'
# 'pixel': kernel, kernel_large
# 'gaussian': 'sigma', 'truncate'
if psf_type == 'GAUSSIAN':
sigma = util.fwhm2sigma(fwhm)
sigma_axis = sigma
x_grid, y_grid = util.make_grid(kernelsize, deltaPix)
kernel_large = self.gaussian.function(x_grid, y_grid, amp=1., sigma_x=sigma_axis, sigma_y=sigma_axis, center_x=0, center_y=0)
kernel_large /= np.sum(kernel_large)
kernel_large = util.array2image(kernel_large)
kernel_pixel = kernel_util.pixel_kernel(kernel_large)
kwargs_psf = {'psf_type': psf_type, 'fwhm': fwhm, 'truncation': truncate*fwhm, 'kernel_point_source': kernel_large, 'kernel_pixel': kernel_pixel, 'pixel_size': deltaPix}
elif psf_type == 'PIXEL':
kernel_large = copy.deepcopy(kernel)
kernel_large = kernel_util.cut_psf(kernel_large, psf_size=kernelsize)
kernel_small = copy.deepcopy(kernel)
kernel_small = kernel_util.cut_psf(kernel_small, psf_size=kernelsize)
#kwargs_psf = {'psf_type': "PIXEL", 'kernel_pixel': kernel_small, 'kernel_point_source': kernel_large}
kwargs_psf = {'psf_type': "PIXEL", 'kernel_point_source': kernel_large}
elif psf_type == 'NONE':
kwargs_psf = {'psf_type': 'NONE'}
else:
raise ValueError("psf type %s not supported!" % psf_type)
return kwargs_psf
def normalize_flux(self, kwargs_options, kwargs_source, kwargs_lens_light, kwargs_ps, norm_factor_source=1, norm_factor_lens_light=1, norm_factor_point_source=1.):
"""
multiplies the surface brightness amplitudes with a norm_factor
aim: mimic different telescopes photon collection area or colours for different imaging bands
:param kwargs_source:
:param kwargs_lens_light:
:param norm_factor:
:return:
"""
lensLightModel = LightModel(kwargs_options.get('lens_light_model_list', []))
sourceModel = LightModel(kwargs_options.get('source_light_model_list', []))
lensModel = LensModel(lens_model_list=kwargs_options.get('lens_model_list', []))
pointSource = PointSource(point_source_type_list=kwargs_options.get('point_source_list', []),
lensModel=lensModel, fixed_magnification_list=kwargs_options.get('fixed_magnification_list', [False]),
additional_images_list=kwargs_options.get('additional_images_list', [False]))
kwargs_source_updated = copy.deepcopy(kwargs_source)
kwargs_lens_light_updated = copy.deepcopy(kwargs_lens_light)
kwargs_ps_updated = copy.deepcopy(kwargs_ps)
kwargs_source_updated = sourceModel.re_normalize_flux(kwargs_source_updated, norm_factor_source)
kwargs_lens_light_updated = lensLightModel.re_normalize_flux(kwargs_lens_light_updated, norm_factor_lens_light)
kwargs_ps_updated = pointSource.re_normalize_flux(kwargs_ps_updated, norm_factor_point_source)
return kwargs_source_updated, kwargs_lens_light_updated, kwargs_ps_updated
def normalize_flux_source(self, kwargs_options, kwargs_source, norm_factor_source):
"""
normalized the flux of the source
:param kwargs_options:
:param kwargs_source:
:param norm_factor_source:
:return:
"""
kwargs_source_updated = copy.deepcopy(kwargs_source)
sourceModel = LightModel(kwargs_options.get('source_light_model_list', []))
kwargs_source_updated = sourceModel.re_normalize_flux(kwargs_source_updated, norm_factor_source)
return kwargs_source_updated
def simulate(self, image_model_class, kwargs_lens=None, kwargs_source=None, kwargs_lens_light=None, kwargs_ps=None,
no_noise=False, source_add=True, lens_light_add=True, point_source_add=True):
"""
simulate image
:param kwargs_options:
:param kwargs_data:
:param kwargs_psf:
:param kwargs_lens:
:param kwargs_source:
:param kwargs_lens_light:
:param kwargs_ps:
:param no_noise:
:return:
"""
image = image_model_class.image(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps, source_add=source_add, lens_light_add=lens_light_add, point_source_add=point_source_add)
# add noise
if no_noise:
return image
else:
poisson = image_util.add_poisson(image, exp_time=image_model_class.Data.exposure_map)
bkg = image_util.add_background(image, sigma_bkd=image_model_class.Data.background_rms)
return image + bkg + poisson
def source_plane(self, kwargs_options, kwargs_source, numPix, deltaPix):
"""
source plane simulation
:param kwargs_options:
:param kwargs_source:
:param numPix:
:param deltaPix:
:return:
"""
x, y = util.make_grid(numPix, deltaPix)
sourceModel = LightModel(kwargs_options.get('source_light_model_list', []))
image1d = sourceModel.surface_brightness(x, y, kwargs_source)
image2d = util.array2image(image1d)
return image2d
def __init__(self):
self.gaussian = Gaussian()
class TestGaussianKappa(object):
"""
test the Gaussian with Gaussian kappa
"""
def setup(self):
self.gaussian_kappa = GaussianKappa()
self.gaussian = Gaussian()
def test_derivatives(self):
x = np.linspace(0, 5, 10)
y = np.linspace(0, 5, 10)
amp = 1. * 2 * np.pi
center_x = 0.
center_y = 0.
sigma = 1.
f_x, f_y = self.gaussian_kappa.derivatives(x, y, amp, sigma, center_x,
center_y)
npt.assert_almost_equal(f_x[2], 0.63813558702212059, decimal=8)
npt.assert_almost_equal(f_y[2], 0.63813558702212059, decimal=8)
def test_hessian(self):
x = np.linspace(0, 5, 10)
y = np.linspace(0, 5, 10)
amp = 1. * 2 * np.pi
center_x = 0.
center_y = 0.
sigma = 1.
f_xx, f_yy, f_xy = self.gaussian_kappa.hessian(x, y, amp, sigma,
center_x, center_y)
kappa = 1. / 2 * (f_xx + f_yy)
kappa_true = self.gaussian.function(x, y, amp, sigma, sigma, center_x,
center_y)
print(kappa_true)
print(kappa)
npt.assert_almost_equal(kappa[0], kappa_true[0], decimal=5)
npt.assert_almost_equal(kappa[1], kappa_true[1], decimal=5)
def test_density_2d(self):
x = np.linspace(0, 5, 10)
y = np.linspace(0, 5, 10)
amp = 1. * 2 * np.pi
center_x = 0.
center_y = 0.
sigma = 1.
f_xx, f_yy, f_xy = self.gaussian_kappa.hessian(x, y, amp, sigma,
center_x, center_y)
kappa = 1. / 2 * (f_xx + f_yy)
amp_3d = self.gaussian_kappa._amp2d_to_3d(amp, sigma, sigma)
density_2d = self.gaussian_kappa.density_2d(x, y, amp_3d, sigma,
center_x, center_y)
npt.assert_almost_equal(kappa[1], density_2d[1], decimal=5)
npt.assert_almost_equal(kappa[2], density_2d[2], decimal=5)
def test_3d_2d_convention(self):
x = np.linspace(0, 5, 10)
y = np.linspace(0, 5, 10)
amp = 1. * 2 * np.pi
center_x = 0.
center_y = 0.
sigma = 1.
amp_3d = self.gaussian_kappa._amp2d_to_3d(amp, sigma, sigma)
density_2d_gauss = self.gaussian_kappa.density_2d(
x, y, amp_3d, sigma, center_x, center_y)
density_2d = self.gaussian.function(x, y, amp, sigma, sigma, center_x,
center_y)
npt.assert_almost_equal(density_2d_gauss[1], density_2d[1], decimal=5)
def setup(self):
self.gaussian_kappa = GaussianKappa()
self.gaussian = Gaussian()
class TestGaussian(object):
"""
tests the Gaussian methods
"""
def setup(self):
self.Gaussian = Gaussian()
def test_function(self):
x = 1
y = 2
amp = 1. * 2 * np.pi
center_x = 1.
center_y = 1.
sigma_x = 1.
sigma_y = 1.
values = self.Gaussian.function(x, y, amp, center_x, center_y, sigma_x,
sigma_y)
assert values == np.exp(-1. / 2)
x = np.array([2, 3, 4])
y = np.array([1, 1, 1])
values = self.Gaussian.function(x, y, amp, center_x, center_y, sigma_x,
sigma_y)
assert values[0] == np.exp(-1. / 2)
assert values[1] == np.exp(-2.**2 / 2)
assert values[2] == np.exp(-3.**2 / 2)
def test_derivatives(self):
x = 1
y = 2
amp = 1. * 2 * np.pi
center_x = 1.
center_y = 1.
sigma_x = 1.
sigma_y = 1.
values = self.Gaussian.derivatives(x, y, amp, center_x, center_y,
sigma_x, sigma_y)
assert values[0] == 0.
assert values[1] == -np.exp(-1. / 2)
x = np.array([2, 3, 4])
y = np.array([1, 1, 1])
values = self.Gaussian.derivatives(x, y, amp, center_x, center_y,
sigma_x, sigma_y)
assert values[0][0] == -np.exp(-1. / 2)
assert values[1][0] == 0.
assert values[0][1] == -2 * np.exp(-2.**2 / 2)
assert values[1][1] == 0.
def test_hessian(self):
x = 1
y = 2
amp = 1. * 2 * np.pi
center_x = 1.
center_y = 1.
sigma_x = 1.
sigma_y = 1.
values = self.Gaussian.hessian(x, y, amp, center_x, center_y, sigma_x,
sigma_y)
assert values[0] == -np.exp(-1. / 2)
assert values[1] == 0.
assert values[2] == 0.
x = np.array([2, 3, 4])
y = np.array([1, 1, 1])
values = self.Gaussian.hessian(x, y, amp, center_x, center_y, sigma_x,
sigma_y)
assert values[0][0] == 0.
assert values[1][0] == -np.exp(-1. / 2)
assert values[2][0] == 0.
assert values[0][1] == 0.40600584970983811
assert values[1][1] == -0.1353352832366127
assert values[2][1] == 0.
def setup(self):
self.Gaussian = Gaussian()
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)
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 __init__(self):
self.gaussian = Gaussian()
self.ds = 0.00001
super(LensProfileBase, self).__init__()
class GaussianKappa(LensProfileBase):
"""
this class contains functions to evaluate a Gaussian function and calculates its derivative and hessian matrix
"""
param_names = ['amp', 'sigma', 'center_x', 'center_y']
lower_limit_default = {'amp': 0, 'sigma': 0, 'center_x': -100, 'center_y': -100}
upper_limit_default = {'amp': 100, 'sigma': 100, 'center_x': 100, 'center_y': 100}
def __init__(self):
self.gaussian = Gaussian()
self.ds = 0.00001
super(LensProfileBase, self).__init__()
def function(self, x, y, amp, sigma, center_x=0, center_y=0):
"""
returns Gaussian
"""
x_ = x - center_x
y_ = y - center_y
r = np.sqrt(x_**2 + y_**2)
sigma_x, sigma_y = sigma, sigma
c = 1. / (2 * sigma_x * sigma_y)
if isinstance(x_, int) or isinstance(x_, float):
num_int = self._num_integral(r, c)
else:
num_int = []
for i in range(len(x_)):
num_int.append(self._num_integral(r[i], c))
num_int = np.array(num_int)
amp_density = self._amp2d_to_3d(amp, sigma_x, sigma_y)
amp2d = amp_density / (np.sqrt(np.pi) * np.sqrt(sigma_x * sigma_y * 2))
amp2d *= 2 * 1. / (2 * c)
return num_int * amp2d
def _num_integral(self, r, c):
"""
numerical integral (1-e^{-c*x^2})/x dx [0..r]
:param r: radius
:param c: 1/2sigma^2
:return:
"""
out = integrate.quad(lambda x: (1-np.exp(-c*x**2))/x, 0, r)
return out[0]
def derivatives(self, x, y, amp, sigma, center_x=0, center_y=0):
"""
returns df/dx and df/dy of the function
"""
x_ = x - center_x
y_ = y - center_y
R = np.sqrt(x_**2 + y_**2)
sigma_x, sigma_y = sigma, sigma
if isinstance(R, int) or isinstance(R, float):
R = max(R, self.ds)
else:
R[R <= self.ds] = self.ds
alpha = self.alpha_abs(R, amp, sigma)
return alpha / R * x_, alpha / R * y_
def hessian(self, x, y, amp, sigma, center_x=0, center_y=0):
"""
returns Hessian matrix of function d^2f/dx^2, d^f/dy^2, d^2/dxdy
"""
x_ = x - center_x
y_ = y - center_y
r = np.sqrt(x_**2 + y_**2)
sigma_x, sigma_y = sigma, sigma
if isinstance(r, int) or isinstance(r, float):
r = max(r, self.ds)
else:
r[r <= self.ds] = self.ds
d_alpha_dr = -self.d_alpha_dr(r, amp, sigma_x, sigma_y)
alpha = self.alpha_abs(r, amp, sigma)
f_xx = -(d_alpha_dr/r + alpha/r**2) * x_**2/r + alpha/r
f_yy = -(d_alpha_dr/r + alpha/r**2) * y_**2/r + alpha/r
f_xy = -(d_alpha_dr/r + alpha/r**2) * x_*y_/r
return f_xx, f_yy, f_xy
def density(self, r, amp, sigma):
"""
:param r:
:param amp:
:param sigma:
:return:
"""
sigma_x, sigma_y = sigma, sigma
return self.gaussian.function(r, 0, amp, sigma_x, sigma_y)
def density_2d(self, x, y, amp, sigma, center_x=0, center_y=0):
"""
:param R:
:param am:
:param sigma_x:
:param sigma_y:
:return:
"""
sigma_x, sigma_y = sigma, sigma
amp2d = self._amp3d_to_2d(amp, sigma_x, sigma_y)
return self.gaussian.function(x, y, amp2d, sigma_x, sigma_y, center_x, center_y)
def mass_2d(self, R, amp, sigma):
"""
:param R:
:param amp:
:param sigma_x:
:param sigma_y:
:return:
"""
sigma_x, sigma_y = sigma, sigma
amp2d = amp / (np.sqrt(np.pi) * np.sqrt(sigma_x * sigma_y * 2))
c = 1./(2 * sigma_x * sigma_y)
return amp2d * 2 * np.pi * 1./(2*c) * (1. - np.exp(-c * R**2))
def mass_2d_lens(self, R, amp, sigma):
"""
:param R:
:param amp:
:param sigma_x:
:param sigma_y:
:return:
"""
sigma_x, sigma_y = sigma, sigma
amp_density = self._amp2d_to_3d(amp, sigma_x, sigma_y)
return self.mass_2d(R, amp_density, sigma)
def alpha_abs(self, R, amp, sigma):
"""
absolute value of the deflection
:param R:
:param amp:
:param sigma_x:
:param sigma_y:
:return:
"""
sigma_x, sigma_y = sigma, sigma
amp_density = self._amp2d_to_3d(amp, sigma_x, sigma_y)
alpha = self.mass_2d(R, amp_density, sigma) / np.pi / R
return alpha
def d_alpha_dr(self, R, amp, sigma_x, sigma_y):
"""
:param R:
:param amp:
:param sigma_x:
:param sigma_y:
:return:
"""
c = 1. / (2 * sigma_x * sigma_y)
A = self._amp2d_to_3d(amp, sigma_x, sigma_y) * np.sqrt(2/np.pi*sigma_x*sigma_y)
return 1./R**2 * (-1 + (1 + 2*c*R**2) * np.exp(-c*R**2)) * A
def mass_3d(self, R, amp, sigma):
"""
:param R:
:param amp:
:param sigma_x:
:param sigma_y:
:return:
"""
sigma_x, sigma_y = sigma, sigma
A = amp / (2 * np.pi * sigma_x * sigma_y)
c = 1. / (2 * sigma_x * sigma_y)
result = 1. /(2*c) * (-R * np.exp(-c*R**2) + scipy.special.erf(np.sqrt(c) * R) * np.sqrt(np.pi/(4 * c)))
return result*A * 4 * np.pi
def mass_3d_lens(self, R, amp, sigma):
"""
:param R:
:param amp:
:param sigma_x:
:param sigma_y:
:return:
"""
sigma_x, sigma_y = sigma, sigma
amp_density = self._amp2d_to_3d(amp, sigma_x, sigma_y)
return self.mass_3d(R, amp_density, sigma)
def _amp3d_to_2d(self, amp, sigma_x, sigma_y):
"""
converts 3d density into 2d density parameter
:param amp:
:param sigma_x:
:param sigma_y:
:return:
"""
return amp * np.sqrt(np.pi) * np.sqrt(sigma_x * sigma_y * 2)
def _amp2d_to_3d(self, amp, sigma_x, sigma_y):
"""
converts 3d density into 2d density parameter
:param amp:
:param sigma_x:
:param sigma_y:
:return:
"""
return amp / (np.sqrt(np.pi) * np.sqrt(sigma_x * sigma_y * 2))
def __init__(self):
self.gaussian = Gaussian()
self.ds = 0.00001