def test_pixel_kernel():
# point source kernel
kernel_size = 9
kernel = np.zeros((kernel_size, kernel_size))
kernel[4, 4] = 1.
pixel_kernel = kernel_util.pixel_kernel(point_source_kernel=kernel, subgrid_res=1)
assert pixel_kernel[4, 4] == kernel[4, 4]
pixel_kernel = kernel_util.pixel_kernel(point_source_kernel=kernel, subgrid_res=11)
npt.assert_almost_equal(pixel_kernel[4, 4], 0.65841, decimal=3)
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}
elif psf_type == 'NONE':
kwargs_psf = {'psf_type': 'NONE'}
else:
raise ValueError("psf type %s not supported!" % psf_type)
psf_class = PSF(kwargs_psf)
return psf_class
def kernel_pixel(self):
"""
returns the convolution kernel for a uniform surface brightness on a pixel size
:return: 2d numpy array
"""
if not hasattr(self, '_kernel_pixel'):
self._kernel_pixel = kernel_util.pixel_kernel(self.kernel_point_source, subgrid_res=1)
return self._kernel_pixel
def update_psf(self, kwargs_psf, kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps, factor=1, symmetry=1):
"""
:param kwargs_data:
:param kwargs_psf:
:param kwargs_options:
:param kwargs_lens:
:param kwargs_source:
:param kwargs_lens_light:
:param kwargs_ps:
:return:
"""
psf_class = PSF(kwargs_psf)
self._image_model_class.update_psf(psf_class)
self._image_model_class.update_numerics(self._kwargs_numerics)
kernel_old = psf_class.kernel_point_source
kernel_small = psf_class.kernel_pixel
kernel_size = len(kernel_old)
kernelsize_small = len(kernel_small)
kwargs_numerics_psf = copy.deepcopy(self._kwargs_numerics)
kwargs_numerics_psf['psf_error_map'] = False
self._image_model_class.update_numerics(kwargs_numerics_psf)
image_single_point_source_list = self.image_single_point_source(self._image_model_class, kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps)
ra_image, dec_image, amp = self._image_model_class.PointSource.point_source_list(kwargs_ps, kwargs_lens)
x_, y_ = self._image_model_class.Data.map_coord2pix(ra_image, dec_image)
mask = self._image_model_class.ImageNumerics.mask
x_grid, y_grid = self._image_model_class.Data.coordinates
deltaPix = self._image_model_class.Data.deltaPix
#fwhm = self._image_model_class.PSF.psf_fwhm(kwargs_psf, deltaPix)
radius = kwargs_psf.get("block_neighbour", 0.) / 2.
mask_point_source_list = self.mask_point_sources(ra_image, dec_image, x_grid, y_grid, radius)
point_source_list = self.cutout_psf(x_, y_, image_single_point_source_list, kernel_size, mask, mask_point_source_list, kernel_old, symmetry=symmetry)
kernel_old_array = np.zeros((symmetry, kernel_size, kernel_size))
for i in range(symmetry):
kernel_old_array[i, :, :] = kernel_old
kernel_new, error_map = self.combine_psf(point_source_list, kernel_old_array,
sigma_bkg=self._image_model_class.Data.background_rms, factor=factor)
kernel_new_small = copy.deepcopy(kernel_new)
kernel_new_small = kernel_util.pixel_kernel(kernel_new_small, subgrid_res=3)
kernel_new_small = kernel_util.cut_psf(kernel_new_small, psf_size=kernelsize_small)
kernel_new = kernel_util.cut_psf(kernel_new, psf_size=kernel_size)
kwargs_psf_new = copy.deepcopy(kwargs_psf)
if not self._kwargs_numerics.get('psf_keep_small', False):
kwargs_psf_new['kernel_pixel'] = kernel_new_small
kwargs_psf_new['kernel_point_source'] = kernel_new
self._image_model_class.update_psf(PSF(kwargs_psf_new))
self._image_model_class.update_numerics(self._kwargs_numerics)
logL_after = self._image_model_class.likelihood_data_given_model(kwargs_lens, kwargs_source,
kwargs_lens_light, kwargs_ps)
if not self._kwargs_numerics.get('psf_keep_error_map', False):
kwargs_psf_new['psf_error_map'] = error_map
return kwargs_psf_new, logL_after
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 __init__(self, kwargs_psf):
self.psf_type = kwargs_psf.get('psf_type', 'NONE')
if self.psf_type == 'GAUSSIAN':
self._fwhm = kwargs_psf['fwhm']
self._sigma_gaussian = util.fwhm2sigma(self._fwhm)
self._truncation = kwargs_psf.get('truncation', 5 * self._fwhm)
if 'pixel_size' in kwargs_psf:
self._pixel_size = kwargs_psf['pixel_size']
elif self.psf_type == 'PIXEL':
if 'kernel_point_source_subsampled' in kwargs_psf:
self._kernel_point_source_subsampled = kwargs_psf[
'kernel_point_source_subsampled']
n_high = len(self._kernel_point_source_subsampled)
self._point_source_subsampling_factor = kwargs_psf[
'point_source_subsampling_factor']
numPix = int(n_high / self._point_source_subsampling_factor)
self._kernel_point_source = util.averaging(
self._kernel_point_source_subsampled,
numGrid=n_high,
numPix=numPix)
else:
self._kernel_point_source = kwargs_psf['kernel_point_source']
if 'kernel_pixel_subsampled' in kwargs_psf:
self._kernel_pixel_subsampled = kwargs_psf[
'kernel_pixel_subsampled']
n_high = len(self._kernel_point_source_subsampled)
self._pixel_subsampling_factor = kwargs_psf[
'pixel_subsampling_factor']
numPix = int(n_high / self._pixel_subsampling_factor)
self._kernel_pixel = util.averaging(
self._kernel_pixel_subsampled,
numGrid=n_high,
numPix=numPix)
else:
if 'kernel_pixel' in kwargs_psf:
self._kernel_pixel = kwargs_psf['kernel_pixel']
else:
self._kernel_pixel = kernel_util.pixel_kernel(
self._kernel_point_source, subgrid_res=1)
elif self.psf_type == 'NONE':
self._kernel_point_source = np.zeros((3, 3))
self._kernel_point_source[1, 1] = 1
else:
raise ValueError("psf_type %s not supported!" % self.psf_type)
if 'psf_error_map' in kwargs_psf:
self._psf_error_map = kwargs_psf['psf_error_map']
if len(self._psf_error_map) != len(self._kernel_point_source):
raise ValueError(
'psf_error_map must have same size as kernel_point_source!'
)
def __init__(self, kwargs_psf):
self.psf_type = kwargs_psf.get('psf_type', 'NONE')
if self.psf_type == 'GAUSSIAN':
self._fwhm = kwargs_psf['fwhm']
self._sigma_gaussian = util.fwhm2sigma(self._fwhm)
self._truncation = kwargs_psf.get('truncation', 5 * self._fwhm)
if 'pixel_size' in kwargs_psf:
self._pixel_size = kwargs_psf['pixel_size']
elif self.psf_type == 'PIXEL':
self._kernel_point_source = kwargs_psf['kernel_point_source']
if 'kernel_pixel' in kwargs_psf:
self._kernel_pixel = kwargs_psf['kernel_pixel']
else:
self._kernel_pixel = kernel_util.pixel_kernel(self._kernel_point_source, subgrid_res=7)
elif self.psf_type == 'NONE':
self._kernel_point_source = np.zeros((3, 3))
else:
raise ValueError("psf_type %s not supported!" % self.psf_type)
if 'psf_error_map' in kwargs_psf:
self._psf_error_map = kwargs_psf['psf_error_map']
