def test_find_source_pixel(self): lensing_op = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix, source_interpolation='nearest') beta_x, beta_y = self.lens_model.ray_shooting( lensing_op.imagePlane.theta_x, lensing_op.imagePlane.theta_y, self.kwargs_lens) i = 10 j = lensing_op._find_source_pixel_nearest_legacy(i, beta_x, beta_y) assert (isinstance(j, int) or isinstance(j, np.int64))
def test_image2source(self): lensing_op = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix) image_1d = util.image2array(self.source_light_lensed) image_1d_delensed = lensing_op.image2source( image_1d, kwargs_lens=self.kwargs_lens) assert len(image_1d_delensed.shape) == 1 image_2d = self.source_light_lensed image_2d_delensed = lensing_op.image2source_2d( image_2d, kwargs_lens=self.kwargs_lens, update_mapping=True) assert len(image_2d_delensed.shape) == 2
def test_image_plane_coordinates(self): lensing_op = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix) theta_x, theta_y = lensing_op.image_plane_coordinates assert theta_x.size == self.num_pix**2 assert theta_y.size == self.num_pix**2
def test_source_plane_coordinates(self): lensing_op = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix) theta_x, theta_y = lensing_op.source_plane_coordinates assert theta_x.size == self.num_pix**2 assert theta_y.size == self.num_pix**2 subgrid_res = 2 source_grid_class = NumericsSubFrame( self.data, self.psf, supersampling_factor=subgrid_res).grid_class lensing_op = LensingOperator(self.lens_model, self.image_grid_class, source_grid_class, self.num_pix) theta_x, theta_y = lensing_op.source_plane_coordinates assert theta_x.size == self.num_pix**2 * subgrid_res**2 assert theta_y.size == self.num_pix**2 * subgrid_res**2
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 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 test_interpol_mapping(self): """testing than image2source / source2image are close to the parametric mapping""" lensing_op = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix, source_interpolation='bilinear') lensing_op.update_mapping(self.kwargs_lens) source_1d = util.image2array(self.source_light_delensed) image_1d = util.image2array(self.source_light_lensed) source_1d_lensed = lensing_op.source2image(source_1d) image_1d_delensed = lensing_op.image2source(image_1d) assert source_1d_lensed.shape == image_1d.shape assert image_1d_delensed.shape == source_1d.shape npt.assert_almost_equal(source_1d_lensed / source_1d_lensed.max(), image_1d / image_1d.max(), decimal=0.8) npt.assert_almost_equal(image_1d_delensed / image_1d_delensed.max(), source_1d / source_1d.max(), decimal=0.8)
def setup(self): self.num_pix = 49 # cutout pixel size self.subgrid_res_source = 2 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) self.image_data = np.random.rand(self.num_pix, self.num_pix) kwargs_data = { 'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0, 'transform_pix2angle': Mpix2coord, 'image_data': self.image_data, } data = ImageData(**kwargs_data) lens_model = LensModel(['SPEP']) kwargs_lens = [{ 'theta_E': 1, 'gamma': 2, 'center_x': 0, 'center_y': 0, 'e1': -0.05, 'e2': 0.05 }] # PSF kernel_pixel = np.zeros((self.num_pix, self.num_pix)) kernel_pixel[int(self.num_pix / 2), int(self.num_pix / 2)] = 1 # just a dirac here kwargs_psf = {'psf_type': 'PIXEL', 'kernel_point_source': kernel_pixel} psf = PSF(**kwargs_psf) # wavelets scales for lens and source self.n_scales_source = 4 self.n_scales_lens = 3 # list of source light profiles source_model = LightModel(['SLIT_STARLETS']) self.kwargs_source = [{'n_scales': self.n_scales_source}] # list of lens light profiles lens_light_model = LightModel(['SLIT_STARLETS']) self.kwargs_lens_light = [{'n_scales': self.n_scales_lens}] # define some mask likelihood_mask = np.ones((self.num_pix, self.num_pix)) # get grid classes self.numerics = NumericsSubFrame(data, psf) image_grid_class = self.numerics.grid_class source_numerics = NumericsSubFrame( data, psf, supersampling_factor=self.subgrid_res_source) source_grid_class = source_numerics.grid_class # get a lensing operator self.lensing_op = LensingOperator(lens_model, image_grid_class, source_grid_class, self.num_pix) self.lensing_op.update_mapping(kwargs_lens) self.model_op = ModelOperators(data, self.lensing_op, self.numerics) self.model_op._set_likelihood_mask(likelihood_mask) self.model_op.add_source_light(source_model) self.model_op.add_lens_light(lens_light_model) self.model_op_nolens = ModelOperators(data, self.lensing_op, self.numerics) self.model_op_nolens._set_likelihood_mask(likelihood_mask) self.model_op_nolens.add_source_light(source_model) # define some test images in direct space self.X_s = np.random.rand(self.num_pix_source, self.num_pix_source) # source light self.X_l = np.random.rand(self.num_pix, self.num_pix) # lens light # define some test images in wavelets space self.alpha_s = np.random.rand(self.n_scales_source, self.num_pix_source, self.num_pix_source) # source light self.alpha_l = np.random.rand(self.n_scales_lens, self.num_pix, self.num_pix) # lens light
class TestModelOperators(object): """ tests the Lensing Operator classes """ def setup(self): self.num_pix = 49 # cutout pixel size self.subgrid_res_source = 2 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) self.image_data = np.random.rand(self.num_pix, self.num_pix) kwargs_data = { 'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0, 'transform_pix2angle': Mpix2coord, 'image_data': self.image_data, } data = ImageData(**kwargs_data) lens_model = LensModel(['SPEP']) kwargs_lens = [{ 'theta_E': 1, 'gamma': 2, 'center_x': 0, 'center_y': 0, 'e1': -0.05, 'e2': 0.05 }] # PSF kernel_pixel = np.zeros((self.num_pix, self.num_pix)) kernel_pixel[int(self.num_pix / 2), int(self.num_pix / 2)] = 1 # just a dirac here kwargs_psf = {'psf_type': 'PIXEL', 'kernel_point_source': kernel_pixel} psf = PSF(**kwargs_psf) # wavelets scales for lens and source self.n_scales_source = 4 self.n_scales_lens = 3 # list of source light profiles source_model = LightModel(['SLIT_STARLETS']) self.kwargs_source = [{'n_scales': self.n_scales_source}] # list of lens light profiles lens_light_model = LightModel(['SLIT_STARLETS']) self.kwargs_lens_light = [{'n_scales': self.n_scales_lens}] # define some mask likelihood_mask = np.ones((self.num_pix, self.num_pix)) # get grid classes self.numerics = NumericsSubFrame(data, psf) image_grid_class = self.numerics.grid_class source_numerics = NumericsSubFrame( data, psf, supersampling_factor=self.subgrid_res_source) source_grid_class = source_numerics.grid_class # get a lensing operator self.lensing_op = LensingOperator(lens_model, image_grid_class, source_grid_class, self.num_pix) self.lensing_op.update_mapping(kwargs_lens) self.model_op = ModelOperators(data, self.lensing_op, self.numerics) self.model_op._set_likelihood_mask(likelihood_mask) self.model_op.add_source_light(source_model) self.model_op.add_lens_light(lens_light_model) self.model_op_nolens = ModelOperators(data, self.lensing_op, self.numerics) self.model_op_nolens._set_likelihood_mask(likelihood_mask) self.model_op_nolens.add_source_light(source_model) # define some test images in direct space self.X_s = np.random.rand(self.num_pix_source, self.num_pix_source) # source light self.X_l = np.random.rand(self.num_pix, self.num_pix) # lens light # define some test images in wavelets space self.alpha_s = np.random.rand(self.n_scales_source, self.num_pix_source, self.num_pix_source) # source light self.alpha_l = np.random.rand(self.n_scales_lens, self.num_pix, self.num_pix) # lens light def test_set_wavelet_scales(self): self.model_op.set_source_wavelet_scales(self.n_scales_source) Phi_T_s_X = self.model_op.Phi_T_s(self.X_s) self.model_op.set_lens_wavelet_scales(self.n_scales_lens) Phi_T_l_X = self.model_op.Phi_T_l(self.X_l) # test that transformed image has the right shape in terms of number of scales assert Phi_T_s_X.shape[0] == self.n_scales_source assert Phi_T_l_X.shape[0] == self.n_scales_lens def test_subtract_from_data_and_reset(self): image_to_subtract = np.eye(self.num_pix, self.num_pix) self.model_op.subtract_from_data(image_to_subtract) npt.assert_equal(self.model_op.Y, self.image_data) npt.assert_equal(self.model_op.Y_eff, self.image_data - image_to_subtract) self.model_op.reset_data() npt.assert_equal(self.model_op.Y, self.image_data) npt.assert_equal(self.model_op.Y_eff, self.image_data) def test_spectral_norm_source(self): self.model_op.set_source_wavelet_scales(self.n_scales_source) npt.assert_almost_equal(self.model_op.spectral_norm_source, 0.97, decimal=2) def test_spectral_norm_lens(self): self.model_op.set_lens_wavelet_scales(self.n_scales_lens) npt.assert_almost_equal(self.model_op.spectral_norm_lens, 0.99, decimal=2) def test_data_terms(self): npt.assert_equal(self.model_op.Y, self.image_data) npt.assert_equal(self.model_op.Y_eff, self.image_data) def test_convolution(self): H_X_s = self.model_op.H(self.X_s) npt.assert_equal( H_X_s, self.numerics.convolution_class.convolution2d(self.X_s)) H_T_X_s = self.model_op.H_T(self.X_s) conv_transpose = self.numerics.convolution_class.copy_transpose() npt.assert_equal(H_T_X_s, conv_transpose.convolution2d(self.X_s)) def test_lensing(self): F_X_s = self.model_op.F(self.X_s) npt.assert_equal(F_X_s, self.lensing_op.source2image_2d(self.X_s)) F_T_X_l = self.model_op.F_T(self.X_l) npt.assert_equal(F_T_X_l, self.lensing_op.image2source_2d(self.X_l)) def test_wavelet_transform(self): # TODO : do more accurate tests here self.model_op.set_source_wavelet_scales(self.n_scales_source) self.model_op.set_lens_wavelet_scales(self.n_scales_lens) Phi_alpha_s = self.model_op.Phi_s(self.alpha_s) Phi_alpha_l = self.model_op.Phi_l(self.alpha_l) assert Phi_alpha_s.shape == (self.num_pix * self.subgrid_res_source, self.num_pix * self.subgrid_res_source) assert Phi_alpha_l.shape == (self.num_pix, self.num_pix) Phi_T_X_s = self.model_op.Phi_T_s(self.X_s) Phi_T_X_l = self.model_op.Phi_T_l(self.X_l) assert Phi_T_X_s.shape == (self.n_scales_source, self.num_pix * self.subgrid_res_source, self.num_pix * self.subgrid_res_source) assert Phi_T_X_l.shape == (self.n_scales_lens, self.num_pix, self.num_pix)
def __init__(self, data_class, lens_model_class, image_numerics_class, source_numerics_class, lens_light_mask=None, source_interpolation='bilinear', minimal_source_plane=False, use_mask_for_minimal_source_plane=True, min_num_pix_source=20, min_threshold=3, threshold_increment_high_freq=1, threshold_decrease_type='exponential', fixed_spectral_norm_source=0.98, include_regridding_error=False, sparsity_prior_norm=1, force_positivity=True, formulation='analysis', external_likelihood_penalty=False, random_seed=None, verbose=False, show_steps=False, thread_count=1): """ :param data_class: lenstronomy.imaging_data.ImageData instance describing the data. :param lens_model_class: lenstronomy.lens_model.LensModel instance describing the lens mass model. :param image_numerics_class: lenstronomy.ImSim.Numerics.numerics_subframe.NumericsSubFrame instance for image plane. :param source_numerics_class: lenstronomy.ImSim.Numerics.numerics_subframe.NumericsSubFrame instance for source plane. :param lens_light_mask: boolean mask with False/0 to exclude pixels that are assumed to contain only lens light flux. Defaults to None. :param source_interpolation: type of interpolation of source pixels on the source plane grid. It can be 'nearest' for nearest-neighbor or 'bilinear' for bilinear interpolation. Defaults to 'bilinear'. :param minimal_source_plane: if True, reduce the source plane grid size to the minimum set by min_num_pix_source. Defaults to False. :param use_mask_for_minimal_source_plane: if True, use the likelihood_mask to compute minimal source plane. Defaults to True. :param min_num_pix_source: minimal number of pixels on a side of the square source grid. Only used when minimal_source_plane is True. Defaults to 20. :param min_threshold: in unit of the noise (sigma), minimum threshold for wavelets denoising. Typically between 3 (more conservative thresholding) and 5 (more aggressive thresholding). Defaults to 3. :param threshold_increment_high_freq: additive number to the threshold level (in unit of the noise) for the highest frequencies on wavelets space. Defaults to 1. :param threshold_decrease_type: strategy for decreasing the threshold level at each iteration. Can be 'none' (no decrease, directly sets to min_threshold), 'linear' or 'exponential'. Defaults to None, which is 'exponential' for the source-only solver, 'linear' for the source-lens solver. :param fixed_spectral_norm_source: if None, update the spectral norm for the source operator, for optimal gradient descent step size. Defaults to 0.98, which is a conservative value typical of most lens models. :param sparsity_prior_norm: prior l-norm (0 or 1). If 1, l1-norm and soft-thresholding are applied. If 0, it is l0-norm and hard-thresholding. Defaults to 1. :param force_positivity: if True, apply positivity constraint to the source flux. Defaults to True. :param formulation: type of formalism for the minimization problem. 'analysis' solves the problem in direct space. 'synthesis' solves the peoblem in wavelets space. Defaults to 'analysis'. :param external_likelihood_penalty: if True, the solve() method returns a non-zero penalty, e.g. for penalize more a given lens model during lens model optimization. Defaults to False. :param random_seed: seed for random number generator, used to initialise the algorithm. None for no seed. Defaults to None. :param verbose: if True, prints statements during optimization. Defaults to False. :param show_steps: if True, displays plot of the reconstructed light profiles during optimization. Defaults to False. :param thread_count: number of threads (multithreading) to speedup wavelets computations (only works if pySAP is properly installed). Defaults to 1. """ num_pix_x, num_pix_y = data_class.num_pixel_axes if num_pix_x != num_pix_y: raise ValueError("Only square images are supported") image_grid_class = image_numerics_class.grid_class source_grid_class = source_numerics_class.grid_class lensing_operator_class = LensingOperator( lens_model_class, image_grid_class, source_grid_class, num_pix_x, lens_light_mask=lens_light_mask, minimal_source_plane=minimal_source_plane, min_num_pix_source=min_num_pix_source, use_mask_for_minimal_source_plane=use_mask_for_minimal_source_plane, source_interpolation=source_interpolation, verbose=verbose) super(SparseSolverBase, self).__init__( data_class, lensing_operator_class, image_numerics_class, fixed_spectral_norm_source=fixed_spectral_norm_source, thread_count=thread_count, random_seed=random_seed) # engine that computes noise levels in image / source plane, in wavelets space self.noise = NoiseLevels( data_class, subgrid_res_source=source_grid_class.supersampling_factor, include_regridding_error=include_regridding_error) # threshold level k_min (in units of the noise) self._k_min = min_threshold if threshold_increment_high_freq < 0: raise ValueError( "threshold_increment_high_freq cannot be negative") else: self._increm_high_freq = threshold_increment_high_freq # strategy to decrease threshold up to the max threshold above if threshold_decrease_type not in [ 'none', 'lin', 'linear', 'exp', 'exponential' ]: raise ValueError( "threshold_decrease_type must be in ['none', 'lin', 'linear', 'exp', 'exponential']" ) self._threshold_decrease_type = threshold_decrease_type if sparsity_prior_norm not in [0, 1]: raise ValueError( "Sparsity prior norm can only be 0 or 1 (l0-norm or l1-norm)") self._sparsity_prior_norm = sparsity_prior_norm self._formulation = formulation self._force_positivity = force_positivity self._external_likelihood_penalty = external_likelihood_penalty self._verbose = verbose self._show_steps = show_steps self._tracker = SolverTracker(self, verbose=verbose) self._plotter = SolverPlotter(self, show_now=True)
def test_minimal_source_plane(self): source_1d = util.image2array(self.source_light_delensed) # test with no mask lensing_op = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix, source_interpolation='nearest', minimal_source_plane=True) lensing_op.update_mapping(self.kwargs_lens) image_1d = util.image2array(self.source_light_lensed) assert lensing_op.image2source(image_1d).size < source_1d.size # test with mask lensing_op = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix, source_interpolation='nearest', minimal_source_plane=True) lensing_op.set_likelihood_mask(self.likelihood_mask) lensing_op.update_mapping(self.kwargs_lens) image_1d = util.image2array(self.source_light_lensed) assert lensing_op.image2source(image_1d).size < source_1d.size # for 'bilinear' operator, only works with no mask (for now) lensing_op = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix, source_interpolation='bilinear', minimal_source_plane=True) lensing_op.update_mapping(self.kwargs_lens) image_1d = util.image2array(self.source_light_lensed) assert lensing_op.image2source(image_1d).size < source_1d.size
def test_matrix_product(self): lensing_op = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix, source_interpolation='nearest_legacy') lensing_op.update_mapping(self.kwargs_lens) lensing_op_mat = LensingOperator(self.lens_model, self.image_grid_class, self.source_grid_class_default, self.num_pix, source_interpolation='nearest') lensing_op_mat.update_mapping(self.kwargs_lens) source_1d = util.image2array(self.source_light_delensed) image_1d = util.image2array(self.source_light_lensed) npt.assert_equal(lensing_op.source2image(source_1d), lensing_op_mat.source2image(source_1d)) npt.assert_equal(lensing_op.image2source(image_1d), lensing_op_mat.image2source(image_1d))
def setup(self): self.num_pix = 49 # cutout pixel size self.subgrid_res_source = 2 self.num_pix_source = self.num_pix * self.subgrid_res_source self.background_rms = 0.05 self.noise_map = self.background_rms * np.ones( (self.num_pix, self.num_pix)) 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) self.image_data = np.random.rand(self.num_pix, self.num_pix) kwargs_data = { 'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0, 'transform_pix2angle': Mpix2coord, 'image_data': self.image_data, 'background_rms': self.background_rms, 'noise_map': self.noise_map, } data = ImageData(**kwargs_data) gaussian_func = Gaussian() x, y = l_util.make_grid(41, 1) gaussian = gaussian_func.function(x, y, amp=1, sigma=0.02, center_x=0, center_y=0) self.psf_kernel = gaussian / gaussian.sum() lens_model = LensModel(['SPEP']) self.kwargs_lens = [{ 'theta_E': 1, 'gamma': 2, 'center_x': 0, 'center_y': 0, 'e1': -0.05, 'e2': 0.05 }] # wavelets scales for lens and source self.n_scales_source = 4 self.n_scales_lens = 3 # list of source light profiles self.source_model = LightModel(['SLIT_STARLETS']) self.kwargs_source = [{'n_scales': self.n_scales_source}] # list of lens light profiles self.lens_light_model = LightModel(['SLIT_STARLETS']) self.kwargs_lens_light = [{'n_scales': self.n_scales_lens}] # get grid classes image_grid_class = NumericsSubFrame(data, PSF('NONE')).grid_class source_grid_class = NumericsSubFrame( data, PSF('NONE'), supersampling_factor=self.subgrid_res_source).grid_class # get a lensing operator self.lensing_op = LensingOperator(lens_model, image_grid_class, source_grid_class, self.num_pix) self.noise_class = NoiseLevels( data, subgrid_res_source=self.subgrid_res_source, include_regridding_error=False) self.noise_class_regrid = NoiseLevels( data, subgrid_res_source=self.subgrid_res_source, include_regridding_error=True)
class TestNoiseLevels(object): """ tests the Lensing Operator classes """ def setup(self): self.num_pix = 49 # cutout pixel size self.subgrid_res_source = 2 self.num_pix_source = self.num_pix * self.subgrid_res_source self.background_rms = 0.05 self.noise_map = self.background_rms * np.ones( (self.num_pix, self.num_pix)) 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) self.image_data = np.random.rand(self.num_pix, self.num_pix) kwargs_data = { 'ra_at_xy_0': ra_at_xy_0, 'dec_at_xy_0': dec_at_xy_0, 'transform_pix2angle': Mpix2coord, 'image_data': self.image_data, 'background_rms': self.background_rms, 'noise_map': self.noise_map, } data = ImageData(**kwargs_data) gaussian_func = Gaussian() x, y = l_util.make_grid(41, 1) gaussian = gaussian_func.function(x, y, amp=1, sigma=0.02, center_x=0, center_y=0) self.psf_kernel = gaussian / gaussian.sum() lens_model = LensModel(['SPEP']) self.kwargs_lens = [{ 'theta_E': 1, 'gamma': 2, 'center_x': 0, 'center_y': 0, 'e1': -0.05, 'e2': 0.05 }] # wavelets scales for lens and source self.n_scales_source = 4 self.n_scales_lens = 3 # list of source light profiles self.source_model = LightModel(['SLIT_STARLETS']) self.kwargs_source = [{'n_scales': self.n_scales_source}] # list of lens light profiles self.lens_light_model = LightModel(['SLIT_STARLETS']) self.kwargs_lens_light = [{'n_scales': self.n_scales_lens}] # get grid classes image_grid_class = NumericsSubFrame(data, PSF('NONE')).grid_class source_grid_class = NumericsSubFrame( data, PSF('NONE'), supersampling_factor=self.subgrid_res_source).grid_class # get a lensing operator self.lensing_op = LensingOperator(lens_model, image_grid_class, source_grid_class, self.num_pix) self.noise_class = NoiseLevels( data, subgrid_res_source=self.subgrid_res_source, include_regridding_error=False) self.noise_class_regrid = NoiseLevels( data, subgrid_res_source=self.subgrid_res_source, include_regridding_error=True) def test_background_rms(self): assert self.background_rms == self.noise_class.background_rms def test_noise_map(self): npt.assert_equal(self.noise_map, self.noise_class.noise_map) npt.assert_equal(self.noise_map, self.noise_class_regrid.noise_map) npt.assert_equal(self.noise_map, self.noise_class.effective_noise_map) def test_update_source_levels(self): wavelet_transform_source = lambda x: self.source_model.func_list[ 0].decomposition_2d(x, self.kwargs_source[0]['n_scales']) image2source_transform = lambda x: self.lensing_op.image2source_2d( x, kwargs_lens=self.kwargs_lens) upscale_transform = lambda x: x self.noise_class.update_source_levels( self.num_pix, self.num_pix_source, wavelet_transform_source, image2source_transform, upscale_transform, psf_kernel=None) # without psf_kernel specified assert self.noise_class.levels_source.shape == (self.n_scales_source, self.num_pix_source, self.num_pix_source) self.noise_class.update_source_levels(self.num_pix, self.num_pix_source, wavelet_transform_source, image2source_transform, upscale_transform, psf_kernel=self.psf_kernel) assert self.noise_class.levels_source.shape == (self.n_scales_source, self.num_pix_source, self.num_pix_source) def test_update_image_levels(self): wavelet_transform_image = lambda x: self.lens_light_model.func_list[ 0].decomposition_2d(x, self.kwargs_lens_light[0]['n_scales']) self.noise_class.update_image_levels(self.num_pix, wavelet_transform_image) assert self.noise_class.levels_image.shape == (self.n_scales_lens, self.num_pix, self.num_pix) def test_update_regridding_error(self): magnification_map = self.lensing_op.magnification_map(self.kwargs_lens) self.noise_class.update_regridding_error( magnification_map) # should do nothing npt.assert_equal(self.noise_class.effective_noise_map, self.noise_map) self.noise_class_regrid.update_regridding_error(magnification_map) npt.assert_equal( self.noise_class_regrid.effective_noise_map, np.sqrt(self.noise_map**2 + self.noise_class_regrid.regridding_error_map**2))