def test_shift_coords(self):
numPix = 10
deltaPix = 0.05
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, inverse=True)
# mask (1= model this pixel, 0= leave blanck)
kwargs_data = {'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord, 'image_data': np.ones((numPix, numPix))}
data = ImageData(**kwargs_data)
ra_shift = 0.05
dec_shift = 0.
kwargs_data['ra_shift'] = ra_shift
kwargs_data['dec_shift'] = dec_shift
data_shift = ImageData(**kwargs_data)
ra, dec = data.map_pix2coord(1, 1)
ra_new, dec_new = data_shift.map_pix2coord(1, 1)
npt.assert_almost_equal(ra_new - ra, ra_shift, decimal=10)
npt.assert_almost_equal(dec_new - dec, dec_shift, decimal=10)
ra_2, dec_2 = data_shift.map_pix2coord(2, 1)
npt.assert_almost_equal(ra, ra_2, decimal=10)
npt.assert_almost_equal(dec, dec_2, decimal=10)
x, y = data.map_coord2pix(0, 0)
x_new, y_new = data_shift.map_coord2pix(ra_shift, dec_shift)
npt.assert_almost_equal(x, x_new, decimal=10)
npt.assert_almost_equal(y, y_new, decimal=10)
def test_extinction_map(self):
kwargs_data = sim_util.data_configure_simple(numPix=10, deltaPix=1, exposure_time=1, background_rms=1)
data_class = ImageData(**kwargs_data)
extinction_class = DifferentialExtinction(optical_depth_model=['UNIFORM'], tau0_index=0)
imageModel = ImageModel(data_class, PSF(), extinction_class=extinction_class)
extinction = imageModel.extinction_map(kwargs_extinction=[{'amp': 1}], kwargs_special={'tau0_list': [1, 0, 0]})
npt.assert_almost_equal(extinction, np.exp(-1))
def test_error_map_source(self):
sourceModel = LightModel(light_model_list=['UNIFORM', 'UNIFORM'])
kwargs_data = sim_util.data_configure_simple(numPix=10,
deltaPix=1,
exposure_time=1,
background_rms=1)
data_class = ImageData(**kwargs_data)
psf_type = "GAUSSIAN"
fwhm = 0.9
kwargs_psf = {'psf_type': psf_type, 'fwhm': fwhm}
psf_class = PSF(**kwargs_psf)
imageModel = ImageLinearFit(data_class=data_class,
psf_class=psf_class,
lens_model_class=None,
point_source_class=None,
source_model_class=sourceModel)
x_grid, y_grid = util.make_grid(numPix=10, deltapix=1)
error_map = imageModel.error_map_source(kwargs_source=[{
'amp': 1
}, {
'amp': 1
}],
x_grid=x_grid,
y_grid=y_grid,
cov_param=np.array([[1, 0],
[0, 1]]))
assert error_map[0] == 2
def test_shift_coordinate_system(self):
x_shift = 0.05
y_shift = 0
numPix = 10
deltaPix = 0.05
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, inverse=True)
kwargs_data = {'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord, 'image_data': np.ones((numPix, numPix))}
data = ImageData(**kwargs_data)
data_new = copy.deepcopy(data)
data_new.shift_coordinate_system(x_shift, y_shift, pixel_unit=False)
ra, dec = 0, 0
x, y = data.map_coord2pix(ra, dec)
x_new, y_new = data_new.map_coord2pix(ra + x_shift, dec + y_shift)
npt.assert_almost_equal(x, x_new, decimal=10)
npt.assert_almost_equal(y, y_new, decimal=10)
ra, dec = data.map_pix2coord(x, y)
ra_new, dec_new = data_new.map_pix2coord(x, y)
npt.assert_almost_equal(ra, ra_new-x_shift, decimal=10)
npt.assert_almost_equal(dec, dec_new-y_shift, decimal=10)
x_coords, y_coords = data.pixel_coordinates
x_coords_new, y_coords_new = data_new.pixel_coordinates
npt.assert_almost_equal(x_coords[0], x_coords_new[0]-x_shift, decimal=10)
npt.assert_almost_equal(y_coords[0], y_coords_new[0]-y_shift, decimal=10)
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,
background_rms=1)
data_class = ImageData(**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 sepc_imageModel(self):
from lenstronomy.ImSim.image_model import ImageModel
from lenstronomy.Data.imaging_data import ImageData
from lenstronomy.Data.psf import PSF
data_class = ImageData(**self.kwargs_data)
from lenstronomy.PointSource.point_source import PointSource
pointSource = PointSource(
point_source_type_list=self.point_source_list)
psf_class = PSF(**self.kwargs_psf)
from lenstronomy.LightModel.light_model import LightModel
lightModel = LightModel(light_model_list=self.light_model_list)
if self.light_model_list is None:
imageModel = ImageModel(data_class,
psf_class,
point_source_class=pointSource,
kwargs_numerics=self.kwargs_numerics)
else:
imageModel = ImageModel(data_class,
psf_class,
source_model_class=lightModel,
point_source_class=pointSource,
kwargs_numerics=self.kwargs_numerics)
self.data_class = data_class
self.psf_class = psf_class
self.lightModel = lightModel
self.imageModel = imageModel
self.pointSource = pointSource
def test_force_positive_source_surface_brightness(self):
kwargs_likelihood = {'force_minimum_source_surface_brightness': True}
kwargs_model = {'source_light_model_list': ['SERSIC']}
kwargs_constraints = {}
param_class = Param(kwargs_model, **kwargs_constraints)
kwargs_data = sim_util.data_configure_simple(numPix=10, deltaPix=0.1, exposure_time=1, sigma_bkg=0.1)
data_class = ImageData(**kwargs_data)
kwargs_psf = {'psf_type': 'NONE'}
psf_class = PSF(**kwargs_psf)
kwargs_sersic = {'amp': -1., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0}
source_model_list = ['SERSIC']
kwargs_source = [kwargs_sersic]
source_model_class = LightModel(light_model_list=source_model_list)
imageModel = ImageModel(data_class, psf_class, lens_model_class=None, source_model_class=source_model_class)
image_sim = sim_util.simulate_simple(imageModel, [], kwargs_source)
kwargs_data['image_data'] = image_sim
kwargs_data_joint = {'multi_band_list': [[kwargs_data, kwargs_psf, {}]], 'multi_band_type': 'single-band'}
likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data_joint, kwargs_model=kwargs_model, param_class=param_class, **kwargs_likelihood)
logL, _ = likelihood.logL(args=param_class.kwargs2args(kwargs_source=kwargs_source), verbose=True)
assert logL <= -10**10
def create_image_model(kwargs_data,
kwargs_psf,
kwargs_numerics,
kwargs_model,
likelihood_mask=None):
"""
:param kwargs_data:
:param kwargs_psf:
:param kwargs_model:
:param kwargs_model_indexes:
:return:
"""
data_class = ImageData(**kwargs_data)
psf_class = PSF(**kwargs_psf)
lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_class = create_class_instances(
**kwargs_model)
imageModel = ImageLinearFit(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
extinction_class,
kwargs_numerics,
likelihood_mask=likelihood_mask)
return imageModel
def create_image_model(kwargs_data,
kwargs_psf,
kwargs_numerics,
kwargs_model,
image_likelihood_mask=None):
"""
:param kwargs_data: ImageData keyword arguments
:param kwargs_psf: PSF keyword arguments
:param kwargs_numerics: numerics keyword arguments for Numerics() class
:param kwargs_model: model keyword arguments
:param image_likelihood_mask: image likelihood mask
(same size as image_data with 1 indicating being evaluated and 0 being left out)
:return: ImageLinearFit() instance
"""
data_class = ImageData(**kwargs_data)
psf_class = PSF(**kwargs_psf)
lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_class = create_class_instances(
**kwargs_model)
imageModel = ImageLinearFit(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
extinction_class,
kwargs_numerics,
likelihood_mask=image_likelihood_mask)
return imageModel
def __init__(self, multi_band_list, kwargs_model, likelihood_mask_list=None, band_index=0):
self.type = 'single-band-multi-model'
if likelihood_mask_list is None:
likelihood_mask_list = [None for i in range(len(multi_band_list))]
lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_class = class_creator.create_class_instances(band_index=band_index, **kwargs_model)
kwargs_data = multi_band_list[band_index][0]
kwargs_psf = multi_band_list[band_index][1]
kwargs_numerics = multi_band_list[band_index][2]
data_i = ImageData(**kwargs_data)
psf_i = PSF(**kwargs_psf)
index_lens_model_list = kwargs_model.get('index_lens_model_list', [None for i in range(len(multi_band_list))])
self._index_lens_model = index_lens_model_list[band_index]
index_source_list = kwargs_model.get('index_source_light_model_list', [None for i in range(len(multi_band_list))])
self._index_source = index_source_list[band_index]
index_lens_light_list = kwargs_model.get('index_lens_light_model_list', [None for i in range(len(multi_band_list))])
self._index_lens_light = index_lens_light_list[band_index]
index_point_source_list = kwargs_model.get('index_point_source_model_list', [None for i in range(len(multi_band_list))])
self._index_point_source = index_point_source_list[band_index]
index_optical_depth = kwargs_model.get('index_optical_depth_model_list',
[None for i in range(len(multi_band_list))])
self._index_optical_depth = index_optical_depth[band_index]
super(SingleBandMultiModel, self).__init__(data_i, psf_i, lens_model_class, source_model_class,
lens_light_model_class, point_source_class, extinction_class,
kwargs_numerics=kwargs_numerics, likelihood_mask=likelihood_mask_list[band_index])
def data_class(self):
"""
creates a Data() instance of lenstronomy based on knowledge of the observation
:return: instance of Data() class
"""
data_class = ImageData(**self.kwargs_data)
return data_class
def test_create_empty(self):
kwargs_data = sim_util.data_configure_simple(numPix=10, deltaPix=1, exposure_time=1, background_rms=1)
data_class = ImageData(**kwargs_data)
imageModel_empty = ImageModel(data_class, PSF())
assert imageModel_empty._psf_error_map == False
flux = imageModel_empty.lens_surface_brightness(kwargs_lens_light=None)
assert flux.all() == 0
def test_update_data(self):
kwargs_data = sim_util.data_configure_simple(numPix=10,
deltaPix=1,
exposure_time=1,
background_rms=1,
inverse=True)
data_class = ImageData(**kwargs_data)
self.imageModel.update_data(data_class)
assert self.imageModel.Data.num_pixel == 100
def __init__(self,
multi_band_list,
kwargs_model,
likelihood_mask_list=None,
band_index=0,
kwargs_pixelbased=None):
"""
:param multi_band_list: list of imaging band configurations [[kwargs_data, kwargs_psf, kwargs_numerics],[...], ...]
:param kwargs_model: model option keyword arguments
:param likelihood_mask_list: list of likelihood masks (booleans with size of the individual images
:param band_index: integer, index of the imaging band to model
:param kwargs_pixelbased: keyword arguments with various settings related to the pixel-based solver (see SLITronomy documentation)
"""
self.type = 'single-band-multi-model'
if likelihood_mask_list is None:
likelihood_mask_list = [None for i in range(len(multi_band_list))]
lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_class = class_creator.create_class_instances(
band_index=band_index, **kwargs_model)
kwargs_data = multi_band_list[band_index][0]
kwargs_psf = multi_band_list[band_index][1]
kwargs_numerics = multi_band_list[band_index][2]
data_i = ImageData(**kwargs_data)
psf_i = PSF(**kwargs_psf)
index_lens_model_list = kwargs_model.get(
'index_lens_model_list',
[None for i in range(len(multi_band_list))])
self._index_lens_model = index_lens_model_list[band_index]
index_source_list = kwargs_model.get(
'index_source_light_model_list',
[None for i in range(len(multi_band_list))])
self._index_source = index_source_list[band_index]
index_lens_light_list = kwargs_model.get(
'index_lens_light_model_list',
[None for i in range(len(multi_band_list))])
self._index_lens_light = index_lens_light_list[band_index]
index_point_source_list = kwargs_model.get(
'index_point_source_model_list',
[None for i in range(len(multi_band_list))])
self._index_point_source = index_point_source_list[band_index]
index_optical_depth = kwargs_model.get(
'index_optical_depth_model_list',
[None for i in range(len(multi_band_list))])
self._index_optical_depth = index_optical_depth[band_index]
super(SingleBandMultiModel,
self).__init__(data_i,
psf_i,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
extinction_class,
kwargs_numerics=kwargs_numerics,
likelihood_mask=likelihood_mask_list[band_index],
kwargs_pixelbased=kwargs_pixelbased)
def test_update_data(self):
kwargs_data = {'image_data': np.zeros((self.numPix, self.numPix)),
'noise_map': None, 'exposure_time': 1, 'background_rms': 1}
data = ImageData(**kwargs_data)
C_D = data.C_D
data.update_data(image_data=np.ones((self.numPix, self.numPix)))
C_D_new = data.C_D
assert C_D_new[0,0] > C_D[0, 0]
data_new = data.data
npt.assert_almost_equal(data_new, np.ones((self.numPix, self.numPix)))
def _read_kwargs_lens(
self,
ra,
dec,
kwargs_data,
lens_model_list=['SHIFT', 'SHEAR', 'CONVERGENCE', 'FLEXIONFG']):
"""
Initial lens parameters, read from shear, convergence
:param ra: x coordinate of lensed image
:param dec: y coordinate of lensed image
:param kwargs_data: arguments of image data
:param lens_model_list: list of choices of lens model
:return: list of lens parameters
"""
imageData = ImageData(**kwargs_data)
r_cut = (np.shape(imageData.data)[0] - 1) / 2
xaxes, yaxes = imageData.pixel_coordinates
ra_center = xaxes[int(r_cut + 1), int(r_cut + 1)]
dec_center = yaxes[int(r_cut + 1), int(r_cut + 1)]
kwargs_lens = []
for lens_type in lens_model_list:
if lens_type == 'SHIFT':
kwargs_lens.append({
'alpha_x': ra_center,
'alpha_y': dec_center
})
elif lens_type == 'SHEAR':
xgamma, ygamma = self.radec2detector(ra, dec)
gamma1 = self.gamma1[xgamma, ygamma]
gamma2 = self.gamma2[xgamma, ygamma]
kwargs_lens.append({
'gamma1': gamma1,
'gamma2': gamma2,
'ra_0': ra_center,
'dec_0': dec_center
})
elif lens_type == 'CONVERGENCE':
xkappa, ykappa = self.radec2detector(ra, dec)
kappa = self.kappa[xkappa, ykappa]
kwargs_lens.append({
'kappa_ext': kappa,
'ra_0': ra_center,
'dec_0': dec_center
})
elif lens_type == 'FLEXIONFG':
kwargs_lens.append({
'F1': 0,
'F2': 0,
'G1': 0,
'G2': 0,
'ra_0': ra_center,
'dec_0': dec_center
})
magnification = 1. / ((1 - kappa)**2 - (gamma1**2 + gamma2**2))
return kwargs_lens, magnification
def setup(self):
self.num_pix = 20 # cutout pixel size
delta_pix = 0.2
background_rms = 0.05
_, _, ra_at_xy_0, dec_at_xy_0, _, _, Mpix2coord, _ \
= l_util.make_grid_with_coordtransform(numPix=self.num_pix, deltapix=delta_pix, subgrid_res=1,
inverse=False, left_lower=False)
# imaging data class
kwargs_data = {
'ra_at_xy_0': ra_at_xy_0,
'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord,
'image_data': np.zeros((self.num_pix, self.num_pix)),
'background_rms': background_rms,
'noise_map': background_rms * np.ones(
(self.num_pix, self.num_pix)),
}
data_class = ImageData(**kwargs_data)
# lens mass class
lens_model_class = LensModel(['SPEP'])
self.kwargs_lens = [{
'theta_E': 1,
'gamma': 2,
'center_x': 0,
'center_y': 0,
'e1': -0.05,
'e2': 0.05
}]
# source light class
source_model_class = LightModel(['SLIT_STARLETS'])
self.kwargs_source = [{
'coeffs': 0,
'n_scales': 3,
'n_pixels': self.num_pix**2
}]
# define numerics classes
image_numerics_class = NumericsSubFrame(pixel_grid=data_class,
psf=PSF(psf_type='NONE'))
source_numerics_class = NumericsSubFrame(pixel_grid=data_class,
psf=PSF(psf_type='NONE'),
supersampling_factor=1)
# init sparse solver
self.solver = SparseSolverSource(data_class,
lens_model_class,
image_numerics_class,
source_numerics_class,
source_model_class,
num_iter_source=10)
# init the tracker
self.tracker_alone = SolverTracker(self.solver, verbose=True)
def setup(self):
# data specifics
sigma_bkg = .05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 100 # cutout pixel size
deltaPix = 0.05 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
# PSF specification
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exp_time, sigma_bkg)
data_class = ImageData(**kwargs_data)
kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': fwhm, 'truncation': 5, 'pixel_size': deltaPix}
psf_class = PSF(**kwargs_psf)
# 'EXTERNAL_SHEAR': external shear
kwargs_shear = {'e1': 0.01, 'e2': 0.01} # gamma_ext: shear strength, psi_ext: shear angel (in radian)
phi, q = 0.2, 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_spemd = {'theta_E': 1., 'gamma': 1.8, 'center_x': 0, 'center_y': 0, 'e1': e1, 'e2': e2}
lens_model_list = ['SPEP', 'SHEAR']
self.kwargs_lens = [kwargs_spemd, kwargs_shear]
lens_model_class = LensModel(lens_model_list=lens_model_list)
# list of light profiles (for lens and source)
# 'SERSIC': spherical Sersic profile
kwargs_sersic = {'amp': 1., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
phi, q = 0.2, 0.9
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_sersic_ellipse = {'amp': 1., 'R_sersic': .6, 'n_sersic': 7, 'center_x': 0, 'center_y': 0,
'e1': e1, 'e2': e2}
lens_light_model_list = ['SERSIC']
self.kwargs_lens_light = [kwargs_sersic]
lens_light_model_class = LightModel(light_model_list=lens_light_model_list)
source_model_list = ['SERSIC_ELLIPSE']
self.kwargs_source = [kwargs_sersic_ellipse]
source_model_class = LightModel(light_model_list=source_model_list)
self.kwargs_ps = [{'ra_source': 0.0001, 'dec_source': 0.0,
'source_amp': 1.}] # quasar point source position in the source plane and intrinsic brightness
point_source_class = PointSource(point_source_type_list=['SOURCE_POSITION'], fixed_magnification_list=[True])
kwargs_numerics = {'supersampling_factor': 2, 'supersampling_convolution': True, 'compute_mode': 'gaussian'}
imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class,
point_source_class, kwargs_numerics=kwargs_numerics)
image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens, self.kwargs_source,
self.kwargs_lens_light, self.kwargs_ps)
data_class.update_data(image_sim)
kwargs_data['image_data'] = image_sim
self.solver = LensEquationSolver(lensModel=lens_model_class)
multi_band_list = [[kwargs_data, kwargs_psf, kwargs_numerics]]
kwargs_model = {'lens_model_list': lens_model_list, 'source_light_model_list': source_model_list,
'point_source_model_list': ['SOURCE_POSITION'], 'fixed_magnification_list': [True]}
self.imageModel = MultiLinear(multi_band_list, kwargs_model, likelihood_mask_list=None, compute_bool=None)
def test_raise(self):
with self.assertRaises(ValueError):
num_pix = 10
data = ImageData(np.zeros((num_pix, num_pix)))
lens_model = LensModel(['SPEP'])
image_grid_class = NumericsSubFrame(data, PSF('NONE')).grid_class
source_grid_class = NumericsSubFrame(data, PSF('NONE')).grid_class
lensing_op = LensingOperator(lens_model,
image_grid_class,
source_grid_class,
num_pix,
source_interpolation='sth')
def __init__(self, *args, **kwargs):
super(TestRaise, self).__init__(*args, **kwargs)
self.num_pix = 10
_, _, ra_at_xy_0, dec_at_xy_0, _, _, Mpix2coord, _ \
= l_util.make_grid_with_coordtransform(numPix=self.num_pix, deltapix=0.5, subgrid_res=1,
inverse=False, left_lower=False)
kwargs_data_nonsquare = {
'ra_at_xy_0': ra_at_xy_0,
'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord,
'image_data': np.zeros(
(self.num_pix, self.num_pix + 10)), # non-square image
}
kwargs_data = {
'ra_at_xy_0': ra_at_xy_0,
'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord,
'image_data': np.zeros(
(self.num_pix, self.num_pix)), # non-square image
}
self.data_nonsquare = ImageData(**kwargs_data_nonsquare)
self.data = ImageData(**kwargs_data)
psf = PSF('NONE')
self.numerics = NumericsSubFrame(self.data, psf)
lens_model = LensModel(['SPEP'])
self.source_model_class = LightModel(['SLIT_STARLETS'])
self.lens_light_model_class = LightModel(['SLIT_STARLETS'])
# get grid classes
image_grid_class = self.numerics.grid_class
source_numerics = NumericsSubFrame(self.data,
psf,
supersampling_factor=1)
source_grid_class = source_numerics.grid_class
self.lensing_op = LensingOperator(lens_model, image_grid_class,
source_grid_class, self.num_pix)
self.model_op = ModelOperators(self.data, self.lensing_op,
self.numerics)
self.model_op.add_lens_light(self.lens_light_model_class)
self.model_op_nolens = ModelOperators(self.data, self.lensing_op,
self.numerics)
def lens_model_plot(ax, lensModel, kwargs_lens, numPix=500, deltaPix=0.01, sourcePos_x=0, sourcePos_y=0,
point_source=False, with_caustics=False, coord_center_ra=0, coord_center_dec=0,
coord_inverse=False):
"""
plots a lens model (convergence) and the critical curves and caustics
:param ax:
:param kwargs_lens:
:param numPix:
:param deltaPix:
:return:
"""
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, center_ra=coord_center_ra, center_dec=coord_center_dec,
inverse=coord_inverse)
data = ImageData(**kwargs_data)
_coords = data
_frame_size = numPix * deltaPix
x_grid, y_grid = data.pixel_coordinates
lensModelExt = LensModelExtensions(lensModel)
#ra_crit_list, dec_crit_list, ra_caustic_list, dec_caustic_list = lensModelExt.critical_curve_caustics(
# kwargs_lens, compute_window=_frame_size, grid_scale=deltaPix/2.)
x_grid1d = util.image2array(x_grid)
y_grid1d = util.image2array(y_grid)
kappa_result = lensModel.kappa(x_grid1d, y_grid1d, kwargs_lens)
kappa_result = util.array2image(kappa_result)
im = ax.matshow(np.log10(kappa_result), origin='lower', extent=[0, _frame_size, 0, _frame_size], cmap='Greys',
vmin=-1, vmax=1) #, cmap=self._cmap, vmin=v_min, vmax=v_max)
if with_caustics is True:
ra_crit_list, dec_crit_list = lensModelExt.critical_curve_tiling(kwargs_lens, compute_window=_frame_size,
start_scale=deltaPix, max_order=10)
ra_caustic_list, dec_caustic_list = lensModel.ray_shooting(ra_crit_list, dec_crit_list, kwargs_lens)
plot_util.plot_line_set(ax, _coords, ra_caustic_list, dec_caustic_list, color='g')
plot_util.plot_line_set(ax, _coords, ra_crit_list, dec_crit_list, color='r')
if point_source:
from lenstronomy.LensModel.Solver.lens_equation_solver import LensEquationSolver
solver = LensEquationSolver(lensModel)
theta_x, theta_y = solver.image_position_from_source(sourcePos_x, sourcePos_y, kwargs_lens,
min_distance=deltaPix, search_window=deltaPix*numPix)
mag_images = lensModel.magnification(theta_x, theta_y, kwargs_lens)
x_image, y_image = _coords.map_coord2pix(theta_x, theta_y)
abc_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K']
for i in range(len(x_image)):
x_ = (x_image[i] + 0.5) * deltaPix
y_ = (y_image[i] + 0.5) * deltaPix
ax.plot(x_, y_, 'dk', markersize=4*(1 + np.log(np.abs(mag_images[i]))), alpha=0.5)
ax.text(x_, y_, abc_list[i], fontsize=20, color='k')
x_source, y_source = _coords.map_coord2pix(sourcePos_x, sourcePos_y)
ax.plot((x_source + 0.5) * deltaPix, (y_source + 0.5) * deltaPix, '*k', markersize=10)
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
ax.autoscale(False)
return ax
def __init__(self, *args, **kwargs):
super(TestRaise, self).__init__(*args, **kwargs)
self.num_pix = 49 # cutout pixel size
self.subgrid_res_source = 1
self.num_pix_source = self.num_pix * self.subgrid_res_source
delta_pix = 0.24
_, _, ra_at_xy_0, dec_at_xy_0, _, _, Mpix2coord, _ \
= l_util.make_grid_with_coordtransform(numPix=self.num_pix, deltapix=delta_pix, subgrid_res=1,
inverse=False, left_lower=False)
image_data = np.random.rand(self.num_pix, self.num_pix)
self.kwargs_data = {
'ra_at_xy_0': ra_at_xy_0,
'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord,
'image_data': image_data,
'background_rms': 0.01,
'noise_map': 0.01 * np.ones_like(image_data),
}
self.data = ImageData(**self.kwargs_data)
self.lens_model_class = LensModel(['SPEP'])
self.kwargs_lens = [{
'theta_E': 1,
'gamma': 2,
'center_x': 0,
'center_y': 0,
'e1': -0.05,
'e2': 0.05
}]
self.source_model_class = LightModel(['SLIT_STARLETS'])
self.lens_light_model_class = LightModel(['SLIT_STARLETS'])
self.kwargs_source = [{'n_scales': 4}]
self.kwargs_lens_light = [{'n_scales': 4}]
psf = PSF(psf_type='NONE')
self.numerics = NumericsSubFrame(pixel_grid=self.data, psf=psf)
self.source_numerics = NumericsSubFrame(
pixel_grid=self.data,
psf=psf,
supersampling_factor=self.subgrid_res_source)
self.solver_source_lens = SparseSolverSourceLens(
self.data,
self.lens_model_class,
self.numerics,
self.source_numerics,
self.source_model_class,
self.lens_light_model_class,
num_iter_source=1,
num_iter_lens=1,
num_iter_weights=1)
def data_class(self):
"""
creates a Data() instance of lenstronomy based on knowledge of the observation
:return: instance of Data() class
"""
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=self.numpix, deltapix=self.pixel_scale, subgrid_res=1, left_lower=False, inverse=False)
kwargs_data = {'image_data': np.zeros((self.numpix, self.numpix)), 'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord,
'background_rms': self.background_noise,
'exposure_time': self.scaled_exposure_time}
data_class = ImageData(**kwargs_data)
return data_class
def setup(self):
self.num_pix = 25 # cutout pixel size
self.delta_pix = 0.24
_, _, ra_at_xy_0, dec_at_xy_0, _, _, Mpix2coord, _ \
= l_util.make_grid_with_coordtransform(numPix=self.num_pix, deltapix=self.delta_pix, subgrid_res=1,
inverse=False, left_lower=False)
kwargs_data = {
'ra_at_xy_0': ra_at_xy_0,
'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord,
'image_data': np.zeros((self.num_pix, self.num_pix))
}
numerics = NumericsSubFrame(ImageData(**kwargs_data), PSF('NONE'))
self.plane_grid = PlaneGrid(numerics.grid_class)
def test_data_configure_simple(self):
# data specifics
sigma_bkg = 1. # background noise per pixel
exp_time = 10 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 100 # cutout pixel size
deltaPix = 0.05 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
# PSF specification
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exp_time, sigma_bkg)
data_class = ImageData(**kwargs_data)
assert data_class.pixel_width == deltaPix
def test_raise(self):
with self.assertRaises(ValueError):
# test rectangular size
num_pix_x = 25
num_pix_y = 30
delta_pix = 0.24
_, _, ra_at_xy_0, dec_at_xy_0, _, _, Mpix2coord, _ \
= l_util.make_grid_with_coordtransform(numPix=num_pix_x, deltapix=delta_pix, subgrid_res=1,
inverse=False, left_lower=False)
kwargs_data = {
'ra_at_xy_0': ra_at_xy_0,
'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord,
'image_data': np.zeros((num_pix_x, num_pix_y))
}
numerics = NumericsSubFrame(ImageData(**kwargs_data), PSF('NONE'))
plane_grid = PlaneGrid(numerics.grid_class)
def _joint_pixel_grid(multi_band_list):
"""
Joint PixelGrid() class instance.
This routine only works when the individual patches have the same coordinate system orientation and pixel scale.
:param multi_band_list: list of imaging data configuration [[kwargs_data, kwargs_psf, kwargs_numerics], [...]]
:return: PixelGrid() class instance covering the entire window of the sky including all individual patches
"""
nx, ny = 0, 0
kwargs_data = copy.deepcopy(multi_band_list[0][0])
kwargs_pixel_grid = {
'nx': 0,
'ny': 0,
'transform_pix2angle': kwargs_data['transform_pix2angle'],
'ra_at_xy_0': kwargs_data['ra_at_xy_0'],
'dec_at_xy_0': kwargs_data['dec_at_xy_0']
}
pixel_grid = PixelGrid(**kwargs_pixel_grid)
Mpix2a = pixel_grid.transform_pix2angle
# set up joint coordinate system and pixel size to include all frames
for i in range(len(multi_band_list)):
kwargs_data = multi_band_list[i][0]
data_class_i = ImageData(**kwargs_data)
Mpix2a_i = data_class_i.transform_pix2angle
# check we are operating in the same coordinate system/rotation and pixel scale
npt.assert_almost_equal(Mpix2a, Mpix2a_i, decimal=5)
# evaluate pixel of zero point with the base coordinate system
ra0, dec0 = data_class_i.radec_at_xy_0
x_min, y_min = pixel_grid.map_coord2pix(ra0, dec0)
nx_i, ny_i = data_class_i.num_pixel_axes
nx, ny = _update_frame_size(nx, ny, x_min, y_min, nx_i, ny_i)
# select minimum in x- and y-axis
# transform back in RA/DEC and make this the new zero point of the base coordinate system
ra_at_xy_0_new, dec_at_xy_0_new = pixel_grid.map_pix2coord(
np.minimum(x_min, 0), np.minimum(y_min, 0))
kwargs_pixel_grid['ra_at_xy_0'] = ra_at_xy_0_new
kwargs_pixel_grid['dec_at_xy_0'] = dec_at_xy_0_new
kwargs_pixel_grid['nx'] = nx
kwargs_pixel_grid['ny'] = ny
pixel_grid = PixelGrid(**kwargs_pixel_grid)
return pixel_grid
def test_point_source_rendering(self):
# initialize data
numPix = 100
deltaPix = 0.05
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exposure_time=1, background_rms=1)
data_class = ImageData(**kwargs_data)
kernel = np.zeros((5, 5))
kernel[2, 2] = 1
kwargs_psf = {'kernel_point_source': kernel, 'psf_type': 'PIXEL', 'psf_error_map': np.ones_like(kernel) * 0.001}
psf_class = PSF(**kwargs_psf)
lens_model_class = LensModel(['SPEP'])
source_model_class = LightModel([])
lens_light_model_class = LightModel([])
kwargs_numerics = {'supersampling_factor': 2, 'supersampling_convolution': True, 'point_source_supersampling_factor': 1}
point_source_class = PointSource(point_source_type_list=['LENSED_POSITION'], fixed_magnification_list=[False])
makeImage = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics=kwargs_numerics)
# chose point source positions
x_pix = np.array([10, 5, 10, 90])
y_pix = np.array([40, 50, 60, 50])
ra_pos, dec_pos = makeImage.Data.map_pix2coord(x_pix, y_pix)
e1, e2 = param_util.phi_q2_ellipticity(0, 0.8)
kwargs_lens_init = [{'theta_E': 1, 'gamma': 2, 'e1': e1, 'e2': e2, 'center_x': 0, 'center_y': 0}]
kwargs_else = [{'ra_image': ra_pos, 'dec_image': dec_pos, 'point_amp': np.ones_like(ra_pos)}]
image = makeImage.image(kwargs_lens_init, kwargs_source={}, kwargs_lens_light={}, kwargs_ps=kwargs_else)
#print(np.shape(model), 'test')
#image = makeImage.ImageNumerics.array2image(model)
for i in range(len(x_pix)):
npt.assert_almost_equal(image[y_pix[i], x_pix[i]], 1, decimal=2)
x_pix = np.array([10.5, 5.5, 10.5, 90.5])
y_pix = np.array([40, 50, 60, 50])
ra_pos, dec_pos = makeImage.Data.map_pix2coord(x_pix, y_pix)
phi, q = 0., 0.8
e1, e2 = param_util.phi_q2_ellipticity(phi, q)
kwargs_lens_init = [{'theta_E': 1, 'gamma': 2, 'e1': e1, 'e2': e2, 'center_x': 0, 'center_y': 0}]
kwargs_else = [{'ra_image': ra_pos, 'dec_image': dec_pos, 'point_amp': np.ones_like(ra_pos)}]
image = makeImage.image(kwargs_lens_init, kwargs_source={}, kwargs_lens_light={}, kwargs_ps=kwargs_else)
#image = makeImage.ImageNumerics.array2image(model)
for i in range(len(x_pix)):
print(int(y_pix[i]), int(x_pix[i]+0.5))
npt.assert_almost_equal(image[int(y_pix[i]), int(x_pix[i])], 0.5, decimal=1)
npt.assert_almost_equal(image[int(y_pix[i]), int(x_pix[i]+0.5)], 0.5, decimal=1)
def setup(self):
self.num_pix = 25 # cutout pixel size
self.subgrid_res_source = 2
delta_pix = 0.32
_, _, ra_at_xy_0, dec_at_xy_0, _, _, Mpix2coord, _ \
= l_util.make_grid_with_coordtransform(numPix=self.num_pix, deltapix=delta_pix, subgrid_res=1,
inverse=False, left_lower=False)
kwargs_data = {
'ra_at_xy_0': ra_at_xy_0,
'dec_at_xy_0': dec_at_xy_0,
'transform_pix2angle': Mpix2coord,
'image_data': np.zeros((self.num_pix, self.num_pix))
}
data_class = ImageData(**kwargs_data)
numerics_image = NumericsSubFrame(data_class, PSF('NONE'))
numerics_source = NumericsSubFrame(
data_class,
PSF('NONE'),
supersampling_factor=self.subgrid_res_source)
self.source_plane = SizeablePlaneGrid(numerics_source.grid_class,
verbose=True)
# create a mask mimicking the real case of lensing operation
lens_model_class = LensModel(['SIE'])
kwargs_lens = [{
'theta_E': 1.5,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}]
lensing_op = LensingOperator(lens_model_class,
numerics_image.grid_class,
numerics_source.grid_class, self.num_pix,
self.subgrid_res_source)
lensing_op.update_mapping(kwargs_lens)
unit_image = np.ones((self.num_pix, self.num_pix))
mask_image = np.zeros((self.num_pix, self.num_pix))
mask_image[2:-2, 2:-2] = 1 # some binary image that mask out borders
self.unit_image_mapped = lensing_op.image2source_2d(unit_image,
no_flux_norm=False)
self.mask_mapped = lensing_op.image2source_2d(mask_image)
def generate_lens(sigma_bkg=sigma_bkg,
exp_time=exp_time,
numPix=numPix,
deltaPix=deltaPix,
fwhm=fwhm,
psf_type=psf_type,
kernel_size=kernel_size,
z_source=z_source,
z_lens=z_lens,
phi_ext=phi_ext,
gamma_ext=gamma_ext,
theta_E=theta_E,
gamma_lens=gamma_lens,
e1_lens=e1_lens,
e2_lens=e2_lens,
center_x_lens_light=center_x_lens_light,
center_y_lens_light=center_y_lens_light,
source_x=source_y,
source_y=source_y,
q_source=q_source,
phi_source=phi_source,
center_x=center_x,
center_y=center_y,
amp_source=amp_source,
R_sersic_source=R_sersic_source,
n_sersic_source=n_sersic_source,
phi_lens_light=phi_lens_light,
q_lens_light=q_lens_light,
amp_lens=amp_lens,
R_sersic_lens=R_sersic_lens,
n_sersic_lens=n_sersic_lens,
amp_ps=amp_ps,
supersampling_factor=supersampling_factor,
v_min=v_min,
v_max=v_max,
cosmo=cosmo,
cosmo2=cosmo2,
lens_pos_eq_lens_light_pos=True,
same_cosmology=True):
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exp_time,
sigma_bkg)
data_class = ImageData(**kwargs_data)
kwargs_psf = {'psf_type': psf_type, 'pixel_size': deltaPix, 'fwhm': fwhm}
psf_class = PSF(**kwargs_psf)
cosmo = FlatLambdaCDM(H0=75, Om0=0.3, Ob0=0.)
cosmo = FlatLambdaCDM(H0=65, Om0=0.3, Ob0=0.)
gamma1, gamma2 = param_util.shear_polar2cartesian(phi=phi_ext,
gamma=gamma_ext)
kwargs_shear = {'gamma1': gamma1, 'gamma2': gamma2}
if lens_pos_eq_lens_light_pos:
center_x = center_x_lens_light
center_y = center_y_lens_light
if same_cosmology:
cosmo2 = cosmo
kwargs_spemd = {
'theta_E': theta_E,
'gamma': gamma_lens,
'center_x': center_x,
'center_y': center_y,
'e1': e1_lens,
'e2': e2_lens
}
lens_model_list = ['SPEP', 'SHEAR']
kwargs_lens = [kwargs_spemd, kwargs_shear]
lens_model_class = LensModel(lens_model_list=lens_model_list,
z_lens=z_lens,
z_source=z_source,
cosmo=cosmo)
lens_model_class2 = LensModel(lens_model_list=lens_model_list,
z_lens=z_lens,
z_source=z_source,
cosmo=cosmo2)
e1_source, e2_source = param_util.phi_q2_ellipticity(phi_source, q_source)
kwargs_sersic_source = {
'amp': amp_source,
'R_sersic': R_sersic_source,
'n_sersic': n_sersic_source,
'e1': e1_source,
'e2': e2_source,
'center_x': source_x,
'center_y': source_y
}
source_model_list = ['SERSIC_ELLIPSE']
kwargs_source = [kwargs_sersic_source]
source_model_class = LightModel(light_model_list=source_model_list)
##
e1_lens_light, e2_lens_light = param_util.phi_q2_ellipticity(
phi_lens_light, q_lens_light)
kwargs_sersic_lens = {
'amp': amp_lens,
'R_sersic': R_sersic_lens,
'n_sersic': n_sersic_lens,
'e1': e1_lens_light,
'e2': e2_lens_light,
'center_x': center_x_lens_light,
'center_y': center_y_lens_light
}
lens_light_model_list = ['SERSIC_ELLIPSE']
kwargs_lens_light = [kwargs_sersic_lens]
lens_light_model_class = LightModel(light_model_list=lens_light_model_list)
##
lensEquationSolver = LensEquationSolver(lens_model_class)
x_image, y_image = lensEquationSolver.findBrightImage(
source_x,
source_y, #position of ps
kwargs_lens, #lens proporties
numImages=4, #expected number of images
min_distance=deltaPix, #'resolution'
search_window=numPix * deltaPix) #search window limits
mag = lens_model_class.magnification(
x_image,
y_image, #for found above ps positions
kwargs=kwargs_lens) # and same lens properties
kwargs_ps = [{
'ra_image': x_image,
'dec_image': y_image,
'point_amp': np.abs(mag) * amp_ps
}]
point_source_list = ['LENSED_POSITION']
point_source_class = PointSource(point_source_type_list=point_source_list,
fixed_magnification_list=[False])
kwargs_numerics = {'supersampling_factor': supersampling_factor}
imageModel = ImageModel(
data_class, # take generated above data specs
psf_class, # same for psf
lens_model_class, # lens model (gal+ext)
source_model_class, # sourse light model
lens_light_model_class, # lens light model
point_source_class, # add generated ps images
kwargs_numerics=kwargs_numerics)
image_sim = imageModel.image(kwargs_lens, kwargs_source, kwargs_lens_light,
kwargs_ps)
poisson = image_util.add_poisson(image_sim, exp_time=exp_time)
bkg = image_util.add_background(image_sim, sigma_bkd=sigma_bkg)
image_sim = image_sim + bkg + poisson
data_class.update_data(image_sim)
kwargs_data['image_data'] = image_sim
cmap_string = 'gray'
cmap = plt.get_cmap(cmap_string)
cmap.set_bad(color='b', alpha=1.)
cmap.set_under('k')
f, axes = plt.subplots(1, 1, figsize=(6, 6), sharex=False, sharey=False)
ax = axes
im = ax.matshow(np.log10(image_sim),
origin='lower',
vmin=v_min,
vmax=v_max,
cmap=cmap,
extent=[0, 1, 0, 1])
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
ax.autoscale(False)
plt.show()
kwargs_model = {
'lens_model_list': lens_model_list,
'lens_light_model_list': lens_light_model_list,
'source_light_model_list': source_model_list,
'point_source_model_list': point_source_list
}
from lenstronomy.Analysis.td_cosmography import TDCosmography
td_cosmo = TDCosmography(z_lens,
z_source,
kwargs_model,
cosmo_fiducial=cosmo)
# time delays, the unit [days] is matched when the lensing angles are in arcsec
t_days = td_cosmo.time_delays(kwargs_lens, kwargs_ps, kappa_ext=0)
dt_days = t_days[1:] - t_days[0]
dt_sigma = [3, 5, 10] # Gaussian errors
dt_measured = np.random.normal(dt_days, dt_sigma)
print("the measured relative delays are: ", dt_measured)
return f, source_model_list, kwargs_data, kwargs_psf, kwargs_numerics, dt_measured, dt_sigma, kwargs_ps, lens_model_list, lens_light_model_list, source_model_list, point_source_list, lens_model_class2