def test_update_lens_model(self):
lensModel = LensModel(lens_model_list=['SIS'])
self.PointSource.update_lens_model(lens_model_class=lensModel)
kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}]
x_image_list, y_image_list = self.PointSource.image_position(kwargs_ps=self.kwargs_ps,
kwargs_lens=kwargs_lens)
npt.assert_almost_equal(x_image_list[0][0], -0.82654997748011705 , decimal=8)
def test_spep_sis(self):
lens_model_list = ['SPEP', 'SIS']
lensModel = LensModel(lens_model_list)
lensEquationSolver = LensEquationSolver(lensModel)
sourcePos_x = 0.1
sourcePos_y = -0.1
min_distance = 0.05
search_window = 10
gamma = 1.9
kwargs_lens = [{
'theta_E': 1.,
'gamma': gamma,
'q': 0.8,
'phi_G': 0.5,
'center_x': 0.1,
'center_y': -0.1
}, {
'theta_E': 0.1,
'center_x': 0.5,
'center_y': 0
}]
x_pos, y_pos = lensEquationSolver.image_position_from_source(
sourcePos_x,
sourcePos_y,
kwargs_lens,
min_distance=min_distance,
search_window=search_window,
precision_limit=10**(-10),
num_iter_max=10)
source_x, source_y = lensModel.ray_shooting(x_pos, y_pos, kwargs_lens)
npt.assert_almost_equal(sourcePos_x, source_x, decimal=10)
def create_image_model(kwargs_data, kwargs_psf, kwargs_numerics, kwargs_model):
"""
:param kwargs_data:
:param kwargs_psf:
:param kwargs_options:
:return:
"""
data_class = Data(kwargs_data)
psf_class = PSF(kwargs_psf)
lens_model_class = LensModel(
lens_model_list=kwargs_model.get('lens_model_list', []),
z_source=kwargs_model.get('z_source', None),
redshift_list=kwargs_model.get('redshift_list', None),
multi_plane=kwargs_model.get('multi_plane', False))
source_model_class = LightModel(
light_model_list=kwargs_model.get('source_light_model_list', []))
lens_light_model_class = LightModel(
light_model_list=kwargs_model.get('lens_light_model_list', []))
point_source_class = PointSource(
point_source_type_list=kwargs_model.get('point_source_model_list', []),
lensModel=lens_model_class,
fixed_magnification_list=kwargs_model.get('fixed_magnification_list',
None),
additional_images_list=kwargs_model.get('additional_images_list',
None),
min_distance=kwargs_model.get('min_distance', 0.01),
search_window=kwargs_model.get('search_window', 5),
precision_limit=kwargs_model.get('precision_limit', 10**(-10)),
num_iter_max=kwargs_model.get('num_iter_max', 100))
imageModel = ImageModel(data_class, psf_class, lens_model_class,
source_model_class, lens_light_model_class,
point_source_class, kwargs_numerics)
return imageModel
def test_point_source(self):
pointSource = PointSource(point_source_type_list=['SOURCE_POSITION'],
fixed_magnification_list=[True])
kwargs_ps = [{'source_amp': 1000, 'ra_source': 0.1, 'dec_source': 0.1}]
lensModel = LensModel(lens_model_list=['SIS'])
kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}]
numPix = 64
deltaPix = 0.13
kwargs_data = sim_util.data_configure_simple(numPix,
deltaPix,
exposure_time=1,
sigma_bkg=1)
data_class = Data(kwargs_data)
psf_type = "GAUSSIAN"
fwhm = 0.9
kwargs_psf = {'psf_type': psf_type, 'fwhm': fwhm}
psf_class = PSF(kwargs_psf)
imageModel = ImageModel(data_class=data_class,
psf_class=psf_class,
lens_model_class=lensModel,
point_source_class=pointSource)
image = imageModel.image(kwargs_lens=kwargs_lens, kwargs_ps=kwargs_ps)
assert np.sum(image) > 0
def get_cored_image(self, lens_info, src_light_info, z_lens, z_src,
bulge_or_disk):
"""Render a lensed cored sersic
Note
----
This method is only used to test the total magnification computation
"""
lens_mass_model = LensModel([
'SIE',
'SHEAR_GAMMA_PSI',
],
cosmo=self.cosmo,
z_lens=z_lens,
z_source=z_src)
lens_mass_kwargs = get_lens_params(lens_info,
z_src=z_src,
cosmo=self.cosmo)
src_light_kwargs = get_cored_sersic_params(src_light_info,
bulge_or_disk=bulge_or_disk)
img, img_features = generate_image(lens_mass_kwargs, src_light_kwargs,
self.null_psf, self.data_api,
lens_mass_model,
self.cored_sersic_model)
img /= np.max(img)
return img, img_features
def get_image(self, lens_info, src_light_info, z_lens, z_src,
bulge_or_disk):
lens_mass_model = LensModel([
'SIE',
'SHEAR_GAMMA_PSI',
],
cosmo=self.cosmo,
z_lens=z_lens,
z_source=z_src)
lens_mass_kwargs = get_lens_params(lens_info,
z_src=z_src,
cosmo=self.cosmo)
src_light_kwargs = get_src_light_params(src_light_info,
bulge_or_disk=bulge_or_disk)
img, img_features = generate_image(lens_mass_kwargs, src_light_kwargs,
self.null_psf, self.data_api,
lens_mass_model,
self.src_light_model)
img /= np.max(img)
dmag = -2.5 * np.log10(img_features['total_magnification'])
img_features['magnorms'] = {
band: src_light_info[f'magnorm_{bulge_or_disk}_{band}'] + dmag
for band in self.bands
}
return img, img_features
def test_example(self):
lens_model_list = ['SPEP', 'SHEAR']
lensModel = LensModel(lens_model_list)
lensEquationSolver = LensEquationSolver(lensModel)
sourcePos_x = 0.03
sourcePos_y = 0.0
min_distance = 0.05
search_window = 10
gamma = 2.
e1, e2 = -0.04, -0.1
kwargs_shear = {'e1': e1, 'e2': e2} # shear values to the source plane
kwargs_spemd = {'theta_E': 1., 'gamma': gamma, 'center_x': 0.0, 'center_y': 0.0, 'e1': 0.01,
'e2': 0.05} # parameters of the deflector lens model
kwargs_lens = [kwargs_spemd, kwargs_shear]
x_pos, y_pos = lensEquationSolver.image_position_from_source(sourcePos_x, sourcePos_y, kwargs_lens,
min_distance=min_distance,
search_window=search_window,
precision_limit=10 ** (-10), num_iter_max=10,
arrival_time_sort=True)
x_pos_stoch, y_pos_stoch = lensEquationSolver.image_position_stochastic(sourcePos_x, sourcePos_y, kwargs_lens,
search_window=search_window,
precision_limit=10 ** (-10),
arrival_time_sort=True, x_center=0,
y_center=0, num_random=100,
verbose=False
)
assert len(x_pos) == 4
assert len(x_pos_stoch) == 4
npt.assert_almost_equal(x_pos, x_pos_stoch, decimal=5)
def test_multi_gaussian_lens(self):
kwargs_options = {'lens_model_list': ['SPEP']}
lensModel = LensModel(**kwargs_options)
lensAnalysis = LensProfileAnalysis(lens_model=lensModel)
e1, e2 = param_util.phi_q2_ellipticity(0, 0.9)
kwargs_lens = [{
'gamma': 1.8,
'theta_E': 0.6,
'e1': e1,
'e2': e2,
'center_x': 0.5,
'center_y': -0.1
}]
amplitudes, sigmas, center_x, center_y = lensAnalysis.multi_gaussian_lens(
kwargs_lens, n_comp=20)
model = MultiGaussianKappa()
x = np.logspace(-2, 0.5, 10) + 0.5
y = np.zeros_like(x) - 0.1
f_xx, fxy, fyx, f_yy = model.hessian(x,
y,
amplitudes,
sigmas,
center_x=0.5,
center_y=-0.1)
kappa_mge = (f_xx + f_yy) / 2
kappa_true = lensAnalysis._lens_model.kappa(x, y, kwargs_lens)
print(kappa_true / kappa_mge)
for i in range(len(x)):
npt.assert_almost_equal(kappa_mge[i] / kappa_true[i], 1, decimal=1)
def test_curved_arc_estimate(self):
lens_model_list = ['SPP']
lens = LensModel(lens_model_list=lens_model_list)
arc = LensModel(lens_model_list=['CURVED_ARC_SPP'])
theta_E = 4
gamma = 2.
kwargs_lens = [{
'theta_E': theta_E,
'gamma': gamma,
'center_x': 0,
'center_y': 0
}]
ext = LensModelExtensions(lensModel=lens)
x_0, y_0 = 5, 0
kwargs_arc = ext.curved_arc_estimate(x_0, y_0, kwargs_lens)
theta_E_arc, gamma_arc, center_x_spp_arc, center_y_spp_arc = CurvedArcSPP.stretch2spp(
**kwargs_arc)
npt.assert_almost_equal(theta_E_arc, theta_E, decimal=4)
npt.assert_almost_equal(gamma_arc, gamma, decimal=3)
npt.assert_almost_equal(center_x_spp_arc, 0, decimal=3)
npt.assert_almost_equal(center_y_spp_arc, 0, decimal=3)
x, y = util.make_grid(numPix=10, deltapix=1)
alpha_x, alpha_y = lens.alpha(x, y, kwargs_lens)
alpha0_x, alpha0_y = lens.alpha(x_0, y_0, kwargs_lens)
alpha_x_arc, alpha_y_arc = arc.alpha(x, y, [kwargs_arc])
npt.assert_almost_equal(alpha_x_arc, alpha_x - alpha0_x, decimal=3)
npt.assert_almost_equal(alpha_y_arc, alpha_y - alpha0_y, decimal=3)
x_0, y_0 = 0., 3
kwargs_arc = ext.curved_arc_estimate(x_0, y_0, kwargs_lens)
theta_E_arc, gamma_arc, center_x_spp_arc, center_y_spp_arc = CurvedArcSPP.stretch2spp(
**kwargs_arc)
print(kwargs_arc)
print(theta_E_arc, gamma_arc, center_x_spp_arc, center_y_spp_arc)
npt.assert_almost_equal(theta_E_arc, theta_E, decimal=4)
npt.assert_almost_equal(gamma_arc, gamma, decimal=3)
npt.assert_almost_equal(center_x_spp_arc, 0, decimal=3)
npt.assert_almost_equal(center_y_spp_arc, 0, decimal=3)
x_0, y_0 = -2, -3
kwargs_arc = ext.curved_arc_estimate(x_0, y_0, kwargs_lens)
theta_E_arc, gamma_arc, center_x_spp_arc, center_y_spp_arc = CurvedArcSPP.stretch2spp(
**kwargs_arc)
npt.assert_almost_equal(theta_E_arc, theta_E, decimal=4)
npt.assert_almost_equal(gamma_arc, gamma, decimal=3)
npt.assert_almost_equal(center_x_spp_arc, 0, decimal=3)
npt.assert_almost_equal(center_y_spp_arc, 0, decimal=3)
def __init__(self, x_image, y_image, z_lens, z_source, lens_model_list, redshift_list,
astropy_instance, param_class, foreground_rays,
tol_source=1e-5, numerical_alpha_class=None):
"""
:param x_image: x_image to fit
:param y_image: y_image to fit
:param z_lens: lens redshift
:param z_source: source redshift
:param lens_model_list: list of lens models
:param redshift_list: list of lens redshifts
:param astropy_instance: instance of astropy to pass to lens model
:param param_class: an instance of ParamClass (see documentation in QuadOptimmizer.param_manager)
:param foreground_rays: (optional) pre-computed foreground rays from a previous iteration, if they are not specified
they will be re-computed
:param tol_source: source plane chi^2 sigma
:param numerical_alpha_class: class for computing numerically tabulated deflection angles
"""
self.lensModel = LensModel(lens_model_list, z_lens, z_source, redshift_list, astropy_instance,
multi_plane=True, numerical_alpha_class=numerical_alpha_class)
lensmodel_list_to_vary = lens_model_list[0:param_class.to_vary_index]
redshift_list_to_vary = redshift_list[0:param_class.to_vary_index]
lensmodel_list_fixed = lens_model_list[param_class.to_vary_index:]
redshift_list_fixed = redshift_list[param_class.to_vary_index:]
self.lens_model_to_vary = LensModel(lensmodel_list_to_vary, z_lens, z_source, redshift_list_to_vary,
cosmo=astropy_instance, multi_plane=True,
numerical_alpha_class=numerical_alpha_class)
self.lens_model_fixed = LensModel(lensmodel_list_fixed, z_lens, z_source, redshift_list_fixed,
cosmo=astropy_instance, multi_plane=True,
numerical_alpha_class=numerical_alpha_class)
self._z_lens = z_lens
self._z_source = z_source
self._x_image = x_image
self._y_image = y_image
self._param_class = param_class
self._tol_source = tol_source
self._foreground_rays = foreground_rays
def test_critical_curves_tiling(self):
lens_model_list = ['SPEP']
phi, q = 1., 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_lens = [{'theta_E': 1., 'gamma': 2., 'e1': e1, 'e2': e2, 'center_x': 0, 'center_y': 0}]
lensModel = LensModelExtensions(LensModel(lens_model_list))
ra_crit, dec_crit = lensModel.critical_curve_tiling(kwargs_lens, compute_window=5, start_scale=0.01, max_order=10)
npt.assert_almost_equal(ra_crit[0], -0.5355208333333333, decimal=5)
def test_update_lens_model(self):
self.base.update_lens_model(lens_model_class=None)
assert self.base._solver is None
base = PSBase()
base.update_lens_model(lens_model_class=LensModel(lens_model_list=['SIS']))
assert base._solver is not None
PSBase(fixed_magnification=True, additional_image=True)
def test_subtract(self):
lensModel = LensModel(['SPEP'])
solver_spep_center = Solver2Point(lensModel, solver_type='CENTER')
x_cat = np.array([0, 0])
y_cat = np.array([1, 2])
a = solver_spep_center._subtract_constraint(x_cat, y_cat)
assert a[0] == 0
assert a[1] == 1
def setup(self):
lens_model = LensModel(lens_model_list=['SIS'])
self.kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}]
self.ps_mag = LensedPositions(lens_model=lens_model, fixed_magnification=True)
self.ps = LensedPositions(lens_model=lens_model, fixed_magnification=False)
self.ps_add = LensedPositions(lens_model=lens_model, fixed_magnification=[False], additional_image=True)
self.kwargs = {'point_amp': [2, 1], 'ra_image': [0, 1.2], 'dec_image': [0, 0]}
self.kwargs_mag = {'source_amp': 2, 'ra_image': [0, 1.2], 'dec_image': [0, 0]}
def test_external_shear_direction(self):
lensModel = LensModel(lens_model_list=['SHEAR'])
kwargs_lens = [{'e1': 0.1, 'e2': -0.1}, {'e1': 0.1, 'e2': -0.1}]
f, ax = output_plots.ext_shear_direction(data_class=self.data_class,
lens_model_class=lensModel,
kwargs_lens=kwargs_lens,
strength_multiply=10)
plt.close()
def test_solver_nfw(self):
lens_model_list = ['NFW_ELLIPSE', 'SIS']
lensModel = LensModel(lens_model_list)
solver = Solver4Point(lensModel)
lensEquationSolver = LensEquationSolver(lensModel)
sourcePos_x = 0.1
sourcePos_y = -0.1
deltapix = 0.05
numPix = 150
Rs = 4.
phi_G, q = 0.5, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_lens = [{
'theta_Rs': 1.,
'Rs': Rs,
'e1': e1,
'e2': e2,
'center_x': 0.1,
'center_y': -0.1
}, {
'theta_E': 1,
'center_x': 0,
'center_y': 0
}]
x_pos, y_pos = lensEquationSolver.findBrightImage(
sourcePos_x,
sourcePos_y,
kwargs_lens,
numImages=4,
min_distance=deltapix,
search_window=numPix * deltapix)
phi_G, q = 1.5, 0.9
e1, e2 = param_util.phi_q2_ellipticity(phi_G, q)
kwargs_lens_init = [{
'theta_Rs': 0.5,
'Rs': Rs,
'e1': e1,
'e2': e2,
'center_x': 0.,
'center_y': 0
}, kwargs_lens[1]]
kwargs_lens_new, accuracy = solver.constraint_lensmodel(
x_pos, y_pos, kwargs_lens_init)
npt.assert_almost_equal(kwargs_lens_new[0]['theta_Rs'],
kwargs_lens[0]['theta_Rs'],
decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['e1'],
kwargs_lens[0]['e1'],
decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['e2'],
kwargs_lens[0]['e2'],
decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['center_x'],
kwargs_lens[0]['center_x'],
decimal=3)
npt.assert_almost_equal(kwargs_lens_new[0]['center_y'],
kwargs_lens[0]['center_y'],
decimal=3)
def setup(self):
lens_model_list = ['SPEP', 'SHEAR']
lensModel = LensModel(lens_model_list=lens_model_list)
lensModelExtensions = LensModelExtensions(lensModel=lensModel)
lensEquationSolver = LensEquationSolver(lensModel=lensModel)
x_source, y_source = 0.02, 0.01
kwargs_lens = [{
'theta_E': 1.,
'e1': 0.1,
'e2': 0.1,
'gamma': 2.,
'center_x': 0,
'center_y': 0
}, {
'e1': 0.06,
'e2': -0.03
}]
x_img, y_img = lensEquationSolver.image_position_from_source(
kwargs_lens=kwargs_lens,
sourcePos_x=x_source,
sourcePos_y=y_source)
print('image positions are: ', x_img, y_img)
mag_inf = lensModel.magnification(x_img, y_img, kwargs_lens)
print('point source magnification: ', mag_inf)
source_size_arcsec = 0.001
window_size = 0.1
grid_number = 100
print('source size in arcsec: ', source_size_arcsec)
mag_finite = lensModelExtensions.magnification_finite(
x_pos=x_img,
y_pos=y_img,
kwargs_lens=kwargs_lens,
source_sigma=source_size_arcsec,
window_size=window_size,
grid_number=grid_number)
flux_ratios = mag_finite[1:] / mag_finite[0]
flux_ratio_errors = [0.1, 0.1, 0.1]
self.flux_likelihood = FluxRatioLikelihood(
lens_model_class=lensModel,
flux_ratios=flux_ratios,
flux_ratio_errors=flux_ratio_errors,
source_type='GAUSSIAN',
window_size=window_size,
grid_number=grid_number)
self.flux_likelihood_inf = FluxRatioLikelihood(
lens_model_class=lensModel,
flux_ratios=flux_ratios,
flux_ratio_errors=flux_ratio_errors,
source_type='INF',
window_size=window_size,
grid_number=grid_number)
self.kwargs_cosmo = {'source_size': source_size_arcsec}
self.x_img, self.y_img = x_img, y_img
self.kwargs_lens = kwargs_lens
def test_shapelet_cart(self):
lens_model_list = ['SHAPELETS_CART', 'SIS']
lens = LensModel(lens_model_list)
solver = Solver2Point(lens, solver_type='SHAPELETS')
image_position = LensEquationSolver(lens)
sourcePos_x = 0.1
sourcePos_y = 0.03
deltapix = 0.05
numPix = 100
kwargs_lens = [{
'coeffs': [1., 0., 0.1, 1.],
'beta': 1.
}, {
'theta_E': 1.,
'center_x': -0.1,
'center_y': 0.1
}]
x_pos, y_pos = image_position.findBrightImage(
sourcePos_x,
sourcePos_y,
kwargs_lens,
numImages=2,
min_distance=deltapix,
search_window=numPix * deltapix,
precision_limit=10**(-10))
print(len(x_pos), 'number of images')
x_pos = x_pos[:2]
y_pos = y_pos[:2]
kwargs_init = [{
'coeffs': [1., 0., 0.1, 1.],
'beta': 1.
}, {
'theta_E': 1.,
'center_x': -0.1,
'center_y': 0.1
}]
kwargs_out, precision = solver.constraint_lensmodel(
x_pos, y_pos, kwargs_init)
print(kwargs_out, 'output')
source_x, source_y = lens.ray_shooting(x_pos[0], y_pos[0], kwargs_out)
x_pos_new, y_pos_new = image_position.findBrightImage(
source_x,
source_y,
kwargs_out,
numImages=2,
min_distance=deltapix,
search_window=numPix * deltapix)
npt.assert_almost_equal(x_pos_new[0], x_pos[0], decimal=3)
npt.assert_almost_equal(y_pos_new[0], y_pos[0], decimal=3)
npt.assert_almost_equal(kwargs_out[0]['coeffs'][1],
kwargs_lens[0]['coeffs'][1],
decimal=3)
npt.assert_almost_equal(kwargs_out[0]['coeffs'][2],
kwargs_lens[0]['coeffs'][2],
decimal=3)
def test_profile_slope(self):
lens_model = LensModelExtensions(LensModel(lens_model_list=['SPP']))
gamma_in = 2.
kwargs_lens = [{
'theta_E': 1.,
'gamma': gamma_in,
'center_x': 0,
'center_y': 0
}]
gamma_out = lens_model.profile_slope(kwargs_lens)
npt.assert_array_almost_equal(gamma_out, gamma_in, decimal=3)
gamma_in = 1.7
kwargs_lens = [{
'theta_E': 1.,
'gamma': gamma_in,
'center_x': 0,
'center_y': 0
}]
gamma_out = lens_model.profile_slope(kwargs_lens)
npt.assert_array_almost_equal(gamma_out, gamma_in, decimal=3)
gamma_in = 2.5
kwargs_lens = [{
'theta_E': 1.,
'gamma': gamma_in,
'center_x': 0,
'center_y': 0
}]
gamma_out = lens_model.profile_slope(kwargs_lens)
npt.assert_array_almost_equal(gamma_out, gamma_in, decimal=3)
lens_model = LensModelExtensions(LensModel(lens_model_list=['SPEP']))
gamma_in = 2.
phi, q = 0.34403343049704888, 0.89760957136967312
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_lens = [{
'theta_E': 1.4516812130749424,
'e1': e1,
'e2': e2,
'center_x': -0.04507598845306314,
'center_y': 0.054491803177414651,
'gamma': gamma_in
}]
gamma_out = lens_model.profile_slope(kwargs_lens)
npt.assert_array_almost_equal(gamma_out, gamma_in, decimal=3)
def test_assertions(self):
lensModel = LensModel(['SPEP'])
lensEquationSolver = LensEquationSolver(lensModel)
kwargs_lens = [{
'theta_E': 1,
'gamma': 2,
'e1': 0.2,
'e2': -0.03,
'center_x': 0,
'center_y': 0
}]
with pytest.raises(ValueError):
lensEquationSolver.image_position_from_source(0.1,
0.,
kwargs_lens,
solver='analytical')
lensModel = LensModel(['EPL_NUMBA', 'SHEAR'])
lensEquationSolver = LensEquationSolver(lensModel)
kwargs_lens = [{
'theta_E': 1.,
'gamma': 2.2,
'center_x': 0.0,
'center_y': 0.0,
'e1': 0.01,
'e2': 0.05
}, {
'gamma1': -0.04,
'gamma2': -0.1,
'ra_0': 0.0,
'dec_0': 0.0
}]
with pytest.raises(ValueError):
lensEquationSolver.image_position_from_source(0.1,
0.,
kwargs_lens,
solver='nonexisting')
with pytest.raises(ValueError):
kwargs_lens[1]['ra_0'] = 0.1
lensEquationSolver.image_position_from_source(0.1,
0.,
kwargs_lens,
solver='analytical')
def test_position_convention(self):
lens_model_list = ['SIS', 'SIS','SIS', 'SIS']
redshift_list = [0.5, 0.5, 0.9, 0.6]
kwargs_lens = [{'theta_E': 1, 'center_x':0, 'center_y': 0},
{'theta_E': 0.4, 'center_x': 0, 'center_y': 0.2},
{'theta_E': 1, 'center_x': 1.8, 'center_y': -0.4},
{'theta_E': 0.41, 'center_x': 1., 'center_y': 0.7}]
index_list = [[2,3], [3,2]]
# compute the physical position given lensed position, and check that lensing computations
# using the two different conventions and sets of kwargs agree
for index in index_list:
lensModel_observed = LensModel(lens_model_list=lens_model_list, multi_plane=True,
observed_convention_index=index, z_source=1.5,
lens_redshift_list=redshift_list)
lensModel_physical = LensModel(lens_model_list=lens_model_list, multi_plane=True,
z_source=1.5, lens_redshift_list=redshift_list)
multi = lensModel_observed.lens_model._multi_plane_base
lensed, phys = LensedLocation(multi, index), PhysicalLocation()
kwargs_lens_physical = lensModel_observed.lens_model._convention(kwargs_lens)
kwargs_phys, kwargs_lensed = phys(kwargs_lens), lensed(kwargs_lens)
for j, lensed_kwargs in enumerate(kwargs_lensed):
for ki in lensed_kwargs.keys():
assert lensed_kwargs[ki] == kwargs_lens_physical[j][ki]
assert kwargs_phys[j][ki] == kwargs_lens[j][ki]
fxx, fyy, fxy, fyx = lensModel_observed.hessian(0.5, 0.5, kwargs_lens)
fxx2, fyy2, fxy2, fyx2 = lensModel_physical.hessian(0.5, 0.5, kwargs_lens_physical)
npt.assert_almost_equal(fxx, fxx2)
npt.assert_almost_equal(fxy, fxy2)
betax1, betay1 = lensModel_observed.ray_shooting(0.5, 0.5, kwargs_lens)
betax2, betay2 = lensModel_physical.ray_shooting(0.5, 0.5, kwargs_lens_physical)
npt.assert_almost_equal(betax1, betax2)
npt.assert_almost_equal(betay1, betay2)
def setup(self):
lens_model = LensModel(lens_model_list=['SIS'])
self.kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}]
self.ps_mag = SourcePositions(lens_model=lens_model,
fixed_magnification=True)
self.ps = SourcePositions(lens_model=lens_model,
fixed_magnification=False)
self.kwargs = {'point_amp': [2, 1], 'ra_source': 0.1, 'dec_source': 0}
self.kwargs_mag = {'source_amp': 1, 'ra_source': 0.1, 'dec_source': 0}
def test_image_position(self):
x_img, y_img = self.ps.image_position(self.kwargs, self.kwargs_lens)
lens_model = LensModel(lens_model_list=['SIS'])
x_src, y_src = lens_model.ray_shooting(x_img,
y_img,
kwargs=self.kwargs_lens)
npt.assert_almost_equal(x_src, self.kwargs['ra_source'])
npt.assert_almost_equal(y_src, self.kwargs['dec_source'])
def test_flexion(self):
lensModel = LensModel(lens_model_list=['FLEXION'])
g1, g2, g3, g4 = 0.01, 0.02, 0.03, 0.04
kwargs = [{'g1': g1, 'g2': g2, 'g3': g3, 'g4': g4}]
f_xxx, f_xxy, f_xyy, f_yyy = lensModel.flexion(x=1., y=1., kwargs=kwargs)
npt.assert_almost_equal(f_xxx, g1, decimal=8)
npt.assert_almost_equal(f_xxy, g2, decimal=8)
npt.assert_almost_equal(f_xyy, g3, decimal=8)
npt.assert_almost_equal(f_yyy, g4, decimal=8)
def test_magnification(self):
ra_0, dec_0 = 1, -1
flex = LensModel(['FLEXION'])
g1, g2, g3, g4 = 0.01, 0.02, 0.03, 0.04
kwargs = {'g1': g1, 'g2': g2, 'g3': g3, 'g4': g4, 'ra_0': ra_0, 'dec_0': dec_0}
mag = flex.magnification(ra_0, dec_0, [kwargs])
npt.assert_almost_equal(mag, 1, decimal=8)
def test_flexion(self):
x = np.array(0)
y = np.array(2)
flex = LensModel(['FLEXION'])
f_xxx, f_xxy, f_xyy, f_yyy = flex.flexion(x, y, [self.kwargs_lens])
npt.assert_almost_equal(f_xxx, self.kwargs_lens['g1'], decimal=9)
npt.assert_almost_equal(f_xxy, self.kwargs_lens['g2'], decimal=9)
npt.assert_almost_equal(f_xyy, self.kwargs_lens['g3'], decimal=9)
npt.assert_almost_equal(f_yyy, self.kwargs_lens['g4'], decimal=9)
def setup(self):
self.lensModel = LensModel(['GAUSSIAN'])
self.kwargs = [{
'amp': 1.,
'sigma_x': 2.,
'sigma_y': 2.,
'center_x': 0.,
'center_y': 0.
}]
def test_init(self):
lens_model_list = [
'FLEXION', 'SIS_TRUNCATED', 'SERSIC', 'SERSIC_ELLIPSE',
'SERSIC_DOUBLE', 'COMPOSITE', 'PJAFFE', 'PJAFFE_ELLIPSE',
'HERNQUIST_ELLIPSE', 'INTERPOL', 'INTERPOL_SCALED',
'SHAPELETS_POLAR', 'DIPOLE'
]
lensModel = LensModel(lens_model_list)
assert len(lensModel.lens_model_list) == len(lens_model_list)
def assert_differentials(self, lens_model, kwargs, potential=True):
#lensModelNum = NumericLens(lens_model)
diff = 0.000001
#x, y = 1., 2.
x = np.linspace(start=0.1, stop=5.5, num=10)
y = np.zeros_like(x)
lensModel = LensModel(lens_model)
f_xx, f_xy, f_yx, f_yy = lensModel.hessian(x, y, [kwargs])
f_xx_num, f_xy_num, f_yx_num, f_yy_num = lensModel.hessian(x,
y, [kwargs],
diff=diff)
npt.assert_almost_equal(f_xx, f_xx_num, decimal=3)
npt.assert_almost_equal(f_yy, f_yy_num, decimal=3)
npt.assert_almost_equal(f_xy, f_xy_num, decimal=3)
if potential is True:
f_x, f_y = lensModel.alpha(x, y, [kwargs])
f_x_num, f_y_num = lensModel.alpha(x, y, [kwargs], diff=diff)
npt.assert_almost_equal(f_x, f_x_num, decimal=3)
npt.assert_almost_equal(f_y, f_y_num, decimal=3)
y = np.linspace(start=0.1, stop=5.5, num=10)
x = np.zeros_like(y)
lensModel = LensModel(lens_model)
f_xx, f_xy, f_yx, f_yy = lensModel.hessian(x, y, [kwargs])
f_xx_num, f_xy_num, f_yx_num, f_yy_num = lensModel.hessian(x,
y, [kwargs],
diff=diff)
npt.assert_almost_equal(f_xx, f_xx_num, decimal=3)
npt.assert_almost_equal(f_yy, f_yy_num, decimal=3)
npt.assert_almost_equal(f_xy, f_xy_num, decimal=3)
if potential is True:
f_x, f_y = lensModel.alpha(x, y, [kwargs])
f_x_num, f_y_num = lensModel.alpha(x, y, [kwargs], diff=diff)
npt.assert_almost_equal(f_x, f_x_num, decimal=3)
npt.assert_almost_equal(f_y, f_y_num, decimal=3)
def __init__(self,
data_class,
psf_class,
lens_model_class=None,
source_model_class=None,
lens_light_model_class=None,
point_source_class=None,
extinction_class=None,
kwargs_numerics=None):
"""
:param data_class: instance of ImageData() or PixelGrid() class
:param psf_class: instance of PSF() class
:param lens_model_class: instance of LensModel() class
:param source_model_class: instance of LightModel() class describing the source parameters
:param lens_light_model_class: instance of LightModel() class describing the lens light parameters
:param point_source_class: instance of PointSource() class describing the point sources
:param kwargs_numerics: keyword argument with various numeric description (see ImageNumerics class for options)
"""
self.type = 'single-band'
self.PSF = psf_class
self.Data = data_class
self.PSF.set_pixel_size(self.Data.pixel_width)
if kwargs_numerics is None:
kwargs_numerics = {}
self.ImageNumerics = NumericsSubFrame(pixel_grid=self.Data,
psf=self.PSF,
**kwargs_numerics)
if lens_model_class is None:
lens_model_class = LensModel(lens_model_list=[])
self.LensModel = lens_model_class
if point_source_class is None:
point_source_class = PointSource(point_source_type_list=[])
self.PointSource = point_source_class
self.PointSource.update_lens_model(lens_model_class=lens_model_class)
x_center, y_center = self.Data.center
self.PointSource.update_search_window(
search_window=np.max(self.Data.width),
x_center=x_center,
y_center=y_center,
min_distance=self.Data.pixel_width,
only_from_unspecified=True)
self._psf_error_map = self.PSF.psf_error_map_bool
if source_model_class is None:
source_model_class = LightModel(light_model_list=[])
self.SourceModel = source_model_class
if lens_light_model_class is None:
lens_light_model_class = LightModel(light_model_list=[])
self.LensLightModel = lens_light_model_class
self.source_mapping = Image2SourceMapping(
lensModel=lens_model_class, sourceModel=source_model_class)
self.num_bands = 1
self._kwargs_numerics = kwargs_numerics
if extinction_class is None:
extinction_class = DifferentialExtinction(optical_depth_model=[])
self._extinction = extinction_class
