def test_make_subgrid():
numPix = 101
deltapix = 1
x_grid, y_grid = util.make_grid(numPix, deltapix, subgrid_res=1)
x_sub_grid, y_sub_grid = util.make_subgrid(x_grid, y_grid, subgrid_res=2)
assert np.sum(x_grid) == 0
assert x_sub_grid[0] == -50.25
assert y_sub_grid[17] == -50.25
x_sub_grid_new, y_sub_grid_new = util.make_subgrid(x_grid, y_grid, subgrid_res=4)
assert x_sub_grid_new[0] == -50.375
def __init__(self, nx, ny, transform_pix2angle, ra_at_xy_0, dec_at_xy_0, supersampling_factor=1,
flux_evaluate_indexes=None):
"""
:param nx: number of pixels in x-axis
:param ny: number of pixels in y-axis
:param transform_pix2angle: 2x2 matrix, mapping of pixel to coordinate
:param ra_at_xy_0: ra coordinate at pixel (0,0)
:param dec_at_xy_0: dec coordinate at pixel (0,0)
:param supersampling_factor: int, factor (per axis) of super-sampling
:param flux_evaluate_indexes: bool array of shape nx x ny, corresponding to pixels being evaluated
(for both low and high res). Default is None, replaced by setting all pixels to being evaluated.
"""
super(RegularGrid, self).__init__(transform_pix2angle, ra_at_xy_0, dec_at_xy_0)
self._supersampling_factor = supersampling_factor
self._nx = nx
self._ny = ny
self._x_grid, self._y_grid = self.coordinate_grid(nx, ny)
if flux_evaluate_indexes is None:
flux_evaluate_indexes = np.ones_like(self._x_grid, dtype=bool)
else:
flux_evaluate_indexes = util.image2array(flux_evaluate_indexes)
self._compute_indexes = self._subgrid_index(flux_evaluate_indexes, self._supersampling_factor, self._nx, self._ny)
x_grid_sub, y_grid_sub = util.make_subgrid(self._x_grid, self._y_grid, self._supersampling_factor)
self._ra_subgrid = x_grid_sub[self._compute_indexes]
self._dec_subgrid = y_grid_sub[self._compute_indexes]
def __init__(self,
image,
sigma,
poisson,
sampling_option,
deltaPix=1,
mask=None,
subgrid_res=1,
x_grid=None,
y_grid=None):
"""
initializes all the classes needed for the chain
"""
self.image = util.image2array(image)
self.numPix = len(image)
self.deltaPix = deltaPix
self.subgrid_res = subgrid_res
self.background = sigma
self.poisson = poisson
if x_grid is None or y_grid is None:
self.x_grid, self.y_grid = util.make_grid(self.numPix, deltaPix,
subgrid_res)
else:
self.x_grid, self.y_grid = util.make_subgrid(
x_grid, y_grid, subgrid_res)
self.gaussian = Gaussian()
self.moffat = Moffat()
self.sampling_option = sampling_option
if not mask is None:
self.mask = util.image2array(mask)
else:
self.mask = np.ones((self.numPix, self.numPix))
def _check_subgrid(self):
if not hasattr(self, '_ra_subgrid') or not hasattr(
self, '_dec_subgrid'):
ra_grid, dec_grid = self._Data.coordinates
ra_grid = util.image2array(ra_grid)
dec_grid = util.image2array(dec_grid)
x_grid_sub, y_grid_sub = util.make_subgrid(ra_grid, dec_grid,
self._subgrid_res)
self._ra_subgrid = x_grid_sub[self._idex_mask_sub == 1]
self._dec_subgrid = y_grid_sub[self._idex_mask_sub == 1]
def make_image_fixed_source(self,
param,
kwargs_options,
kwargs_data,
kwargs_lens,
kwargs_source,
kwargs_psf,
kwargs_lens_light,
kwargs_else,
add_noise=False):
"""
make an image with fixed source parameters
:param kwargs_lens:
:param kwargs_source:
:param kwargs_psf:
:param kwargs_lens_light:
:param kwargs_else:
:return:
"""
subgrid_res = kwargs_options['subgrid_res']
num_order = kwargs_options.get('shapelet_order', 0)
image = []
residuals = []
for i in range(self.num_bands(kwargs_data)):
kwargs_data_i = kwargs_data[i]
kwargs_psf_i = kwargs_psf["image" + str(i + 1)]
param_i = param[i]
deltaPix = kwargs_data_i['deltaPix']
x_grid, y_grid = kwargs_data_i['x_coords'], kwargs_data_i[
'y_coords']
x_grid_sub, y_grid_sub = util.make_subgrid(x_grid, y_grid,
subgrid_res)
numPix = len(kwargs_data_i['image_data'])
makeImage = ImageModel(kwargs_options, kwargs_data_i)
image_i, error_map = makeImage.make_image_with_params(
x_grid_sub, y_grid_sub, kwargs_lens, kwargs_source,
kwargs_psf_i, kwargs_lens_light, kwargs_else, numPix, deltaPix,
subgrid_res, param_i, num_order)
residuals_i = util.image2array(
makeImage.reduced_residuals(image_i, error_map))
residuals.append(residuals_i)
if add_noise:
image_i = makeImage.add_noise2image(image_i)
image.append(image_i)
return image, residuals
def test_rescaled_grid(self):
import lenstronomy.Util.util as util
numPix = 10
theta = 0.5
deltaPix = 0.05
subgrid_res = 3
Mpix2a = np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]]) * deltaPix
x_grid, y_grid = util.make_grid_transformed(numPix, Mpix2a)
coords = Coordinates(Mpix2a,
ra_at_xy_0=x_grid[0],
dec_at_xy_0=y_grid[0])
x_grid_high_res, y_grid_high_res = util.make_subgrid(
x_grid, y_grid, subgrid_res=subgrid_res)
coords_sub = Coordinates(Mpix2a / subgrid_res,
ra_at_xy_0=x_grid_high_res[0],
dec_at_xy_0=y_grid_high_res[0])
x, y = coords_sub.map_coord2pix(x_grid[1], y_grid[1])
npt.assert_almost_equal(x, 4, decimal=10)
npt.assert_almost_equal(y, 1, decimal=10)
x, y = coords_sub.map_coord2pix(x_grid[0], y_grid[0])
npt.assert_almost_equal(x, 1, decimal=10)
npt.assert_almost_equal(y, 1, decimal=10)
ra, dec = coords_sub.map_pix2coord(1, 1)
npt.assert_almost_equal(ra, x_grid[0], decimal=10)
npt.assert_almost_equal(dec, y_grid[0], decimal=10)
ra, dec = coords_sub.map_pix2coord(1 + 2 * subgrid_res, 1)
npt.assert_almost_equal(ra, x_grid[2], decimal=10)
npt.assert_almost_equal(dec, y_grid[2], decimal=10)
x_2d = util.array2image(x_grid)
y_2d = util.array2image(y_grid)
ra, dec = coords_sub.map_pix2coord(1 + 2 * subgrid_res,
1 + 3 * subgrid_res)
npt.assert_almost_equal(ra, x_2d[3, 2], decimal=10)
npt.assert_almost_equal(dec, y_2d[3, 2], decimal=10)
ra, dec = coords.map_pix2coord(2, 3)
npt.assert_almost_equal(ra, x_2d[3, 2], decimal=10)
npt.assert_almost_equal(dec, y_2d[3, 2], decimal=10)
def make_mock_image(self,
kwargs_options,
kwargs_data,
kwargs_lens,
kwargs_source,
kwargs_psf,
kwargs_lens_light,
kwargs_else,
add_noise=False,
noMask=True):
"""
:return: mock image, without substructure
"""
subgrid_res = kwargs_options['subgrid_res']
image = []
param = []
residuals = []
for i in range(self.num_bands(kwargs_data)):
kwargs_data_i = kwargs_data[i]
kwargs_psf_i = kwargs_psf["image" + str(i + 1)]
deltaPix = kwargs_data_i['deltaPix']
x_grid, y_grid = kwargs_data_i['x_coords'], kwargs_data_i[
'y_coords']
x_grid_sub, y_grid_sub = util.make_subgrid(x_grid, y_grid,
subgrid_res)
numPix = len(kwargs_data_i['image_data'])
makeImage = ImageModel(kwargs_options, kwargs_data_i)
if noMask:
image_i, param_i, error_map = makeImage.make_image_ideal_noMask(
x_grid_sub,
y_grid_sub,
kwargs_lens,
kwargs_source,
kwargs_psf_i,
kwargs_lens_light,
kwargs_else,
numPix,
deltaPix,
subgrid_res,
inv_bool=False)
else:
image_i, error_map, cov_param, param_i = makeImage.make_image_ideal(
x_grid_sub,
y_grid_sub,
kwargs_lens,
kwargs_source,
kwargs_psf_i,
kwargs_lens_light,
kwargs_else,
numPix,
deltaPix,
subgrid_res,
inv_bool=False)
residuals_i = util.image2array(
makeImage.reduced_residuals(image_i, error_map))
residuals.append(residuals_i)
if add_noise:
image_i = makeImage.add_noise2image(image_i)
image.append(image_i)
param.append(param_i)
return image, param, residuals
