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 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 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 generate_image(kwargs_lens_mass, kwargs_src_light, psf_model, data_api, lens_mass_model, src_light_model): """Generate the image of a lensed extended source from provided model and model parameters Parameters ---------- kwargs_lens_mass : dict lens model parameters kwargs_src_light : dict host light model parameters psf_model : lenstronomy PSF object the PSF kernel point source map data_api : lenstronomy DataAPI object tool that handles detector and observation conditions Returns ------- tuple of (np.array, dict) the lensed image """ img_features = {} kwargs_numerics = {'supersampling_factor': 1} image_data = data_api.data_class # Instantiate image model lensed_image_model = ImageModel(image_data, psf_model, lens_mass_model, src_light_model, None, None, kwargs_numerics=kwargs_numerics) # Compute total magnification lensed_total_flux = get_lensed_total_flux(kwargs_lens_mass, kwargs_src_light, lensed_image_model) img_features['lensed_total_flux'] = lensed_total_flux #try: #unlensed_total_flux = get_unlenseD_total_flux_analytical(kwargs_src_light_list, src_light_model) unlensed_image_model = ImageModel(image_data, psf_model, None, src_light_model, None, None, kwargs_numerics=kwargs_numerics) unlensed_total_flux = get_unlensed_total_flux_numerical( kwargs_src_light, unlensed_image_model ) # analytical only runs for profiles that allow analytic integration img_features[ 'total_magnification'] = lensed_total_flux / unlensed_total_flux img_features['unlensed_total_flux'] = unlensed_total_flux #except: # pass # Generate image for export img = lensed_image_model.image(kwargs_lens_mass, kwargs_src_light, None, None) img = np.maximum(0.0, img) # safeguard against negative pixel values return img, img_features
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_low_res(self): image_model = ImageModel(self.pixel_grid, self.psf_class, lens_light_model_class=self.lightModel, kwargs_numerics=self.kwargs_numerics_low_res) image_conv = image_model.image(kwargs_lens_light=self.kwargs_light, unconvolved=False) npt.assert_almost_equal( (self.image_true - image_conv) / self.image_true, 0, decimal=1)
def test_sub_frame(self): image_model = ImageModel(self.pixel_grid, self.psf_class, lens_light_model_class=self.lightModel, kwargs_numerics=self.kwargs_numerics_partial) image_conv = image_model.image(kwargs_lens_light=self.kwargs_light, unconvolved=False) delta = (self.image_true - image_conv) / self.image_true npt.assert_almost_equal(delta[self._conv_pixels_partial], 0, decimal=1)
def setup(self): self.SimAPI = Simulation() # 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 = self.SimAPI.data_configure(numPix, deltaPix, exp_time, sigma_bkg) data_class = Data(kwargs_data) kwargs_psf = self.SimAPI.psf_configure(psf_type='GAUSSIAN', fwhm=fwhm, kernelsize=31, deltaPix=deltaPix, truncate=3, kernel=None) psf_class = PSF(kwargs_psf) psf_class._psf_error_map = np.zeros_like(psf_class.kernel_point_source) # 'EXERNAL_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.01, '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 = {'subgrid_res': 2, 'psf_subgrid': True} 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 = self.SimAPI.simulate(imageModel, self.kwargs_lens, self.kwargs_source, self.kwargs_lens_light, self.kwargs_ps) data_class.update_data(image_sim) self.imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics=kwargs_numerics) self.solver = LensEquationSolver(lensModel=self.imageModel.LensModel)
def test_full(self): image_model_true = ImageModel( self.pixel_grid, self.psf_class, lens_light_model_class=self.lightModel, kwargs_numerics=self.kwargs_numerics_true) image_unconvolved = image_model_true.image( kwargs_lens_light=self.kwargs_light, unconvolved=True) npt.assert_almost_equal(np.sum(self.image_true) / np.sum(image_unconvolved), 1, decimal=2)
def kappa_map(self, kwargs_options, kwargs_data, kwargs_lens, kwargs_else, x_clump, y_clump, phi_E_clump, r_trunc): """ :param kwargs_options: :param kwargs_data: :param kwargs_lens: :param kwargs_else: :return: """ kwargs_options_clump = copy.deepcopy(kwargs_options) kwargs_options_clump["add_clump"] = True clump_kwargs = { 'r_trunc': r_trunc, 'phi_E_clump': phi_E_clump, 'x_clump': x_clump, 'y_clump': y_clump } kwargs_else.update(clump_kwargs) makeImage = ImageModel(kwargs_options_clump, kwargs_data) if kwargs_options["multiBand"]: x_grid, y_grid = kwargs_data[0]['x_coords'], kwargs_data[0][ 'y_coords'] else: x_grid, y_grid = kwargs_data['x_coords'], kwargs_data['y_coords'] kappa_result = util.array2image( makeImage.LensModel.kappa(x_grid, y_grid, kwargs_else, **kwargs_lens)) return kappa_result
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): """ :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 _set_sim_api(self, num_pix, kwargs_detector, psf_kernel_size, which_psf_maps): """Set the simulation API objects """ self.data_api = DataAPI(num_pix, **kwargs_detector) #self.pixel_scale = data_api.pixel_scale pixel_scale = kwargs_detector['pixel_scale'] psf_model = psf_utils.get_PSF_model(kwargs_detector['psf_type'], pixel_scale, seeing=kwargs_detector['seeing'], kernel_size=psf_kernel_size, which_psf_maps=which_psf_maps) # Set the precision level of lens equation solver self.min_distance = 0.05 self.search_window = pixel_scale*num_pix self.image_model = ImageModel(self.data_api.data_class, psf_model, self.lens_mass_model, self.src_light_model, self.lens_light_model, self.ps_model, kwargs_numerics=self.kwargs_numerics) if 'agn_light' in self.components: self.unlensed_image_model = ImageModel(self.data_api.data_class, psf_model, None, self.src_light_model, None, self.unlensed_ps_model, kwargs_numerics=self.kwargs_numerics) else: self.unlensed_image_model = ImageModel(self.data_api.data_class, psf_model, None, self.src_light_model, None, None, kwargs_numerics=self.kwargs_numerics)
def __init__(self, multi_band_list, lens_model_list=None, source_model_class=None, lens_light_model_class=None, point_source_class=None): imageModel_list = [] self._idex_lens_list = [] for i in range(len(multi_band_list)): kwargs_data = multi_band_list[i][0] kwargs_psf = multi_band_list[i][1] kwargs_numerics = multi_band_list[i][2] index_lens_list = multi_band_list[i][3].get( 'index_lens_list', [k for k in range(len(lens_model_list))]) self._idex_lens_list.append(index_lens_list) lens_model_list_sub = [lens_model_list[k] for k in index_lens_list] lens_model_class = LensModel(lens_model_list=lens_model_list_sub) data_i = Data(kwargs_data=kwargs_data) psf_i = PSF(kwargs_psf=kwargs_psf) point_source_class_i = copy.deepcopy(point_source_class) imageModel = ImageModel(data_i, psf_i, lens_model_class, source_model_class, lens_light_model_class, point_source_class_i, kwargs_numerics=kwargs_numerics) imageModel_list.append(imageModel) super(MultiFrame, self).__init__(imageModel_list)
def image_model_class(self, kwargs_numerics={}): """ :param kwargs_numerics: keyword arguments list of Numerics module :return: instance of the ImageModel class with all the specified configurations """ return ImageModel(self.data_class, self.psf_class, self.lens_model_class, self.source_model_class, self.lens_light_model_class, self.point_source_model_class, kwargs_numerics=kwargs_numerics)
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 __init__(self, numpix, kwargs_single_band, kwargs_model, kwargs_numerics): """ :param numpix: number of pixels per axis :param kwargs_single_band: keyword arguments specifying the class instance of DataAPI :param kwargs_model: keyword arguments specifying the class instance of ModelAPI :param kwargs_numerics: keyword argument with various numeric description (see ImageNumerics class for options) """ DataAPI.__init__(self, numpix, **kwargs_single_band) ModelAPI.__init__(self, **kwargs_model) self._image_model_class = ImageModel(self.data_class, self.psf_class, self.lens_model_class, self.source_model_class, self.lens_light_model_class, self.point_source_model_class, kwargs_numerics=kwargs_numerics)
def test_point_source_rendering(self): # initialize data from lenstronomy.SimulationAPI.simulations import Simulation SimAPI = Simulation() numPix = 100 deltaPix = 0.05 kwargs_data = SimAPI.data_configure(numPix, deltaPix, exposure_time=1, sigma_bkg=1) data_class = Data(kwargs_data) kernel = np.zeros((5, 5)) kernel[2, 2] = 1 kwargs_psf = {'kernel_point_source': kernel, 'kernel_pixel': kernel, 'psf_type': 'PIXEL'} psf_class = PSF(kwargs_psf) lens_model_class = LensModel(['SPEP']) source_model_class = LightModel([]) lens_light_model_class = LightModel([]) kwargs_numerics = {'subgrid_res': 2, 'point_source_subgrid': 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)}] model = 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)): 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)}] model = 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 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 create_image_model(kwargs_data, kwargs_psf, kwargs_numerics, lens_model_list=[], z_lens=None, z_source=None, lens_redshift_list=None, multi_plane=False, source_light_model_list=[], lens_light_model_list=[], point_source_model_list=[], fixed_magnification_list=None, additional_images_list=None, min_distance=0.01, search_window=5, precision_limit=10**(-10), num_iter_max=100, multi_band_type=None, source_deflection_scaling_list=None, source_redshift_list=None, cosmo=None): """ :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=lens_model_list, z_lens=z_lens, z_source=z_source, lens_redshift_list=lens_redshift_list, multi_plane=multi_plane, cosmo=cosmo) source_model_class = LightModel( light_model_list=source_light_model_list, deflection_scaling_list=source_deflection_scaling_list, source_redshift_list=source_redshift_list) lens_light_model_class = LightModel(light_model_list=lens_light_model_list) point_source_class = PointSource( point_source_type_list=point_source_model_list, lensModel=lens_model_class, fixed_magnification_list=fixed_magnification_list, additional_images_list=additional_images_list, min_distance=min_distance, search_window=search_window, precision_limit=precision_limit, num_iter_max=num_iter_max) imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics) return imageModel
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 __init__(self, multi_band_list, lens_model_class=None, source_model_list=None, lens_light_model_list=None, point_source_class=None): imageModel_list = [] self._index_source_list = [] self._index_lens_light_list = [] for i in range(len(multi_band_list)): kwargs_data = multi_band_list[i][0] kwargs_psf = multi_band_list[i][1] kwargs_numerics = multi_band_list[i][2] data_i = Data(kwargs_data=kwargs_data) psf_i = PSF(kwargs_psf=kwargs_psf) index_source_list = multi_band_list[i][3].get( 'index_source_light_model', [k for k in range(len(source_model_list))]) self._index_source_list.append(index_source_list) source_model_list_sub = [ source_model_list[k] for k in index_source_list ] source_model_class = LightModel( light_model_list=source_model_list_sub) index_lens_light_list = multi_band_list[i][3].get( 'index_lens_light_model', [k for k in range(len(source_model_list))]) self._index_lens_light_list.append(index_lens_light_list) lens_light_model_list_sub = [ lens_light_model_list[k] for k in index_lens_light_list ] lens_light_model_class = LightModel( light_model_list=lens_light_model_list_sub) imageModel = ImageModel(data_i, psf_i, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics=kwargs_numerics) imageModel_list.append(imageModel) super(MultiBandMultiModel, self).__init__(imageModel_list)
def test_force_positive_source_surface_brightness(self): kwargs_likelihood = { 'force_positive_source_surface_brightness': True, 'numPix_source': 10, 'deltaPix_source': 0.1 } 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 = Data(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) data_class.update_data(image_sim) likelihood = LikelihoodModule(imSim_class=imageModel, param_class=param_class, **kwargs_likelihood) logL, _ = likelihood.logL(args=param_class.kwargs2args( kwargs_source=kwargs_source)) assert logL <= -10**10
def creat_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) if 'lens_model_list' in kwargs_model: lens_model_class = LensModel( lens_model_list=kwargs_model.get('lens_model_list', None), z_source=kwargs_model.get('z_source', None), redshift_list=kwargs_model.get('redshift_list', None), multi_plane=kwargs_model.get('multi_plane', False)) else: lens_model_class = None if 'source_light_model_list' in kwargs_model: source_model_class = LightModel(light_model_list=kwargs_model.get( 'source_light_model_list', ['NONE'])) else: source_model_class = None if 'lens_light_model_list' in kwargs_model: lens_light_model_class = LightModel(light_model_list=kwargs_model.get( 'lens_light_model_list', ['NONE'])) else: lens_light_model_class = None if 'point_source_model_list' in kwargs_model: point_source_class = PointSource( point_source_type_list=kwargs_model.get('point_source_model_list', ['NONE']), fixed_magnification_list=kwargs_model.get( 'fixed_magnification_list', None), additional_images_list=kwargs_model.get('additional_images_list', None)) else: point_source_class = None imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics) return imageModel
def __init__(self, multi_band_list, lens_model_class, source_model_class, lens_light_model_class, point_source_class): self._num_bands = len(multi_band_list) self.lensModel = lens_model_class self.pointSource = point_source_class self._imageModel_list = [] for i in range(self._num_bands): kwargs_data = multi_band_list[i][0] kwargs_psf = multi_band_list[i][1] kwargs_numerics = multi_band_list[i][2] data_i = Data(kwargs_data=kwargs_data) psf_i = PSF(kwargs_psf=kwargs_psf) self._imageModel_list.append( ImageModel(data_i, psf_i, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics=kwargs_numerics))
def __init__(self, multi_band_list, lens_model_class=None, source_model_class=None, lens_light_model_class=None, point_source_class=None): imageModel_list = [] for i in range(len(multi_band_list)): kwargs_data = multi_band_list[i][0] kwargs_psf = multi_band_list[i][1] kwargs_numerics = multi_band_list[i][2] data_i = Data(kwargs_data=kwargs_data) psf_i = PSF(kwargs_psf=kwargs_psf) imageModel = ImageModel(data_i, psf_i, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics=kwargs_numerics) imageModel_list.append(imageModel) super(MultiBand, self).__init__(imageModel_list)
def survey_kwargs(self, survey_kwargs): survey_name = survey_kwargs['survey_name'] bandpass_list = survey_kwargs['bandpass_list'] coadd_years = survey_kwargs.get('coadd_years') override_obs_kwargs = survey_kwargs.get('override_obs_kwargs', {}) override_camera_kwargs = survey_kwargs.get('override_camera_kwargs', {}) import lenstronomy.SimulationAPI.ObservationConfig as ObsConfig from importlib import import_module sys.path.insert(0, ObsConfig.__path__[0]) SurveyClass = getattr(import_module(survey_name), survey_name) self._data_api = [] # init self._image_model = [] # init for bp in bandpass_list: survey_obj = SurveyClass(band=bp, psf_type=self.psf_type, coadd_years=coadd_years) # Override as specified in survey_kwargs survey_obj.camera.update(override_camera_kwargs) survey_obj.obs.update(override_obs_kwargs) # This is what we'll actually use kwargs_detector = survey_obj.kwargs_single_band() data_api = DataAPI(self.n_pix, **kwargs_detector) psf_model = psf_utils.get_PSF_model(self.psf_type, self.pixel_scale, seeing=kwargs_detector['seeing'], kernel_size=self.psf_kernel_size, which_psf_maps=self.which_psf_maps) image_model_bp = ImageModel(data_api.data_class, psf_model, self.lens_model, self.src_model, None, None, kwargs_numerics=self.kwargs_numerics) self._data_api.append(data_api) self._image_model.append(image_model_bp)
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
def setup(self): # data specifics sigma_bkg = 0.01 # 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.3 # full width half max of PSF # PSF specification kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exp_time, sigma_bkg) data_class = Data(kwargs_data) sigma = util.fwhm2sigma(fwhm) x_grid, y_grid = util.make_grid(numPix=31, deltapix=0.05) from lenstronomy.LightModel.Profiles.gaussian import Gaussian gaussian = Gaussian() kernel_point_source = gaussian.function(x_grid, y_grid, amp=1., sigma_x=sigma, sigma_y=sigma, center_x=0, center_y=0) kernel_point_source /= np.sum(kernel_point_source) kernel_point_source = util.array2image(kernel_point_source) self.kwargs_psf = {'psf_type': 'PIXEL', 'kernel_point_source': kernel_point_source} psf_class = PSF(kwargs_psf=self.kwargs_psf) # 'EXERNAL_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.0, 'dec_source': 0.0, 'source_amp': 10.}] # 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 = {'subgrid_res': 3, 'psf_subgrid': True} 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) self.imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, kwargs_numerics=kwargs_numerics) self.psf_fitting = PsfFitting(self.imageModel)
def setup(self): # data specifics sigma_bkg = 0.05 # background noise per pixel exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit) numPix = 10 # cutout pixel size deltaPix = 0.1 # 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_gaussian = { 'psf_type': 'GAUSSIAN', 'fwhm': fwhm, 'pixel_size': deltaPix } psf = PSF(**kwargs_psf_gaussian) kwargs_psf = { 'psf_type': 'PIXEL', 'kernel_point_source': psf.kernel_point_source } psf_class = PSF(**kwargs_psf) kwargs_spemd = { 'theta_E': 1., 'gamma': 1.8, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1 } lens_model_list = ['SPEP'] self.kwargs_lens = [kwargs_spemd] lens_model_class = LensModel(lens_model_list=lens_model_list) kwargs_sersic = { 'amp': 1., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0 } # 'SERSIC_ELLIPSE': elliptical Sersic profile kwargs_sersic_ellipse = { 'amp': 1., 'R_sersic': .6, 'n_sersic': 3, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1 } 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) kwargs_numerics = { 'supersampling_factor': 1, 'supersampling_convolution': False, 'compute_mode': 'regular' } imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, kwargs_numerics=kwargs_numerics) image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens, self.kwargs_source, self.kwargs_lens_light) data_class.update_data(image_sim) kwargs_data['image_data'] = image_sim kwargs_data_joint = { 'multi_band_list': [[kwargs_data, kwargs_psf, kwargs_numerics]], 'multi_band_type': 'single-band' } self.data_class = data_class self.psf_class = psf_class kwargs_model = { 'lens_model_list': lens_model_list, 'source_light_model_list': source_model_list, 'lens_light_model_list': lens_light_model_list, 'fixed_magnification_list': [False], } self.kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False} kwargs_constraints = { 'image_plane_source_list': [False] * len(source_model_list) } kwargs_likelihood = { 'source_marg': False, 'position_uncertainty': 0.004, 'check_solver': False, 'solver_tolerance': 0.001, } self.param_class = Param(kwargs_model, **kwargs_constraints) self.Likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data_joint, kwargs_model=kwargs_model, param_class=self.param_class, **kwargs_likelihood) prior_means = self.param_class.kwargs2args( kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light) prior_sigmas = np.ones_like(prior_means) * 0.1 self.output_dir = 'test_nested_out' self.sampler = MultiNestSampler(self.Likelihood, prior_type='uniform', prior_means=prior_means, prior_sigmas=prior_sigmas, output_dir=self.output_dir, remove_output_dir=True)