def setup(self): np.random.seed(42) # 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 = 50 # cutout pixel size deltaPix = 0.1 # pixel size in arcsec (area per pixel = deltaPix**2) fwhm = 0.5 # full width half max of PSF kwargs_model = {'lens_model_list': ['SPEP'], 'lens_light_model_list': ['SERSIC'], 'source_light_model_list': ['SERSIC_ELLIPSE'], 'point_source_model_list': ['SOURCE_POSITION'], 'fixed_magnification_list': [True]} # PSF specification kwargs_band = sim_util.data_configure_simple(numPix, deltaPix, exp_time, sigma_bkg) data_class = ImageData(**kwargs_band) kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': fwhm, 'pixel_size': deltaPix} psf_class = PSF(**kwargs_psf) print(np.shape(psf_class.kernel_point_source), 'test kernel shape -') kwargs_spep = {'theta_E': 1., 'gamma': 1.95, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1} self.kwargs_lens = [kwargs_spep] kwargs_sersic = {'amp': 1/0.05**2., '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} self.kwargs_lens_light = [kwargs_sersic] self.kwargs_source = [kwargs_sersic_ellipse] self.kwargs_ps = [{'ra_source': 0.55, 'dec_source': 0.02, 'source_amp': 1.}] # quasar point source position in the source plane and intrinsic brightness self.kwargs_cosmo = {'D_dt': 1000} kwargs_numerics = {'supersampling_factor': 1, 'supersampling_convolution': False} lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_class = class_creator.create_class_instances(**kwargs_model) imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_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) ra_pos, dec_pos = imageModel.PointSource.image_position(kwargs_ps=self.kwargs_ps, kwargs_lens=self.kwargs_lens) data_class.update_data(image_sim) kwargs_band['image_data'] = image_sim self.data_class = data_class self.psf_class = psf_class self.kwargs_model = kwargs_model self.kwargs_numerics = { 'supersampling_factor': 1, 'supersampling_convolution': False} kwargs_constraints = { 'num_point_source_list': [4], 'solver_type': 'NONE', # 'PROFILE', 'PROFILE_SHEAR', 'ELLIPSE', 'CENTER' 'Ddt_sampling': True } def condition_definition(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps=None, kwargs_special=None, kwargs_extinction=None): logL = 0 if kwargs_lens_light[0]['R_sersic'] > kwargs_source[0]['R_sersic']: logL -= 10**15 return logL kwargs_likelihood = {'force_no_add_image': True, 'source_marg': True, 'astrometric_likelihood': True, 'image_position_uncertainty': 0.004, 'check_matched_source_position': False, 'source_position_tolerance': 0.001, 'source_position_sigma': 0.001, 'check_positive_flux': True, 'flux_ratio_likelihood': True, 'prior_lens': [[0, 'theta_E', 1, 0.1]], 'custom_logL_addition': condition_definition, 'image_position_likelihood': True } self.kwargs_data = {'multi_band_list': [[kwargs_band, kwargs_psf, kwargs_numerics]], 'multi_band_type': 'single-band', 'time_delays_measured': np.ones(4), 'time_delays_uncertainties': np.ones(4), 'flux_ratios': np.ones(4), 'flux_ratio_errors': np.ones(4), 'ra_image_list': ra_pos, 'dec_image_list': dec_pos } self.param_class = Param(self.kwargs_model, **kwargs_constraints) 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.Likelihood = LikelihoodModule(kwargs_data_joint=self.kwargs_data, kwargs_model=kwargs_model, param_class=self.param_class, **kwargs_likelihood) self.kwargs_band = kwargs_band self.kwargs_psf = kwargs_psf self.numPix = numPix
class TestDynestySampler(object): """ test the fitting sequences """ 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, } # reduce number of param to sample (for runtime) kwargs_fixed_lens = [{ 'gamma': 1.8, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1 }] kwargs_lower_lens = [{'theta_E': 0.8}] kwargs_upper_lens = [{'theta_E': 1.2}] kwargs_fixed_source = [{ 'R_sersic': 0.6, 'n_sersic': 3, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1 }] kwargs_fixed_lens_light = [{ 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0 }] self.param_class = Param( kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_source=kwargs_fixed_source, kwargs_fixed_lens_light=kwargs_fixed_lens_light, kwargs_lower_lens=kwargs_lower_lens, kwargs_upper_lens=kwargs_upper_lens, **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.sampler = DynestySampler(self.Likelihood, prior_type='uniform', prior_means=prior_means, prior_sigmas=prior_sigmas, sigma_scale=0.5) def test_sampler(self): kwargs_run = { 'dlogz_init': 0.01, 'nlive_init': 4, 'nlive_batch': 4, 'maxbatch': 1, 'wt_kwargs': { 'pfrac': 0.8 }, } samples, means, logZ, logZ_err, logL, results = self.sampler.run( kwargs_run) assert len(means) == 1 def test_sampler_init(self): try: sampler = DynestySampler( self.Likelihood, prior_type='gaussian', prior_means=None, # will raise an Error prior_sigmas=None) # will raise an Error except Exception as e: assert isinstance(e, ValueError) try: sampler = DynestySampler(self.Likelihood, prior_type='some_type') except Exception as e: assert isinstance(e, ValueError) def test_prior(self): n_dims = self.sampler.n_dims cube_low = np.zeros(n_dims) cube_upp = np.ones(n_dims) self.prior_type = 'uniform' cube_low = self.sampler.prior(cube_low) npt.assert_equal(cube_low, self.sampler.lowers) cube_upp = self.sampler.prior(cube_upp) npt.assert_equal(cube_upp, self.sampler.uppers) cube_mid = 0.5 * np.ones(n_dims) self.prior_type = 'gaussian' self.sampler.prior(cube_mid) cube_gauss = np.array([0.5]) npt.assert_equal(cube_mid, cube_gauss) def test_log_likelihood(self): n_dims = self.sampler.n_dims args = np.nan * np.ones(n_dims) logL = self.sampler.log_likelihood(args) assert logL < 0
class TestFittingSequence(object): """ test the fitting sequences """ def setup(self): np.random.seed(42) # 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 = 50 # 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 = Data(kwargs_data) kwargs_psf = sim_util.psf_configure_simple(psf_type='GAUSSIAN', fwhm=fwhm, kernelsize=11, deltaPix=deltaPix, truncate=3, kernel=None) psf_class = PSF(kwargs_psf) kwargs_spemd = { 'theta_E': 1., 'gamma': 1.95, '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 / 0.05**2., '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) self.kwargs_ps = [ { 'ra_source': 0.55, 'dec_source': 0.02, 'source_amp': 1. } ] # quasar point source position in the source plane and intrinsic brightness self.kwargs_cosmo = {'D_dt': 1000} point_source_list = ['SOURCE_POSITION'] point_source_class = PointSource( point_source_type_list=point_source_list, fixed_magnification_list=[True]) kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False} 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.data_class = data_class self.psf_class = psf_class self.kwargs_model = { 'lens_model_list': lens_model_list, 'source_light_model_list': source_model_list, 'lens_light_model_list': lens_light_model_list, 'point_source_model_list': point_source_list, } self.kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False} kwargs_constraints = { 'num_point_source_list': [4], 'solver_type': 'NONE', # 'PROFILE', 'PROFILE_SHEAR', 'ELLIPSE', 'CENTER' 'cosmo_type': 'D_dt' } kwargs_likelihood = { 'force_no_add_image': True, 'source_marg': True, 'point_source_likelihood': True, 'position_uncertainty': 0.004, 'check_solver': True, 'solver_tolerance': 0.001, 'check_positive_flux': True, } self.param_class = Param(self.kwargs_model, **kwargs_constraints) 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.Likelihood = LikelihoodModule(imSim_class=self.imageModel, param_class=self.param_class, **kwargs_likelihood) def test_logL(self): args = self.param_class.kwargs2args( kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light, kwargs_ps=self.kwargs_ps, kwargs_cosmo=self.kwargs_cosmo) logL, _ = self.Likelihood.logL(args) num_data_evaluate = self.Likelihood.imSim.numData_evaluate() npt.assert_almost_equal(logL / num_data_evaluate, -1 / 2., decimal=1) def test_time_delay_likelihood(self): kwargs_likelihood = { 'time_delay_likelihood': True, 'time_delays_measured': np.ones(4), 'time_delays_uncertainties': np.ones(4) } likelihood = LikelihoodModule(imSim_class=self.imageModel, param_class=self.param_class, **kwargs_likelihood) args = self.param_class.kwargs2args( kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light, kwargs_ps=self.kwargs_ps, kwargs_cosmo=self.kwargs_cosmo) logL, _ = likelihood.logL(args) npt.assert_almost_equal(logL, -3340.79, decimal=-1) def test_solver(self): # make simulation with point source positions in image plane x_pos, y_pos = self.imageModel.PointSource.image_position( self.kwargs_ps, self.kwargs_lens) kwargs_ps = [{'ra_image': x_pos[0], 'dec_image': y_pos[0]}] kwargs_likelihood = { 'source_marg': True, 'point_source_likelihood': True, 'position_uncertainty': 0.004, 'check_solver': True, 'solver_tolerance': 0.001, 'check_positive_flux': True, 'solver': True } #imageModel = ImageModel(self.data_class, self.psf_class, self.lens_model_class, self.source_model_class, # self.lens_light_model_class, # point_source_class, kwargs_numerics=kwargs_numerics) 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
class TestLikelihoodModule(object): """ test the fitting sequences """ def setup(self): np.random.seed(42) # 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 = 50 # cutout pixel size deltaPix = 0.1 # pixel size in arcsec (area per pixel = deltaPix**2) fwhm = 0.5 # full width half max of PSF kwargs_model = {'lens_model_list': ['SPEP'], 'lens_light_model_list': ['SERSIC'], 'source_light_model_list': ['SERSIC_ELLIPSE'], 'point_source_model_list': ['SOURCE_POSITION'], 'fixed_magnification_list': [True]} # PSF specification kwargs_band = sim_util.data_configure_simple(numPix, deltaPix, exp_time, sigma_bkg) data_class = ImageData(**kwargs_band) kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': fwhm, 'pixel_size': deltaPix} psf_class = PSF(**kwargs_psf) print(np.shape(psf_class.kernel_point_source), 'test kernel shape -') kwargs_spep = {'theta_E': 1., 'gamma': 1.95, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1} self.kwargs_lens = [kwargs_spep] kwargs_sersic = {'amp': 1/0.05**2., '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} self.kwargs_lens_light = [kwargs_sersic] self.kwargs_source = [kwargs_sersic_ellipse] self.kwargs_ps = [{'ra_source': 0.55, 'dec_source': 0.02, 'source_amp': 1.}] # quasar point source position in the source plane and intrinsic brightness self.kwargs_cosmo = {'D_dt': 1000} kwargs_numerics = {'supersampling_factor': 1, 'supersampling_convolution': False} lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_class = class_creator.create_class_instances(**kwargs_model) imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_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) ra_pos, dec_pos = imageModel.PointSource.image_position(kwargs_ps=self.kwargs_ps, kwargs_lens=self.kwargs_lens) data_class.update_data(image_sim) kwargs_band['image_data'] = image_sim self.data_class = data_class self.psf_class = psf_class self.kwargs_model = kwargs_model self.kwargs_numerics = { 'supersampling_factor': 1, 'supersampling_convolution': False} kwargs_constraints = { 'num_point_source_list': [4], 'solver_type': 'NONE', # 'PROFILE', 'PROFILE_SHEAR', 'ELLIPSE', 'CENTER' 'Ddt_sampling': True } def condition_definition(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps=None, kwargs_special=None, kwargs_extinction=None): logL = 0 if kwargs_lens_light[0]['R_sersic'] > kwargs_source[0]['R_sersic']: logL -= 10**15 return logL kwargs_likelihood = {'force_no_add_image': True, 'source_marg': True, 'astrometric_likelihood': True, 'image_position_uncertainty': 0.004, 'check_matched_source_position': False, 'source_position_tolerance': 0.001, 'source_position_sigma': 0.001, 'check_positive_flux': True, 'flux_ratio_likelihood': True, 'prior_lens': [[0, 'theta_E', 1, 0.1]], 'custom_logL_addition': condition_definition, 'image_position_likelihood': True } self.kwargs_data = {'multi_band_list': [[kwargs_band, kwargs_psf, kwargs_numerics]], 'multi_band_type': 'single-band', 'time_delays_measured': np.ones(4), 'time_delays_uncertainties': np.ones(4), 'flux_ratios': np.ones(4), 'flux_ratio_errors': np.ones(4), 'ra_image_list': ra_pos, 'dec_image_list': dec_pos } self.param_class = Param(self.kwargs_model, **kwargs_constraints) 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.Likelihood = LikelihoodModule(kwargs_data_joint=self.kwargs_data, kwargs_model=kwargs_model, param_class=self.param_class, **kwargs_likelihood) self.kwargs_band = kwargs_band self.kwargs_psf = kwargs_psf self.numPix = numPix def test_logL(self): args = self.param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light, kwargs_ps=self.kwargs_ps, kwargs_special=self.kwargs_cosmo) logL = self.Likelihood.logL(args, verbose=True) num_data_evaluate = self.Likelihood.num_data npt.assert_almost_equal(logL/num_data_evaluate, -1/2., decimal=1) def test_time_delay_likelihood(self): kwargs_likelihood = {'time_delay_likelihood': True, } likelihood = LikelihoodModule(kwargs_data_joint=self.kwargs_data, kwargs_model=self.kwargs_model, param_class=self.param_class, **kwargs_likelihood) args = self.param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light, kwargs_ps=self.kwargs_ps, kwargs_special=self.kwargs_cosmo) logL = likelihood.logL(args, verbose=True) npt.assert_almost_equal(logL, -3080.29, decimal=-1) def test_check_bounds(self): penalty, bound_hit = self.Likelihood.check_bounds(args=[0, 1], lowerLimit=[1, 0], upperLimit=[2, 2], verbose=True) assert bound_hit def test_pixelbased_modelling(self): ss_source = 2 numPix_source = self.numPix*ss_source n_scales = 3 kwargs_pixelbased = { 'source_interpolation': 'nearest', 'supersampling_factor_source': ss_source, # supersampling of pixelated source grid # following choices are to minimize pixel solver runtime (not to get accurate reconstruction!) 'threshold_decrease_type': 'none', 'num_iter_source': 2, 'num_iter_lens': 2, 'num_iter_global': 2, 'num_iter_weights': 2, } kwargs_likelihood = { 'image_likelihood': True, 'kwargs_pixelbased': kwargs_pixelbased, 'check_positive_flux': True, # effectively not applied, activated for code coverage purposes } kernel = PSF(**self.kwargs_psf).kernel_point_source kwargs_psf = {'psf_type': 'PIXEL', 'kernel_point_source': kernel} kwargs_numerics = {'supersampling_factor': 1} kwargs_data = {'multi_band_list': [[self.kwargs_band, kwargs_psf, kwargs_numerics]]} kwargs_model = { 'lens_model_list': ['SPEP'], 'lens_light_model_list': ['SLIT_STARLETS'], 'source_light_model_list': ['SLIT_STARLETS'], } kwargs_fixed_source = [{'n_scales': n_scales, 'n_pixels': numPix_source**2, 'scale': 1, 'center_x': 0, 'center_y': 0}] kwargs_fixed_lens_light = [{'n_scales': n_scales, 'n_pixels': self.numPix**2, 'scale': 1, 'center_x': 0, 'center_y': 0}] kwargs_constraints = {'source_grid_offset': True} param_class = Param(kwargs_model, kwargs_fixed_source=kwargs_fixed_source, kwargs_fixed_lens_light=kwargs_fixed_lens_light, **kwargs_constraints) likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data, kwargs_model=kwargs_model, param_class=param_class, **kwargs_likelihood) kwargs_source = [{'amp': np.ones(n_scales*numPix_source**2)}] kwargs_lens_light = [{'amp': np.ones(n_scales*self.numPix**2)}] kwargs_special = {'delta_x_source_grid': 0, 'delta_y_source_grid': 0} args = param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=kwargs_source, kwargs_lens_light=kwargs_lens_light, kwargs_special=kwargs_special) logL = likelihood.logL(args, verbose=True) num_data_evaluate = likelihood.num_data npt.assert_almost_equal(logL/num_data_evaluate, -1/2., decimal=1)
def sl_sys_analysis(): # Get command line arguments args = {} if comm_rank == 0: print(":Registered %d processes" % comm_size) args["infile"] = sys.argv[1] args["nimgs"] = sys.argv[2] args["los"] = sys.argv[3] args["version"] = sys.argv[4] args["dt_sigma"] = float(sys.argv[5]) args["image_amps_sigma"] = float(sys.argv[6]) args["flux_ratio_errors"] = float(sys.argv[7]) args["astrometry_sigma"] = float(sys.argv[8]) args = comm.bcast(args) # Organize devision of strong lensing systems with open(args["infile"], "r") as myfile: limg_data = myfile.read() systems = json.loads(limg_data) sys_nr_per_proc = int(len(systems) / comm_size) print("comm_rank", comm_rank) start_sys = sys_nr_per_proc * comm_rank end_sys = sys_nr_per_proc * (comm_rank + 1) print(start_sys, end_sys) with open("../lens_catalogs_sie_only.json", "r") as myfile: limg_data = myfile.read() systems_prior = json.loads(limg_data) if comm_rank == 0: print("Each process will have %d systems" % sys_nr_per_proc) print("That should take app. %f min." % (sys_nr_per_proc * 20)) source_size_pc = 10.0 window_size = 0.1 # units of arcseconds grid_number = 100 # supersampled window (per axis) z_source = 2.0 cosmo = FlatLambdaCDM(H0=71, Om0=0.3089, Ob0=0.0) results = {"gamma": [], "phi_ext": [], "gamma_ext": [], "theta_E": [], "D_dt": []} for ii in range(len(systems))[(start_sys + 2) : end_sys]: system = systems[ii] system_prior = systems_prior[ii] print("Analysing system ID: %d" % ii) # the data set is z_lens = system_prior["zl"] lensCosmo = LensCosmo(cosmo=cosmo, z_lens=z_lens, z_source=z_source) # convert units of pc into arcseconds D_s = lensCosmo.D_s source_size_arcsec = source_size_pc / 10 ** 6 / D_s / constants.arcsec print("The source size in arcsec init = %.4f" % source_size_arcsec) #0.0012 # multiple images properties ximg = np.zeros(system["nimgs"]) yimg = np.zeros(system["nimgs"]) t_days = np.zeros(system["nimgs"]) image_amps = np.zeros(system["nimgs"]) for jj in range(system["nimgs"]): ximg[jj] = system["ximg"][jj] # [arcsec] yimg[jj] = system["yimg"][jj] # [arcsec] t_days[jj] = system["delay"][jj] # [days] image_amps[jj] = system["mags"][jj] # [linear units or magnitudes] # sort by arrival time index_sort = np.argsort(t_days) ximg = ximg[index_sort] # relative RA (arc seconds) yimg = yimg[index_sort] # relative DEC (arc seconds) image_amps = np.abs(image_amps[index_sort]) t_days = t_days[index_sort] d_dt = t_days[1:] - t_days[0] # measurement uncertainties astrometry_sigma = args["astrometry_sigma"] ximg_measured = ximg + np.random.normal(0, astrometry_sigma, system["nimgs"]) yimg_measured = yimg + np.random.normal(0, astrometry_sigma, system["nimgs"]) image_amps_sigma = np.ones(system["nimgs"]) * args["image_amps_sigma"] flux_ratios = image_amps[1:] - image_amps[0] flux_ratio_errors = np.ones(system["nimgs"] - 1) * args["flux_ratio_errors"] flux_ratios_measured = flux_ratios + np.random.normal(0, flux_ratio_errors) d_dt_sigma = np.ones(system["nimgs"] - 1) * args["dt_sigma"] d_dt_measured = d_dt + np.random.normal(0, d_dt_sigma) kwargs_data_joint = { "time_delays_measured": d_dt_measured, "time_delays_uncertainties": d_dt_sigma, "flux_ratios": flux_ratios_measured, "flux_ratio_errors": flux_ratio_errors, "ra_image_list": [ximg_measured], "dec_image_list": [yimg_measured], } # lens model choices lens_model_list = ["SPEMD", "SHEAR_GAMMA_PSI"] # 1. layer: primary SPEP fixed_lens = [] kwargs_lens_init = [] kwargs_lens_sigma = [] kwargs_lower_lens = [] kwargs_upper_lens = [] fixed_lens.append({}) kwargs_lens_init.append( { "theta_E": 1.0, "gamma": 2, "center_x": 0, "center_y": 0, "e1": 0, "e2": 0.0, } ) # error kwargs_lens_sigma.append( { "theta_E": 0.2, "e1": 0.1, "e2": 0.1, "gamma": 0.1, "center_x": 0.1, "center_y": 0.1, } ) # lower limit kwargs_lower_lens.append( { "theta_E": 0.01, "e1": -0.5, "e2": -0.5, "gamma": 1.5, "center_x": -10, "center_y": -10, } ) # upper limit kwargs_upper_lens.append( { "theta_E": 10, "e1": 0.5, "e2": 0.5, "gamma": 2.5, "center_x": 10, "center_y": 10, } ) # 2nd layer: external SHEAR fixed_lens.append({"ra_0": 0, "dec_0": 0}) kwargs_lens_init.append({"gamma_ext": 0.05, "psi_ext": 0.0}) kwargs_lens_sigma.append({"gamma_ext": 0.05, "psi_ext": np.pi}) kwargs_lower_lens.append({"gamma_ext": 0, "psi_ext": -np.pi}) kwargs_upper_lens.append({"gamma_ext": 0.3, "psi_ext": np.pi}) # 3rd layer: external CONVERGENCE kwargs_lens_init.append({'kappa_ext': 0.12}) kwargs_lens_sigma.append({'kappa_ext': 0.06}) kwargs_lower_lens.append({'kappa_ext': 0.0}) kwargs_upper_lens.append({'kappa_ext': 0.3}) # combined lens model lens_params = [ kwargs_lens_init, kwargs_lens_sigma, fixed_lens, kwargs_lower_lens, kwargs_upper_lens, ] # image position parameters point_source_list = ["LENSED_POSITION"] # we fix the image position coordinates fixed_ps = [{}] # the initial guess for the appearing image positions is: # at the image position. kwargs_ps_init = [{"ra_image": ximg, "dec_image": yimg}] # let some freedome in how well the actual image positions are # matching those given by the data (indicated as 'ra_image', 'dec_image' # and held fixed while fitting) kwargs_ps_sigma = [ { "ra_image": 0.01 * np.ones(len(ximg)), "dec_image": 0.01 * np.ones(len(ximg)), } ] kwargs_lower_ps = [ { "ra_image": -10 * np.ones(len(ximg)), "dec_image": -10 * np.ones(len(ximg)), } ] kwargs_upper_ps = [ {"ra_image": 10 * np.ones(len(ximg)), "dec_image": 10 * np.ones(len(ximg))} ] ps_params = [ kwargs_ps_init, kwargs_ps_sigma, fixed_ps, kwargs_lower_ps, kwargs_upper_ps, ] # quasar source size fixed_special = {} kwargs_special_init = {} kwargs_special_sigma = {} kwargs_lower_special = {} kwargs_upper_special = {} fixed_special["source_size"] = source_size_arcsec kwargs_special_init["source_size"] = source_size_arcsec kwargs_special_sigma["source_size"] = source_size_arcsec kwargs_lower_special["source_size"] = 0.0001 kwargs_upper_special["source_size"] = 1 # Time-delay distance kwargs_special_init["D_dt"] = 4300 # corresponds to H0 ~ 70 kwargs_special_sigma["D_dt"] = 3000 kwargs_lower_special["D_dt"] = 2500 # corresponds to H0 ~ 120 kwargs_upper_special["D_dt"] = 14000 # corresponds to H0 ~ 20 special_params = [ kwargs_special_init, kwargs_special_sigma, fixed_special, kwargs_lower_special, kwargs_upper_special, ] # combined parameter settings kwargs_params = { "lens_model": lens_params, "point_source_model": ps_params, "special": special_params, } # our model choices kwargs_model = { "lens_model_list": lens_model_list, "point_source_model_list": point_source_list, } lensModel = LensModel(kwargs_model["lens_model_list"]) lensModelExtensions = LensModelExtensions(lensModel=lensModel) lensEquationSolver = LensEquationSolver(lensModel=lensModel) # setup options for likelihood and parameter sampling time_delay_likelihood = True flux_ratio_likelihood = True image_position_likelihood = True kwargs_flux_compute = { "source_type": "INF", "window_size": window_size, "grid_number": grid_number, } kwargs_constraints = { "num_point_source_list": [int(args["nimgs"])], # any proposed lens model must satisfy the image positions # appearing at the position of the point sources being sampeld # "solver_type": "PROFILE_SHEAR", "Ddt_sampling": time_delay_likelihood, # sampling of the time-delay distance # explicit modelling of the astrometric imperfection of # the point source positions "point_source_offset": True, } # explicit sampling of finite source size parameter # (only use when source_type='GAUSSIAN' or 'TORUS') if ( kwargs_flux_compute["source_type"] in ["GAUSSIAN", "TORUS"] and flux_ratio_likelihood is True ): kwargs_constraints["source_size"] = True # e.g. power-law mass slope of the main deflector # [[index_model, 'param_name', mean, 1-sigma error], [...], ...] prior_lens = [[0, "gamma", 2, 0.1]] prior_special = [] kwargs_likelihood = { "position_uncertainty": args["astrometry_sigma"], "source_position_likelihood": True, "image_position_likelihood": True, "time_delay_likelihood": True, "flux_ratio_likelihood": True, "kwargs_flux_compute": kwargs_flux_compute, "prior_lens": prior_lens, "prior_special": prior_special, "check_solver": True, "solver_tolerance": 0.001, "check_bounds": True, } fitting_seq = FittingSequence( kwargs_data_joint, kwargs_model, kwargs_constraints, kwargs_likelihood, kwargs_params, ) fitting_kwargs_list = [ ["PSO", {"sigma_scale": 1.0, "n_particles": 200, "n_iterations": 500}] ] chain_list_pso = fitting_seq.fit_sequence(fitting_kwargs_list) kwargs_result = fitting_seq.best_fit() kwargs_result = fitting_seq.best_fit(bijective=True) args_result = fitting_seq.param_class.kwargs2args(**kwargs_result) logL, _ = fitting_seq.likelihoodModule.logL(args_result, verbose=True) # and now we run the MCMC fitting_kwargs_list = [ [ "MCMC", {"n_burn": 400, "n_run": 600, "walkerRatio": 10, "sigma_scale": 0.1}, ] ] chain_list_mcmc = fitting_seq.fit_sequence(fitting_kwargs_list) kwargs_result = fitting_seq.best_fit() # print("number of non-linear parameters in the MCMC process: ", len(param_mcmc)) # print("parameters in order: ", param_mcmc) print("number of evaluations in the MCMC process: ", np.shape(samples_mcmc)[0]) param = Param( kwargs_model, fixed_lens, kwargs_fixed_ps=fixed_ps, kwargs_fixed_special=fixed_special, kwargs_lens_init=kwargs_result["kwargs_lens"], **kwargs_constraints, ) # the number of non-linear parameters and their names # num_param, param_list = param.num_param() for i in range(len(samples_mcmc)): kwargs_out = param.args2kwargs(samples_mcmc[i]) kwargs_lens_out, kwargs_special_out, kwargs_ps_out = ( kwargs_out["kwargs_lens"], kwargs_out["kwargs_special"], kwargs_out["kwargs_ps"], ) # compute 'real' image position adding potential astrometric shifts x_pos = kwargs_ps_out[0]["ra_image"] y_pos = kwargs_ps_out[0]["dec_image"] # extract quantities of the main deflector theta_E = kwargs_lens_out[0]["theta_E"] gamma = kwargs_lens_out[0]["gamma"] e1, e2 = kwargs_lens_out[0]["e1"], kwargs_lens_out[0]["e2"] phi, q = param_util.ellipticity2phi_q(e1, e2) phi_ext, gamma_ext = ( kwargs_lens_out[1]["psi_ext"] % np.pi, kwargs_lens_out[1]["gamma_ext"], ) if flux_ratio_likelihood is True: mag = lensModel.magnification(x_pos, y_pos, kwargs_lens_out) flux_ratio_fit = mag[1:] / mag[0] if ( kwargs_constraints.get("source_size", False) is True and "source_size" not in fixed_special ): source_size = kwargs_special_out["source_size"] if time_delay_likelihood is True: D_dt = kwargs_special_out["D_dt"] # and here the predicted angular diameter distance from a # default cosmology (attention for experimenter bias!) gamma = np.median(gamma) phi_ext = np.median(phi_ext) gamma_ext = np.median(gamma_ext) theta_E = np.median(theta_E) D_dt = np.median(D_dt) results["gamma"].append(gamma) results["phi_ext"].append(phi_ext) results["gamma_ext"].append(gamma_ext) results["theta_E"].append(theta_E) results["H0"].append(c_light / D_dt)
class TestFittingSequence(object): """ test the fitting sequences """ 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 = Data(kwargs_data) kwargs_psf = sim_util.psf_configure_simple(psf_type='GAUSSIAN', fwhm=fwhm, kernelsize=11, deltaPix=deltaPix, truncate=3, kernel=None) kwargs_psf = sim_util.psf_configure_simple(psf_type='PIXEL', fwhm=fwhm, kernelsize=11, deltaPix=deltaPix, truncate=6, kernel=kwargs_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 = {'subgrid_res': 1, 'psf_subgrid': False} 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) 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} num_source_model = len(source_model_list) kwargs_constraints = { 'image_plane_source_list': [False] * num_source_model, } kwargs_likelihood = { 'source_marg': True, 'point_source_likelihood': False, 'position_uncertainty': 0.004, 'check_solver': False, 'solver_tolerance': 0.001, } self.param_class = Param(kwargs_model, **kwargs_constraints) self.Likelihood = LikelihoodModule(imSim_class=imageModel, param_class=self.param_class, **kwargs_likelihood) self.sampler = Sampler(likelihoodModule=self.Likelihood) def test_pso(self): n_particles = 2 n_iterations = 2 result, chain = self.sampler.pso(n_particles, n_iterations, lower_start=None, upper_start=None, threadCount=1, init_pos=None, mpi=False, print_key='PSO') assert len(result) == 16 def test_mcmc_emcee(self): n_walkers = 36 n_run = 2 n_burn = 2 mean_start = self.param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light) sigma_start = np.ones_like(mean_start) * 0.1 samples = self.sampler.mcmc_emcee(n_walkers, n_run, n_burn, mean_start, sigma_start, mpi=False) assert len(samples) == n_walkers * n_run def test_mcmc_CH(self): walkerRatio = 2 n_run = 2 n_burn = 2 mean_start = self.param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light) sigma_start = np.ones_like(mean_start) * 0.1 self.sampler.mcmc_CH(walkerRatio, n_run, n_burn, mean_start, sigma_start, threadCount=1, init_pos=None, mpi=False)
ct = (len(agn_image) - fit_frame_size) / 2 # If want to cut to 81, agn_image[ct:-ct,ct:-ct] agn_image = agn_image[ct:-ct, ct:-ct] kwargs_constraints = {'num_point_source_list': [1]} point_source_list = ['UNLENSED'] light_model_list = ['SERSIC_ELLIPSE'] * 3 kwargs_model = { 'source_light_model_list': light_model_list, 'point_source_model_list': point_source_list } from lenstronomy.Sampling.parameters import Param param = Param(kwargs_model, kwargs_fixed_source=source_params_2, kwargs_fixed_ps=ps_param_2, **kwargs_constraints) mcmc_new_list = [] from lenstronomy.ImSim.image_model import ImageModel import lenstronomy.Util.simulation_util as sim_util from lenstronomy.Data.imaging_data import Data kwargs_data = sim_util.data_configure_simple(81, 0.04, 1000, 0.001, inverse=True) data_class = Data(kwargs_data) data_class.update_data(agn_image) kernel_size = len(psf)
def test_mass_scaling(self): kwargs_model = { 'lens_model_list': ['SIS', 'NFW', 'NFW', 'SIS', 'SERSIC', 'HERNQUIST'] } kwargs_constraints = {'mass_scaling_list': [False, 1, 1, 1, 1, 1]} kwargs_fixed_lens = [{}, { 'theta_Rs': 0.1 }, { 'theta_Rs': 0.3 }, { 'theta_E': 0.1 }, { 'k_eff': 0.3 }, { 'sigma0': 1 }] kwargs_fixed_cosmo = {} param_class = Param(kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_cosmo=kwargs_fixed_cosmo, **kwargs_constraints) kwargs_lens = [{ 'theta_E': 1, 'center_x': 0, 'center_y': 0 }, { 'theta_Rs': 0.1, 'Rs': 5, 'center_x': 1., 'center_y': 0 }, { 'theta_Rs': 0.1, 'Rs': 5, 'center_x': 0, 'center_y': 1. }, { 'theta_E': 0.1, 'center_x': 3, 'center_y': 1. }, { 'k_eff': 0.3, 'R_sersic': 1, 'n_sersic': 2, 'center_x': 3, 'center_y': 1. }, { 'sigma0': 1, 'Rs': 1, 'center_x': 3, 'center_y': 1. }] kwargs_source = [] kwargs_lens_light = [] kwargs_ps = [] mass_scale = 2 kwargs_cosmo = {'scale_factor': [mass_scale]} args = param_class.kwargs2args(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps, kwargs_cosmo=kwargs_cosmo) assert args[-1] == mass_scale kwargs_lens, _, _, _, _ = param_class.args2kwargs(args) print(kwargs_lens, 'test') assert kwargs_lens[0]['theta_E'] == 1 assert kwargs_lens[1]['theta_Rs'] == 0.1 * mass_scale assert kwargs_lens[2]['theta_Rs'] == 0.3 * mass_scale assert kwargs_lens[3]['theta_E'] == 0.1 * mass_scale assert kwargs_lens[4]['k_eff'] == 0.3 * mass_scale assert kwargs_lens[5]['sigma0'] == 1 * mass_scale kwargs_lens, _, _, _, _ = param_class.args2kwargs(args, bijective=True) assert kwargs_lens[0]['theta_E'] == 1 assert kwargs_lens[1]['theta_Rs'] == 0.1 assert kwargs_lens[2]['theta_Rs'] == 0.3
def fit_qso_multiband(QSO_im_list, psf_ave_list, psf_std_list=None, source_params=None,ps_param=None, background_rms_list=[0.04]*5, pix_sz = 0.168, exp_time = 300., fix_n=None, image_plot = True, corner_plot=True, flux_ratio_plot=True, deep_seed = False, fixcenter = False, QSO_msk_list=None, QSO_std_list=None, tag = None, no_MCMC= False, pltshow = 1, new_band_seq=None): ''' A quick fit for the QSO image with (so far) single sersice + one PSF. The input psf noise is optional. Parameter -------- QSO_im: An array of the QSO image. psf_ave: The psf image. psf_std: The psf noise, optional. source_params: The prior for the source. Default is given. background_rms: default as 0.04 exp_time: default at 2400. deep_seed: if Ture, more mcmc steps will be performed. tag: The name tag for save the plot Return -------- Will output the fitted image (Set image_plot = True), the corner_plot and the flux_ratio_plot. source_result, ps_result, image_ps, image_host To do -------- ''' # data specifics need to set up based on the data situation background_rms_list = background_rms_list # background noise per pixel (Gaussian) exp_time = exp_time # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit) numPix = len(QSO_im_list[0]) # cutout pixel size deltaPix = pix_sz psf_type = 'PIXEL' # 'gaussian', 'pixel', 'NONE' kernel_list = psf_ave_list if new_band_seq == None: new_band_seq= range(len(QSO_im_list)) # if psf_std_list is not None: # kwargs_numerics_list = [{'subgrid_res': 1, 'psf_subgrid': False, 'psf_error_map': True}] * len(QSO_im_list) #Turn on the PSF error map # else: kwargs_numerics_list = [{'supersampling_factor': 1, 'supersampling_convolution': False}] * len(QSO_im_list) if source_params is None: # here are the options for the host galaxy fitting fixed_source = [] kwargs_source_init = [] kwargs_source_sigma = [] kwargs_lower_source = [] kwargs_upper_source = [] # Disk component, as modelled by an elliptical Sersic profile if fix_n == None: fixed_source.append({}) # we fix the Sersic index to n=1 (exponential) kwargs_source_init.append({'R_sersic': 0.3, 'n_sersic': 2., 'e1': 0., 'e2': 0., 'center_x': 0., 'center_y': 0.}) kwargs_source_sigma.append({'n_sersic': 0.5, 'R_sersic': 0.5, 'e1': 0.1, 'e2': 0.1, 'center_x': 0.1, 'center_y': 0.1}) kwargs_lower_source.append({'e1': -0.5, 'e2': -0.5, 'R_sersic': 0.1, 'n_sersic': 0.3, 'center_x': -10, 'center_y': -10}) kwargs_upper_source.append({'e1': 0.5, 'e2': 0.5, 'R_sersic': 3., 'n_sersic': 7., 'center_x': 10, 'center_y': 10}) elif fix_n is not None: fixed_source.append({'n_sersic': fix_n}) kwargs_source_init.append({'R_sersic': 0.3, 'n_sersic': fix_n, 'e1': 0., 'e2': 0., 'center_x': 0., 'center_y': 0.}) kwargs_source_sigma.append({'n_sersic': 0.001, 'R_sersic': 0.5, 'e1': 0.1, 'e2': 0.1, 'center_x': 0.1, 'center_y': 0.1}) kwargs_lower_source.append({'e1': -0.5, 'e2': -0.5, 'R_sersic': 0.1, 'n_sersic': fix_n, 'center_x': -10, 'center_y': -10}) kwargs_upper_source.append({'e1': 0.5, 'e2': 0.5, 'R_sersic': 3, 'n_sersic': fix_n, 'center_x': 10, 'center_y': 10}) source_params = [kwargs_source_init, kwargs_source_sigma, fixed_source, kwargs_lower_source, kwargs_upper_source] else: source_params = source_params if ps_param is None: center_x = 0.0 center_y = 0.0 point_amp = QSO_im_list[0].sum()/2. fixed_ps = [{}] kwargs_ps = [{'ra_image': [center_x], 'dec_image': [center_y], 'point_amp': [point_amp]}] kwargs_ps_init = kwargs_ps kwargs_ps_sigma = [{'ra_image': [0.01], 'dec_image': [0.01]}] kwargs_lower_ps = [{'ra_image': [-10], 'dec_image': [-10]}] kwargs_upper_ps = [{'ra_image': [10], 'dec_image': [10]}] ps_param = [kwargs_ps_init, kwargs_ps_sigma, fixed_ps, kwargs_lower_ps, kwargs_upper_ps] else: ps_param = ps_param kwargs_params = {'source_model': source_params, 'point_source_model': ps_param} #============================================================================== #Doing the QSO fitting #============================================================================== kwargs_data_list, data_class_list = [], [] for i in range(len(QSO_im_list)): kwargs_data_i = sim_util.data_configure_simple(numPix, deltaPix, exp_time, background_rms_list[i], inverse=True) kwargs_data_list.append(kwargs_data_i) data_class_list.append(ImageData(**kwargs_data_i)) kwargs_psf_list = [] psf_class_list = [] for i in range(len(QSO_im_list)): kwargs_psf_i = {'psf_type': psf_type, 'kernel_point_source': kernel_list[i]} kwargs_psf_list.append(kwargs_psf_i) psf_class_list.append(PSF(**kwargs_psf_i)) data_class_list[i].update_data(QSO_im_list[i]) light_model_list = ['SERSIC_ELLIPSE'] * len(source_params[0]) lightModel = LightModel(light_model_list=light_model_list) point_source_list = ['UNLENSED'] pointSource = PointSource(point_source_type_list=point_source_list) imageModel_list = [] for i in range(len(QSO_im_list)): kwargs_data_list[i]['image_data'] = QSO_im_list[i] # if QSO_msk_list is not None: # kwargs_numerics_list[i]['mask'] = QSO_msk_list[i] if QSO_std_list is not None: kwargs_data_list[i]['noise_map'] = QSO_std_list[i] # if psf_std_list is not None: # kwargs_psf_list[i]['psf_error_map'] = psf_std_list[i] image_band_list = [] for i in range(len(QSO_im_list)): imageModel_list.append(ImageModel(data_class_list[i], psf_class_list[i], source_model_class=lightModel, point_source_class=pointSource, kwargs_numerics=kwargs_numerics_list[i])) image_band_list.append([kwargs_data_list[i], kwargs_psf_list[i], kwargs_numerics_list[i]]) multi_band_list = [image_band_list[i] for i in range(len(QSO_im_list))] # numerical options and fitting sequences kwargs_model = { 'source_light_model_list': light_model_list, 'point_source_model_list': point_source_list } if fixcenter == False: kwargs_constraints = {'num_point_source_list': [1] } elif fixcenter == True: kwargs_constraints = {'joint_source_with_point_source': [[0, 0]], 'num_point_source_list': [1] } kwargs_likelihood = {'check_bounds': True, #Set the bonds, if exceed, reutrn "penalty" 'source_marg': False, #In likelihood_module.LikelihoodModule -- whether to fully invert the covariance matrix for marginalization 'check_positive_flux': True, 'image_likelihood_mask_list': [QSO_msk_list] } # mpi = False # MPI possible, but not supported through that notebook. # The Params for the fitting. kwargs_init: initial input. kwargs_sigma: The parameter uncertainty. kwargs_fixed: fixed parameters; #kwargs_lower,kwargs_upper: Lower and upper limits. kwargs_data_joint = {'multi_band_list': multi_band_list, 'multi_band_type': 'multi-linear'} # 'single-band', 'multi-linear', 'joint-linear' fitting_seq = FittingSequence(kwargs_data_joint, kwargs_model, kwargs_constraints, kwargs_likelihood, kwargs_params) if deep_seed == False: fitting_kwargs_list = [ ['PSO', {'sigma_scale': 0.8, 'n_particles': 80, 'n_iterations': 60, 'compute_bands': [True]+[False]*(len(QSO_im_list)-1)}], ['align_images', {'n_particles': 10, 'n_iterations': 10, 'compute_bands': [False]+[True]*(len(QSO_im_list)-1)}], ['PSO', {'sigma_scale': 0.8, 'n_particles': 100, 'n_iterations': 200, 'compute_bands': [True]*len(QSO_im_list)}], ['MCMC', {'n_burn': 10, 'n_run': 20, 'walkerRatio': 50, 'sigma_scale': .1}] ] elif deep_seed == True: fitting_kwargs_list = [ ['PSO', {'sigma_scale': 0.8, 'n_particles': 150, 'n_iterations': 60, 'compute_bands': [True]+[False]*(len(QSO_im_list)-1)}], ['align_images', {'n_particles': 20, 'n_iterations': 20, 'compute_bands': [False]+[True]*(len(QSO_im_list)-1)}], ['PSO', {'sigma_scale': 0.8, 'n_particles': 150, 'n_iterations': 200, 'compute_bands': [True]*len(QSO_im_list)}], ['MCMC', {'n_burn': 20, 'n_run': 40, 'walkerRatio': 50, 'sigma_scale': .1}] ] if no_MCMC == True: del fitting_kwargs_list[-1] start_time = time.time() # lens_result, source_result, lens_light_result, ps_result, cosmo_temp, chain_list, param_list, samples_mcmc, param_mcmc, dist_mcmc = fitting_seq.fit_sequence(fitting_kwargs_list) chain_list, param_list, samples_mcmc, param_mcmc, dist_mcmc = fitting_seq.fit_sequence(fitting_kwargs_list) lens_result, source_result, lens_light_result, ps_result, cosmo_temp = fitting_seq.best_fit() end_time = time.time() print(end_time - start_time, 'total time needed for computation') print('============ CONGRATULATION, YOUR JOB WAS SUCCESSFUL ================ ') source_result_list, ps_result_list = [], [] image_reconstructed_list, error_map_list, image_ps_list, image_host_list, shift_RADEC_list=[], [], [], [],[] imageLinearFit_list = [] for k in range(len(QSO_im_list)): # this is the linear inversion. The kwargs will be updated afterwards imageLinearFit_k = ImageLinearFit(data_class_list[k], psf_class_list[k], source_model_class=lightModel, point_source_class=pointSource, kwargs_numerics=kwargs_numerics_list[k]) image_reconstructed_k, error_map_k, _, _ = imageLinearFit_k.image_linear_solve(kwargs_source=source_result, kwargs_ps=ps_result) imageLinearFit_list.append(imageLinearFit_k) [kwargs_data_k, kwargs_psf_k, kwargs_numerics_k] = fitting_seq.multi_band_list[k] # data_class_k = data_class_list[k] #ImageData(**kwargs_data_k) # psf_class_k = psf_class_list[k] #PSF(**kwargs_psf_k) # imageModel_k = ImageModel(data_class_k, psf_class_k, source_model_class=lightModel, # point_source_class=pointSource, kwargs_numerics=kwargs_numerics_list[k]) imageModel_k = imageModel_list[k] modelPlot = ModelPlot(multi_band_list[k], kwargs_model, lens_result, source_result, lens_light_result, ps_result, arrow_size=0.02, cmap_string="gist_heat", likelihood_mask=QSO_im_list[k]) print("source_result", 'for', "k", source_result) image_host_k = [] for i in range(len(source_result)): image_host_k.append(imageModel_list[k].source_surface_brightness(source_result,de_lensed=True,unconvolved=False, k=i)) image_ps_k = imageModel_k.point_source(ps_result) # let's plot the output of the PSO minimizer image_reconstructed_list.append(image_reconstructed_k) source_result_list.append(source_result) ps_result_list.append(ps_result) error_map_list.append(error_map_k) image_ps_list.append(image_ps_k) image_host_list.append(image_host_k) if 'ra_shift' in fitting_seq.multi_band_list[k][0].keys(): shift_RADEC_list.append([fitting_seq.multi_band_list[k][0]['ra_shift'], fitting_seq.multi_band_list[k][0]['dec_shift']]) else: shift_RADEC_list.append([0,0]) if image_plot: f, axes = plt.subplots(3, 3, figsize=(16, 16), sharex=False, sharey=False) modelPlot.data_plot(ax=axes[0,0], text="Data") modelPlot.model_plot(ax=axes[0,1]) modelPlot.normalized_residual_plot(ax=axes[0,2], v_min=-6, v_max=6) modelPlot.decomposition_plot(ax=axes[1,0], text='Host galaxy', source_add=True, unconvolved=True) modelPlot.decomposition_plot(ax=axes[1,1], text='Host galaxy convolved', source_add=True) modelPlot.decomposition_plot(ax=axes[1,2], text='All components convolved', source_add=True, lens_light_add=True, point_source_add=True) modelPlot.subtract_from_data_plot(ax=axes[2,0], text='Data - Point Source', point_source_add=True) modelPlot.subtract_from_data_plot(ax=axes[2,1], text='Data - host galaxy', source_add=True) modelPlot.subtract_from_data_plot(ax=axes[2,2], text='Data - host galaxy - Point Source', source_add=True, point_source_add=True) f.tight_layout() if tag is not None: f.savefig('{0}_fitted_image_band{1}.pdf'.format(tag,new_band_seq[k])) if pltshow == 0: plt.close() else: plt.show() if corner_plot==True and no_MCMC==False and k ==0: # here the (non-converged) MCMC chain of the non-linear parameters if not samples_mcmc == []: n, num_param = np.shape(samples_mcmc) plot = corner.corner(samples_mcmc, labels=param_mcmc, show_titles=True) if tag is not None: plot.savefig('{0}_para_corner.pdf'.format(tag)) if pltshow == 0: plt.close() else: plt.show() if flux_ratio_plot==True and no_MCMC==False: param = Param(kwargs_model, kwargs_fixed_source=source_params[2], kwargs_fixed_ps=fixed_ps, **kwargs_constraints) mcmc_new_list = [] labels_new = [r"Quasar flux", r"host_flux", r"source_x", r"source_y"] # transform the parameter position of the MCMC chain in a lenstronomy convention with keyword arguments # for i in range(len(samples_mcmc)/10): kwargs_lens_out, kwargs_light_source_out, kwargs_light_lens_out, kwargs_ps_out, kwargs_cosmo = param.getParams(samples_mcmc[i+ len(samples_mcmc)/10*9]) image_reconstructed, _, _, _ = imageLinearFit_list[k].image_linear_solve(kwargs_source=kwargs_light_source_out, kwargs_ps=kwargs_ps_out) image_ps = imageModel_list[k].point_source(kwargs_ps_out) flux_quasar = np.sum(image_ps) image_disk = imageModel_list[k].source_surface_brightness(kwargs_light_source_out,de_lensed=True,unconvolved=False, k=0) flux_disk = np.sum(image_disk) source_x = kwargs_ps_out[0]['ra_image'] source_y = kwargs_ps_out[0]['dec_image'] if flux_disk>0: mcmc_new_list.append([flux_quasar, flux_disk, source_x, source_y]) plot = corner.corner(mcmc_new_list, labels=labels_new, show_titles=True) if tag is not None: plot.savefig('{0}_HOSTvsQSO_corner_band{1}.pdf'.format(tag,new_band_seq[k])) if pltshow == 0: plt.close() else: plt.show() errp_list = [] for k in range(len(QSO_im_list)): if QSO_std_list is None: errp_list.append(np.sqrt(data_class_list[k].C_D+np.abs(error_map_list[k]))) else: errp_list.append(np.sqrt(QSO_std_list[k]**2+np.abs(error_map_list[k]))) return source_result_list, ps_result_list, image_ps_list, image_host_list, errp_list, shift_RADEC_list, fitting_seq #fitting_seq.multi_band_list
class TestLikelihoodModule(object): """ test the fitting sequences """ def setup(self): np.random.seed(42) # 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 = 50 # cutout pixel size deltaPix = 0.1 # pixel size in arcsec (area per pixel = deltaPix**2) fwhm = 0.5 # full width half max of PSF kwargs_model = {'lens_model_list': ['SPEP'], 'lens_light_model_list': ['SERSIC'], 'source_light_model_list': ['SERSIC_ELLIPSE'], 'point_source_model_list': ['SOURCE_POSITION'], 'fixed_magnification_list': [True]} # PSF specification kwargs_band = sim_util.data_configure_simple(numPix, deltaPix, exp_time, sigma_bkg) data_class = ImageData(**kwargs_band) kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': fwhm, 'pixel_size': deltaPix} psf_class = PSF(**kwargs_psf) print(np.shape(psf_class.kernel_point_source), 'test kernel shape -') kwargs_spemd = {'theta_E': 1., 'gamma': 1.95, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1} self.kwargs_lens = [kwargs_spemd] kwargs_sersic = {'amp': 1/0.05**2., '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} self.kwargs_lens_light = [kwargs_sersic] self.kwargs_source = [kwargs_sersic_ellipse] self.kwargs_ps = [{'ra_source': 0.55, 'dec_source': 0.02, 'source_amp': 1.}] # quasar point source position in the source plane and intrinsic brightness self.kwargs_cosmo = {'D_dt': 1000} kwargs_numerics = {'supersampling_factor': 1, 'supersampling_convolution': False, 'compute_mode': 'gaussian'} lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_class = class_creator.create_class_instances(**kwargs_model) imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_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_band['image_data'] = image_sim self.data_class = data_class self.psf_class = psf_class self.kwargs_model = kwargs_model self.kwargs_numerics = { 'supersampling_factor': 1, 'supersampling_convolution': False} kwargs_constraints = { 'num_point_source_list': [4], 'solver_type': 'NONE', # 'PROFILE', 'PROFILE_SHEAR', 'ELLIPSE', 'CENTER' 'Ddt_sampling': True } def condition_definition(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps=None, kwargs_special=None, kwargs_extinction=None): logL = 0 if kwargs_lens_light[0]['R_sersic'] > kwargs_source[0]['R_sersic']: logL -= 10**15 return logL kwargs_likelihood = {'force_no_add_image': True, 'source_marg': True, 'astrometric_likelihood': True, 'position_uncertainty': 0.004, 'check_solver': True, 'solver_tolerance': 0.001, 'check_positive_flux': True, 'flux_ratio_likelihood': True, 'prior_lens': [[0, 'theta_E', 1, 0.1]], 'condition_definition': condition_definition } self.kwargs_data = {'multi_band_list': [[kwargs_band, kwargs_psf, kwargs_numerics]], 'multi_band_type': 'single-band', 'time_delays_measured': np.ones(4), 'time_delays_uncertainties': np.ones(4), 'flux_ratios': np.ones(4), 'flux_ratio_errors': np.ones(4) } self.param_class = Param(self.kwargs_model, **kwargs_constraints) 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.Likelihood = LikelihoodModule(kwargs_data_joint=self.kwargs_data, kwargs_model=kwargs_model, param_class=self.param_class, **kwargs_likelihood) def test_logL(self): args = self.param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light, kwargs_ps=self.kwargs_ps, kwargs_special=self.kwargs_cosmo) logL, _ = self.Likelihood.logL(args, verbose=True) num_data_evaluate = self.Likelihood.num_data npt.assert_almost_equal(logL/num_data_evaluate, -1/2., decimal=1) def test_time_delay_likelihood(self): kwargs_likelihood = {'time_delay_likelihood': True, } likelihood = LikelihoodModule(kwargs_data_joint=self.kwargs_data, kwargs_model=self.kwargs_model, param_class=self.param_class, **kwargs_likelihood) args = self.param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light, kwargs_ps=self.kwargs_ps, kwargs_special=self.kwargs_cosmo) logL, _ = likelihood.logL(args, verbose=True) npt.assert_almost_equal(logL, -3080.29, decimal=-1) #def test_solver(self): # make simulation with point source positions in image plane # x_pos, y_pos = self.imageModel.PointSource.image_position(self.kwargs_ps, self.kwargs_lens) # kwargs_ps = [{'ra_image': x_pos[0], 'dec_image': y_pos[0]}] # kwargs_likelihood = { # 'source_marg': True, # 'astrometric_likelihood': True, # 'position_uncertainty': 0.004, # 'check_solver': True, # 'solver_tolerance': 0.001, # 'check_positive_flux': True, # 'solver': True # } #imageModel = ImageModel(self.data_class, self.psf_class, self.lens_model_class, self.source_model_class, # self.lens_light_model_class, # point_source_class, kwargs_numerics=kwargs_numerics) 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 fit_qso(QSO_im, psf_ave, psf_std=None, source_params=None,ps_param=None, background_rms=0.04, pix_sz = 0.168, exp_time = 300., fix_n=None, image_plot = True, corner_plot=True, supersampling_factor = 2, flux_ratio_plot=False, deep_seed = False, fixcenter = False, QSO_msk=None, QSO_std=None, tag = None, no_MCMC= False, pltshow = 1, return_Chisq = False, dump_result = False, pso_diag=False): ''' A quick fit for the QSO image with (so far) single sersice + one PSF. The input psf noise is optional. Parameter -------- QSO_im: An array of the QSO image. psf_ave: The psf image. psf_std: The psf noise, optional. source_params: The prior for the source. Default is given. If [], means no Sersic light. background_rms: default as 0.04 exp_time: default at 2400. deep_seed: if Ture, more mcmc steps will be performed. tag: The name tag for save the plot Return -------- Will output the fitted image (Set image_plot = True), the corner_plot and the flux_ratio_plot. source_result, ps_result, image_ps, image_host To do -------- ''' # data specifics need to set up based on the data situation background_rms = background_rms # background noise per pixel (Gaussian) exp_time = exp_time # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit) numPix = len(QSO_im) # cutout pixel size deltaPix = pix_sz psf_type = 'PIXEL' # 'gaussian', 'pixel', 'NONE' kernel = psf_ave kwargs_numerics = {'supersampling_factor': supersampling_factor, 'supersampling_convolution': False} if source_params is None: # here are the options for the host galaxy fitting fixed_source = [] kwargs_source_init = [] kwargs_source_sigma = [] kwargs_lower_source = [] kwargs_upper_source = [] if fix_n == None: fixed_source.append({}) # we fix the Sersic index to n=1 (exponential) kwargs_source_init.append({'R_sersic': 0.3, 'n_sersic': 2., 'e1': 0., 'e2': 0., 'center_x': 0., 'center_y': 0.}) kwargs_source_sigma.append({'n_sersic': 0.5, 'R_sersic': 0.5, 'e1': 0.1, 'e2': 0.1, 'center_x': 0.1, 'center_y': 0.1}) kwargs_lower_source.append({'e1': -0.5, 'e2': -0.5, 'R_sersic': 0.1, 'n_sersic': 0.3, 'center_x': -10, 'center_y': -10}) kwargs_upper_source.append({'e1': 0.5, 'e2': 0.5, 'R_sersic': 3., 'n_sersic': 7., 'center_x': 10, 'center_y': 10}) elif fix_n is not None: fixed_source.append({'n_sersic': fix_n}) kwargs_source_init.append({'R_sersic': 0.3, 'n_sersic': fix_n, 'e1': 0., 'e2': 0., 'center_x': 0., 'center_y': 0.}) kwargs_source_sigma.append({'n_sersic': 0.001, 'R_sersic': 0.5, 'e1': 0.1, 'e2': 0.1, 'center_x': 0.1, 'center_y': 0.1}) kwargs_lower_source.append({'e1': -0.5, 'e2': -0.5, 'R_sersic': 0.1, 'n_sersic': fix_n, 'center_x': -10, 'center_y': -10}) kwargs_upper_source.append({'e1': 0.5, 'e2': 0.5, 'R_sersic': 3, 'n_sersic': fix_n, 'center_x': 10, 'center_y': 10}) source_params = [kwargs_source_init, kwargs_source_sigma, fixed_source, kwargs_lower_source, kwargs_upper_source] else: source_params = source_params if ps_param is None: center_x = 0.0 center_y = 0.0 point_amp = QSO_im.sum()/2. fixed_ps = [{}] kwargs_ps = [{'ra_image': [center_x], 'dec_image': [center_y], 'point_amp': [point_amp]}] kwargs_ps_init = kwargs_ps kwargs_ps_sigma = [{'ra_image': [0.05], 'dec_image': [0.05]}] kwargs_lower_ps = [{'ra_image': [-0.6], 'dec_image': [-0.6]}] kwargs_upper_ps = [{'ra_image': [0.6], 'dec_image': [0.6]}] ps_param = [kwargs_ps_init, kwargs_ps_sigma, fixed_ps, kwargs_lower_ps, kwargs_upper_ps] else: ps_param = ps_param #============================================================================== #Doing the QSO fitting #============================================================================== kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exp_time, background_rms, inverse=True) data_class = ImageData(**kwargs_data) kwargs_psf = {'psf_type': psf_type, 'kernel_point_source': kernel} psf_class = PSF(**kwargs_psf) data_class.update_data(QSO_im) point_source_list = ['UNLENSED'] * len(ps_param[0]) pointSource = PointSource(point_source_type_list=point_source_list) if fixcenter == False: kwargs_constraints = {'num_point_source_list': [1] * len(ps_param[0]) } elif fixcenter == True: kwargs_constraints = {'joint_source_with_point_source': [[i, i] for i in range(len(ps_param[0]))], 'num_point_source_list': [1] * len(ps_param[0]) } if source_params == []: #fitting image as Point source only. kwargs_params = {'point_source_model': ps_param} lightModel = None kwargs_model = {'point_source_model_list': point_source_list } imageModel = ImageModel(data_class, psf_class, point_source_class=pointSource, kwargs_numerics=kwargs_numerics) kwargs_likelihood = {'check_bounds': True, #Set the bonds, if exceed, reutrn "penalty" 'image_likelihood_mask_list': [QSO_msk] } elif source_params != []: kwargs_params = {'source_model': source_params, 'point_source_model': ps_param} light_model_list = ['SERSIC_ELLIPSE'] * len(source_params[0]) lightModel = LightModel(light_model_list=light_model_list) kwargs_model = { 'source_light_model_list': light_model_list, 'point_source_model_list': point_source_list } imageModel = ImageModel(data_class, psf_class, source_model_class=lightModel, point_source_class=pointSource, kwargs_numerics=kwargs_numerics) # numerical options and fitting sequences kwargs_likelihood = {'check_bounds': True, #Set the bonds, if exceed, reutrn "penalty" 'source_marg': False, #In likelihood_module.LikelihoodModule -- whether to fully invert the covariance matrix for marginalization 'check_positive_flux': True, 'image_likelihood_mask_list': [QSO_msk] } kwargs_data['image_data'] = QSO_im if QSO_std is not None: kwargs_data['noise_map'] = QSO_std if psf_std is not None: kwargs_psf['psf_error_map'] = psf_std image_band = [kwargs_data, kwargs_psf, kwargs_numerics] multi_band_list = [image_band] kwargs_data_joint = {'multi_band_list': multi_band_list, 'multi_band_type': 'multi-linear'} # 'single-band', 'multi-linear', 'joint-linear' fitting_seq = FittingSequence(kwargs_data_joint, kwargs_model, kwargs_constraints, kwargs_likelihood, kwargs_params) if deep_seed == False: fitting_kwargs_list = [ ['PSO', {'sigma_scale': 0.8, 'n_particles': 100, 'n_iterations': 60}], ['MCMC', {'n_burn': 10, 'n_run': 10, 'walkerRatio': 50, 'sigma_scale': .1}] ] elif deep_seed == True: fitting_kwargs_list = [ ['PSO', {'sigma_scale': 0.8, 'n_particles': 250, 'n_iterations': 250}], ['MCMC', {'n_burn': 100, 'n_run': 200, 'walkerRatio': 10, 'sigma_scale': .1}] ] if no_MCMC == True: fitting_kwargs_list = [fitting_kwargs_list[0], ] start_time = time.time() chain_list = fitting_seq.fit_sequence(fitting_kwargs_list) kwargs_result = fitting_seq.best_fit() ps_result = kwargs_result['kwargs_ps'] source_result = kwargs_result['kwargs_source'] if no_MCMC == False: sampler_type, samples_mcmc, param_mcmc, dist_mcmc = chain_list[1] end_time = time.time() print(end_time - start_time, 'total time needed for computation') print('============ CONGRATULATION, YOUR JOB WAS SUCCESSFUL ================ ') imageLinearFit = ImageLinearFit(data_class=data_class, psf_class=psf_class, source_model_class=lightModel, point_source_class=pointSource, kwargs_numerics=kwargs_numerics) image_reconstructed, error_map, _, _ = imageLinearFit.image_linear_solve(kwargs_source=source_result, kwargs_ps=ps_result) # this is the linear inversion. The kwargs will be updated afterwards modelPlot = ModelPlot(multi_band_list, kwargs_model, kwargs_result, arrow_size=0.02, cmap_string="gist_heat", likelihood_mask_list=[QSO_msk]) image_host = [] #!!! The linear_solver before and after LensModelPlot could have different result for very faint sources. for i in range(len(source_result)): image_host.append(imageModel.source_surface_brightness(source_result, de_lensed=True,unconvolved=False,k=i)) image_ps = [] for i in range(len(ps_result)): image_ps.append(imageModel.point_source(ps_result, k = i)) if pso_diag == True: f, axes = chain_plot.plot_chain_list(chain_list,0) if pltshow == 0: plt.close() else: plt.show() # let's plot the output of the PSO minimizer reduced_Chisq = imageLinearFit.reduced_chi2(image_reconstructed, error_map) if image_plot: f, axes = plt.subplots(3, 3, figsize=(16, 16), sharex=False, sharey=False) modelPlot.data_plot(ax=axes[0,0], text="Data") modelPlot.model_plot(ax=axes[0,1]) modelPlot.normalized_residual_plot(ax=axes[0,2], v_min=-6, v_max=6) modelPlot.decomposition_plot(ax=axes[1,0], text='Host galaxy', source_add=True, unconvolved=True) modelPlot.decomposition_plot(ax=axes[1,1], text='Host galaxy convolved', source_add=True) modelPlot.decomposition_plot(ax=axes[1,2], text='All components convolved', source_add=True, lens_light_add=True, point_source_add=True) modelPlot.subtract_from_data_plot(ax=axes[2,0], text='Data - Point Source', point_source_add=True) modelPlot.subtract_from_data_plot(ax=axes[2,1], text='Data - host galaxy', source_add=True) modelPlot.subtract_from_data_plot(ax=axes[2,2], text='Data - host galaxy - Point Source', source_add=True, point_source_add=True) f.tight_layout() #f.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0., hspace=0.05) if tag is not None: f.savefig('{0}_fitted_image.pdf'.format(tag)) if pltshow == 0: plt.close() else: plt.show() if corner_plot==True and no_MCMC==False: # here the (non-converged) MCMC chain of the non-linear parameters if not samples_mcmc == []: n, num_param = np.shape(samples_mcmc) plot = corner.corner(samples_mcmc, labels=param_mcmc, show_titles=True) if tag is not None: plot.savefig('{0}_para_corner.pdf'.format(tag)) plt.close() # if pltshow == 0: # plt.close() # else: # plt.show() if flux_ratio_plot==True and no_MCMC==False: param = Param(kwargs_model, kwargs_fixed_source=source_params[2], kwargs_fixed_ps=ps_param[2], **kwargs_constraints) mcmc_new_list = [] if len(ps_param[2]) == 1: labels_new = ["Quasar flux"] + ["host{0} flux".format(i) for i in range(len(source_params[0]))] else: labels_new = ["Quasar{0} flux".format(i) for i in range(len(ps_param[2]))] + ["host{0} flux".format(i) for i in range(len(source_params[0]))] if len(samples_mcmc) > 10000: trans_steps = [len(samples_mcmc)-10000, len(samples_mcmc)] else: trans_steps = [0, len(samples_mcmc)] for i in range(trans_steps[0], trans_steps[1]): kwargs_out = param.args2kwargs(samples_mcmc[i]) kwargs_light_source_out = kwargs_out['kwargs_source'] kwargs_ps_out = kwargs_out['kwargs_ps'] image_reconstructed, _, _, _ = imageLinearFit.image_linear_solve(kwargs_source=kwargs_light_source_out, kwargs_ps=kwargs_ps_out) flux_quasar = [] if len(ps_param[0]) == 1: image_ps_j = imageModel.point_source(kwargs_ps_out) flux_quasar.append(np.sum(image_ps_j)) else: for j in range(len(ps_param[0])): image_ps_j = imageModel.point_source(kwargs_ps_out, k=j) flux_quasar.append(np.sum(image_ps_j)) fluxs = [] for j in range(len(source_params[0])): image_j = imageModel.source_surface_brightness(kwargs_light_source_out,unconvolved= False, k=j) fluxs.append(np.sum(image_j)) mcmc_new_list.append(flux_quasar + fluxs ) if int(i/1000) > int((i-1)/1000) : print(len(samples_mcmc), "MCMC samplers in total, finished translate:", i ) plot = corner.corner(mcmc_new_list, labels=labels_new, show_titles=True) if tag is not None: plot.savefig('{0}_HOSTvsQSO_corner.pdf'.format(tag)) if pltshow == 0: plt.close() else: plt.show() if QSO_std is None: noise_map = np.sqrt(data_class.C_D+np.abs(error_map)) else: noise_map = np.sqrt(QSO_std**2+np.abs(error_map)) if dump_result == True: if flux_ratio_plot==True and no_MCMC==False: trans_paras = [mcmc_new_list, labels_new, 'mcmc_new_list, labels_new'] else: trans_paras = [] picklename= tag + '.pkl' best_fit = [source_result, image_host, ps_result, image_ps,'source_result, image_host, ps_result, image_ps'] chain_list_result = [chain_list, 'chain_list'] kwargs_fixed_source=source_params[2] kwargs_fixed_ps=ps_param[2] classes = data_class, psf_class, lightModel, pointSource material = multi_band_list, kwargs_model, kwargs_result, QSO_msk, kwargs_fixed_source, kwargs_fixed_ps, kwargs_constraints, kwargs_numerics, classes pickle.dump([best_fit, chain_list_result, trans_paras, material], open(picklename, 'wb')) if return_Chisq == False: return source_result, ps_result, image_ps, image_host, noise_map elif return_Chisq == True: return source_result, ps_result, image_ps, image_host, noise_map, reduced_Chisq
def fit_galaxy(galaxy_im, psf_ave, psf_std=None, source_params=None, background_rms=0.04, pix_sz = 0.08, exp_time = 300., fix_n=None, image_plot = True, corner_plot=True, deep_seed = False, galaxy_msk=None, galaxy_std=None, flux_corner_plot = False, tag = None, no_MCMC= False, pltshow = 1, return_Chisq = False, dump_result = False, pso_diag=False): ''' A quick fit for the QSO image with (so far) single sersice + one PSF. The input psf noise is optional. Parameter -------- galaxy_im: An array of the QSO image. psf_ave: The psf image. psf_std: The psf noise, optional. source_params: The prior for the source. Default is given. background_rms: default as 0.04 exp_time: default at 2400. deep_seed: if Ture, more mcmc steps will be performed. tag: The name tag for save the plot Return -------- Will output the fitted image (Set image_plot = True), the corner_plot and the flux_ratio_plot. source_result, ps_result, image_ps, image_host To do -------- ''' # data specifics need to set up based on the data situation background_rms = background_rms # background noise per pixel (Gaussian) exp_time = exp_time # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit) numPix = len(galaxy_im) # cutout pixel size deltaPix = pix_sz if psf_ave is not None: psf_type = 'PIXEL' # 'gaussian', 'pixel', 'NONE' kernel = psf_ave # if psf_std is not None: # kwargs_numerics = {'subgrid_res': 1, 'psf_error_map': True} #Turn on the PSF error map # else: kwargs_numerics = {'supersampling_factor': 1, 'supersampling_convolution': False} if source_params is None: # here are the options for the host galaxy fitting fixed_source = [] kwargs_source_init = [] kwargs_source_sigma = [] kwargs_lower_source = [] kwargs_upper_source = [] # Disk component, as modelled by an elliptical Sersic profile if fix_n == None: fixed_source.append({}) # we fix the Sersic index to n=1 (exponential) kwargs_source_init.append({'R_sersic': 0.3, 'n_sersic': 2., 'e1': 0., 'e2': 0., 'center_x': 0., 'center_y': 0.}) kwargs_source_sigma.append({'n_sersic': 0.5, 'R_sersic': 0.1, 'e1': 0.1, 'e2': 0.1, 'center_x': 0.1, 'center_y': 0.1}) kwargs_lower_source.append({'e1': -0.5, 'e2': -0.5, 'R_sersic': 0.01, 'n_sersic': 0.3, 'center_x': -10, 'center_y': -10}) kwargs_upper_source.append({'e1': 0.5, 'e2': 0.5, 'R_sersic': 3., 'n_sersic': 7., 'center_x': 10, 'center_y': 10}) elif fix_n is not None: fixed_source.append({'n_sersic': fix_n}) kwargs_source_init.append({'R_sersic': 0.3, 'n_sersic': fix_n, 'e1': 0., 'e2': 0., 'center_x': 0., 'center_y': 0.}) kwargs_source_sigma.append({'n_sersic': 0.001, 'R_sersic': 0.1, 'e1': 0.1, 'e2': 0.1, 'center_x': 0.1, 'center_y': 0.1}) kwargs_lower_source.append({'e1': -0.5, 'e2': -0.5, 'R_sersic': 0.01, 'n_sersic': fix_n, 'center_x': -10, 'center_y': -10}) kwargs_upper_source.append({'e1': 0.5, 'e2': 0.5, 'R_sersic': 3, 'n_sersic': fix_n, 'center_x': 10, 'center_y': 10}) source_params = [kwargs_source_init, kwargs_source_sigma, fixed_source, kwargs_lower_source, kwargs_upper_source] else: source_params = source_params kwargs_params = {'source_model': source_params} #============================================================================== #Doing the QSO fitting #============================================================================== kwargs_data = sim_util.data_configure_simple(numPix, deltaPix, exp_time, background_rms, inverse=True) data_class = ImageData(**kwargs_data) if psf_ave is not None: kwargs_psf = {'psf_type': psf_type, 'kernel_point_source': kernel} else: kwargs_psf = {'psf_type': 'NONE'} psf_class = PSF(**kwargs_psf) data_class.update_data(galaxy_im) light_model_list = ['SERSIC_ELLIPSE'] * len(source_params[0]) lightModel = LightModel(light_model_list=light_model_list) kwargs_model = { 'source_light_model_list': light_model_list} # numerical options and fitting sequences kwargs_constraints = {} kwargs_likelihood = {'check_bounds': True, #Set the bonds, if exceed, reutrn "penalty" 'source_marg': False, #In likelihood_module.LikelihoodModule -- whether to fully invert the covariance matrix for marginalization 'check_positive_flux': True, 'image_likelihood_mask_list': [galaxy_msk] } kwargs_data['image_data'] = galaxy_im if galaxy_std is not None: kwargs_data['noise_map'] = galaxy_std if psf_std is not None: kwargs_psf['psf_error_map'] = psf_std image_band = [kwargs_data, kwargs_psf, kwargs_numerics] multi_band_list = [image_band] kwargs_data_joint = {'multi_band_list': multi_band_list, 'multi_band_type': 'multi-linear'} # 'single-band', 'multi-linear', 'joint-linear' fitting_seq = FittingSequence(kwargs_data_joint, kwargs_model, kwargs_constraints, kwargs_likelihood, kwargs_params) if deep_seed == False: fitting_kwargs_list = [ ['PSO', {'sigma_scale': 0.8, 'n_particles': 50, 'n_iterations': 50}], ['MCMC', {'n_burn': 10, 'n_run': 10, 'walkerRatio': 50, 'sigma_scale': .1}] ] elif deep_seed == True: fitting_kwargs_list = [ ['PSO', {'sigma_scale': 0.8, 'n_particles': 100, 'n_iterations': 80}], ['MCMC', {'n_burn': 10, 'n_run': 15, 'walkerRatio': 50, 'sigma_scale': .1}] ] elif deep_seed == 'very_deep': fitting_kwargs_list = [ ['PSO', {'sigma_scale': 0.8, 'n_particles': 150, 'n_iterations': 150}], ['MCMC', {'n_burn': 10, 'n_run': 20, 'walkerRatio': 50, 'sigma_scale': .1}] ] if no_MCMC == True: fitting_kwargs_list = [fitting_kwargs_list[0], ] start_time = time.time() chain_list = fitting_seq.fit_sequence(fitting_kwargs_list) kwargs_result = fitting_seq.best_fit() ps_result = kwargs_result['kwargs_ps'] source_result = kwargs_result['kwargs_source'] if no_MCMC == False: sampler_type, samples_mcmc, param_mcmc, dist_mcmc = chain_list[1] # chain_list, param_list, samples_mcmc, param_mcmc, dist_mcmc = fitting_seq.fit_sequence(fitting_kwargs_list) # lens_result, source_result, lens_light_result, ps_result, cosmo_temp = fitting_seq.best_fit() end_time = time.time() print(end_time - start_time, 'total time needed for computation') print('============ CONGRATULATION, YOUR JOB WAS SUCCESSFUL ================ ') # this is the linear inversion. The kwargs will be updated afterwards imageModel = ImageModel(data_class, psf_class, source_model_class=lightModel,kwargs_numerics=kwargs_numerics) imageLinearFit = ImageLinearFit(data_class=data_class, psf_class=psf_class, source_model_class=lightModel, kwargs_numerics=kwargs_numerics) image_reconstructed, error_map, _, _ = imageLinearFit.image_linear_solve(kwargs_source=source_result, kwargs_ps=ps_result) # image_host = [] #!!! The linear_solver before and after could have different result for very faint sources. # for i in range(len(source_result)): # image_host_i = imageModel.source_surface_brightness(source_result,de_lensed=True,unconvolved=False, k=i) # print("image_host_i", source_result[i]) # print("total flux", image_host_i.sum()) # image_host.append(image_host_i) # let's plot the output of the PSO minimizer modelPlot = ModelPlot(multi_band_list, kwargs_model, kwargs_result, arrow_size=0.02, cmap_string="gist_heat", likelihood_mask_list=[galaxy_msk]) if pso_diag == True: f, axes = chain_plot.plot_chain_list(chain_list,0) if pltshow == 0: plt.close() else: plt.show() reduced_Chisq = imageLinearFit.reduced_chi2(image_reconstructed, error_map) if image_plot: f, axes = plt.subplots(1, 3, figsize=(16, 16), sharex=False, sharey=False) modelPlot.data_plot(ax=axes[0]) modelPlot.model_plot(ax=axes[1]) modelPlot.normalized_residual_plot(ax=axes[2], v_min=-6, v_max=6) f.tight_layout() #f.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=0., hspace=0.05) if tag is not None: f.savefig('{0}_fitted_image.pdf'.format(tag)) if pltshow == 0: plt.close() else: plt.show() image_host = [] for i in range(len(source_result)): image_host_i = imageModel.source_surface_brightness(source_result,de_lensed=True,unconvolved=False, k=i) # print("image_host_i", source_result[i]) # print("total flux", image_host_i.sum()) image_host.append(image_host_i) if corner_plot==True and no_MCMC==False: # here the (non-converged) MCMC chain of the non-linear parameters if not samples_mcmc == []: n, num_param = np.shape(samples_mcmc) plot = corner.corner(samples_mcmc, labels=param_mcmc, show_titles=True) if tag is not None: plot.savefig('{0}_para_corner.pdf'.format(tag)) if pltshow == 0: plt.close() else: plt.show() if flux_corner_plot ==True and no_MCMC==False: param = Param(kwargs_model, kwargs_fixed_source=source_params[2], **kwargs_constraints) mcmc_new_list = [] labels_new = ["host{0} flux".format(i) for i in range(len(source_params[0]))] for i in range(len(samples_mcmc)): kwargs_out = param.args2kwargs(samples_mcmc[i]) kwargs_light_source_out = kwargs_out['kwargs_source'] kwargs_ps_out = kwargs_out['kwargs_ps'] image_reconstructed, _, _, _ = imageLinearFit.image_linear_solve(kwargs_source=kwargs_light_source_out, kwargs_ps=kwargs_ps_out) fluxs = [] for j in range(len(source_params[0])): image_j = imageModel.source_surface_brightness(kwargs_light_source_out,unconvolved= False, k=j) fluxs.append(np.sum(image_j)) mcmc_new_list.append( fluxs ) if int(i/1000) > int((i-1)/1000) : print(len(samples_mcmc), "MCMC samplers in total, finished translate:", i ) plot = corner.corner(mcmc_new_list, labels=labels_new, show_titles=True) if tag is not None: plot.savefig('{0}_HOSTvsQSO_corner.pdf'.format(tag)) if pltshow == 0: plt.close() else: plt.show() if galaxy_std is None: noise_map = np.sqrt(data_class.C_D+np.abs(error_map)) else: noise_map = np.sqrt(galaxy_std**2+np.abs(error_map)) if dump_result == True: if flux_corner_plot==True and no_MCMC==False: trans_paras = [source_params[2], mcmc_new_list, labels_new, 'source_params[2], mcmc_new_list, labels_new'] else: trans_paras = [] picklename= tag + '.pkl' best_fit = [source_result, image_host, 'source_result, image_host'] # pso_fit = [chain_list, param_list, 'chain_list, param_list'] # mcmc_fit = [samples_mcmc, param_mcmc, dist_mcmc, 'samples_mcmc, param_mcmc, dist_mcmc'] chain_list_result = [chain_list, 'chain_list'] pickle.dump([best_fit, chain_list_result, trans_paras], open(picklename, 'wb')) if return_Chisq == False: return source_result, image_host, noise_map elif return_Chisq == True: return source_result, image_host, noise_map, reduced_Chisq
def setup(self): np.random.seed(42) # 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 = 50 # 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 = Data(kwargs_data) kwargs_psf = sim_util.psf_configure_simple(psf_type='GAUSSIAN', fwhm=fwhm, kernelsize=11, deltaPix=deltaPix, truncate=3, kernel=None) psf_class = PSF(kwargs_psf) kwargs_spemd = { 'theta_E': 1., 'gamma': 1.95, '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 / 0.05**2., '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) self.kwargs_ps = [ { 'ra_source': 0.55, 'dec_source': 0.02, 'source_amp': 1. } ] # quasar point source position in the source plane and intrinsic brightness self.kwargs_cosmo = {'D_dt': 1000} point_source_list = ['SOURCE_POSITION'] point_source_class = PointSource( point_source_type_list=point_source_list, fixed_magnification_list=[True]) kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False} 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.data_class = data_class self.psf_class = psf_class self.kwargs_model = { 'lens_model_list': lens_model_list, 'source_light_model_list': source_model_list, 'lens_light_model_list': lens_light_model_list, 'point_source_model_list': point_source_list, } self.kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False} kwargs_constraints = { 'num_point_source_list': [4], 'solver_type': 'NONE', # 'PROFILE', 'PROFILE_SHEAR', 'ELLIPSE', 'CENTER' 'cosmo_type': 'D_dt' } kwargs_likelihood = { 'force_no_add_image': True, 'source_marg': True, 'point_source_likelihood': True, 'position_uncertainty': 0.004, 'check_solver': True, 'solver_tolerance': 0.001, 'check_positive_flux': True, } self.param_class = Param(self.kwargs_model, **kwargs_constraints) 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.Likelihood = LikelihoodModule(imSim_class=self.imageModel, param_class=self.param_class, **kwargs_likelihood)
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, } # reduce number of param to sample (for runtime) kwargs_fixed_lens = [{ 'gamma': 1.8, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1 }] kwargs_lower_lens = [{'theta_E': 0.8}] kwargs_upper_lens = [{'theta_E': 1.2}] kwargs_fixed_source = [{ 'R_sersic': 0.6, 'n_sersic': 3, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1 }] kwargs_fixed_lens_light = [{ 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0 }] self.param_class = Param( kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_source=kwargs_fixed_source, kwargs_fixed_lens_light=kwargs_fixed_lens_light, kwargs_lower_lens=kwargs_lower_lens, kwargs_upper_lens=kwargs_upper_lens, **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.sampler = DynestySampler(self.Likelihood, prior_type='uniform', prior_means=prior_means, prior_sigmas=prior_sigmas, sigma_scale=0.5)
class TestSampler(object): """ test the fitting sequences """ 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, 'image_position_uncertainty': 0.004, 'check_matched_source_position': False, 'source_position_tolerance': 0.001, 'source_position_sigma': 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) self.sampler = Sampler(likelihoodModule=self.Likelihood) def test_pso(self): n_particles = 2 n_iterations = 2 result, chain = self.sampler.pso(n_particles, n_iterations, lower_start=None, upper_start=None, threadCount=1, init_pos=None, mpi=False, print_key='PSO') assert len(result) == 16 def test_mcmc_emcee(self): n_walkers = 36 n_run = 2 n_burn = 2 mean_start = self.param_class.kwargs2args( kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light) sigma_start = np.ones_like(mean_start) * 0.1 samples, dist = self.sampler.mcmc_emcee(n_walkers, n_run, n_burn, mean_start, sigma_start, mpi=False) assert len(samples) == n_walkers * n_run assert len(dist) == len(samples) # test of backup file # 1) run a chain specifiying a backup file name backup_filename = 'test_mcmc_emcee.h5' samples_1, dist_1 = self.sampler.mcmc_emcee( n_walkers, n_run, n_burn, mean_start, sigma_start, mpi=False, backend_filename=backup_filename) assert len(samples_1) == n_walkers * n_run # 2) run a chain starting from the backup of previous run samples_2, dist_2 = self.sampler.mcmc_emcee( n_walkers, n_run, n_burn, mean_start, sigma_start, mpi=False, backend_filename=backup_filename, start_from_backend=True) assert len(samples_2) == len(samples_1) + n_walkers * n_run assert len(dist_2) == len(samples_2) os.remove(backup_filename) # just remove the backup file created above def test_mcmc_zeus(self): n_walkers = 36 n_run = 2 n_burn = 2 mean_start = self.param_class.kwargs2args( kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source, kwargs_lens_light=self.kwargs_lens_light) sigma_start = np.ones_like(mean_start) * 0.1 samples, dist = self.sampler.mcmc_zeus(n_walkers, n_run, n_burn, mean_start, sigma_start) assert len(samples) == n_walkers * n_run assert len(dist) == len(samples) # test of backup file backup_filename = 'test_mcmc_zeus.h5' samples_1, dist_1 = self.sampler.mcmc_zeus( n_walkers, n_run, n_burn, mean_start, sigma_start, backend_filename=backup_filename) assert len(samples_1) == n_walkers * n_run os.remove(backup_filename)
def test_get_cosmo(self): kwargs_model = { 'lens_model_list': ['SPEP'], 'source_light_model_list': ['GAUSSIAN'], 'lens_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION'], } kwargs_param = {'cosmo_type': 'D_dt'} kwargs_fixed_lens = [{'gamma': 1.9}] # for SPEP lens kwargs_fixed_source = [{ 'sigma_x': 0.1, 'sigma_y': 0.1, 'center_x': 0.2, 'center_y': 0.2 }] kwargs_fixed_ps = [{'ra_image': [-1, 1], 'dec_image': [-1, 1]}] kwargs_fixed_lens_light = [{}] kwargs_fixed_cosmo = {'D_dt': 1000} param_class = Param(kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_source=kwargs_fixed_source, kwargs_fixed_lens_light=kwargs_fixed_lens_light, kwargs_fixed_ps=kwargs_fixed_ps, kwargs_fixed_cosmo=kwargs_fixed_cosmo, **kwargs_param) kwargs_true_lens = [{ 'theta_E': 1., 'gamma': 1.9, 'e1': 0.01, 'e2': -0.01, 'center_x': 0., 'center_y': 0. }] # for SPEP lens kwargs_true_source = [{ 'amp': 1 * 2 * np.pi * 0.1**2, 'center_x': 0.2, 'center_y': 0.2, 'sigma_x': 0.1, 'sigma_y': 0.1 }] kwargs_true_lens_light = [{ 'center_x': -0.06, 'center_y': 0.4, 'phi_G': 4.8, 'q': 0.86, 'n_sersic': 1.7, 'amp': 11.8, 'R_sersic': 0.697, 'phi_G_2': 0 }] kwargs_true_ps = [{ 'point_amp': [1, 1], 'ra_image': [-1, 1], 'dec_image': [-1, 1] }] args = param_class.kwargs2args( kwargs_true_lens, kwargs_true_source, kwargs_lens_light=kwargs_true_lens_light, kwargs_ps=kwargs_true_ps, kwargs_cosmo={'D_dt': 1000}) assert param_class.cosmoParams._Ddt_sampling is True
end_time = time.time() print(end_time - start_time, 'total time needed for computation') print( '============ CONGRATULATION, YOUR JOB WAS SUCCESSFUL ================ ' ) #Save in pickle fix_setting = [ fixed_lens, fixed_source, fixed_lens_light, None, fixed_cosmo ] # cosmo = FlatLambdaCDM(H0=70, Om0=0.3, Ob0=0.) #!!!Wrong cosmos # td_cosmo = TDCosmography(z_l, z_s, kwargs_model, cosmo_fiducial=cosmo) # make instance of parameter class with given model options, constraints and fixed parameters # param = Param(kwargs_model, fixed_lens, fixed_source, fixed_lens_light, None, fixed_cosmo, kwargs_lens_init=kwargs_result['kwargs_lens'], **kwargs_constraints) sampler_type, samples_mcmc, param_mcmc, dist_mcmc = chain_list[-1] mcmc_new_list = [] labels_new = [r"$\gamma$", r"$D_{\Delta t}$", "H$_0$"] for i in range(len(samples_mcmc)): # transform the parameter position of the MCMC chain in a lenstronomy convention with keyword arguments # kwargs_result = param.args2kwargs(samples_mcmc[i]) D_dt = kwargs_result['kwargs_special']['D_dt'] # fermat_pot = td_cosmo.fermat_potential(kwargs_result['kwargs_lens'], kwargs_result['kwargs_ps']) # delta_fermat_12 = fermat_pot[0] - fermat_pot[2] gamma = kwargs_result['kwargs_lens'][0]['gamma'] # phi_ext, gamma_ext = kwargs_result['kwargs_lens'][1]['gamma1'], kwargs_result['kwargs_lens'][1]['gamma2'] mcmc_new_list.append([gamma, D_dt, cal_h0(z_l, z_s, D_dt)])
class TestParam(object): def setup(self): kwargs_model = {'lens_model_list': ['SPEP'], 'source_light_model_list': ['GAUSSIAN'], 'lens_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION'], 'multi_plane': True, 'lens_redshift_list': [0.5], 'z_source': 2, 'source_redshift_list': [0.5]} kwargs_param = {'num_point_source_list': [2], 'lens_redshift_sampling_indexes': [0], 'source_redshift_sampling_indexes': [0], 'image_plane_source_list': [True]} kwargs_fixed_lens = [{'gamma': 1.9}] # for SPEP lens kwargs_fixed_source = [{'sigma': 0.1, 'center_x':0.2, 'center_y': 0.2}] kwargs_fixed_ps = [{'ra_image': [-1, 1], 'dec_image': [-1, 1]}] kwargs_fixed_lens_light = [{}] kwargs_fixed_cosmo = [{}] self.param_class = Param(kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_source=kwargs_fixed_source, kwargs_fixed_lens_light=kwargs_fixed_lens_light, kwargs_fixed_ps=kwargs_fixed_ps, kwargs_fixed_special=kwargs_fixed_cosmo, **kwargs_param) self.param_class.print_setting() def test_num_param(self): num_param, list = self.param_class.num_param() assert list[0] == 'theta_E_lens0' assert num_param == 10 kwargs_model = {'lens_model_list': ['SPEP'], 'source_light_model_list': ['GAUSSIAN'], 'lens_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION']} kwargs_param = {} kwargs_fixed_lens = [{'gamma': 1.9}] # for SPEP lens kwargs_fixed_source = [{'sigma': 0.1, 'center_x': 0.2, 'center_y': 0.2}] kwargs_fixed_ps = [{'ra_image': [-1, 1], 'dec_image': [-1, 1]}] kwargs_fixed_lens_light = [{}] kwargs_fixed_cosmo = [{}] param_class_linear = Param(kwargs_model, kwargs_fixed_lens, kwargs_fixed_source, kwargs_fixed_lens_light, kwargs_fixed_ps, kwargs_fixed_cosmo, linear_solver=True, **kwargs_param) num_param, list = param_class_linear.num_param() assert list[0] == 'theta_E_lens0' print(list) assert len(list) == num_param assert num_param == 9 def test_num_param_linear(self): num_param = self.param_class.num_param_linear() assert num_param == 4 def test_get_params(self): kwargs_true_lens = [{'theta_E': 1.,'gamma':1.9, 'e1':0.01, 'e2':-0.01, 'center_x':0., 'center_y':0.}] #for SPEP lens kwargs_true_source = [{'amp': 1*2*np.pi*0.1**2,'center_x':0.2, 'center_y':0.2, 'sigma': 0.1}] kwargs_true_lens_light = [{'center_x': -0.06, 'center_y': 0.4, 'phi_G': 4.8, 'q': 0.86, 'n_sersic': 1.7, 'amp': 11.8, 'R_sersic': 0.697, 'phi_G_2': 0}] kwargs_true_ps = [{'point_amp': [1, 1], 'ra_image': [-1, 1], 'dec_image': [-1, 1]}] kwargs_special = {'z_sampling': [0.5]} args = self.param_class.kwargs2args(kwargs_true_lens, kwargs_true_source, kwargs_lens_light=kwargs_true_lens_light, kwargs_ps=kwargs_true_ps, kwargs_special=kwargs_special) kwargs_return = self.param_class.args2kwargs(args) lens_dict_list = kwargs_return['kwargs_lens'] lens_light_dict_list = kwargs_return['kwargs_lens_light'] lens_dict = lens_dict_list[0] assert lens_dict['theta_E'] == 1. assert lens_dict['gamma'] == 1.9 assert lens_dict['e1'] == 0.01 assert lens_dict['e2'] == -0.01 assert lens_dict['center_x'] == 0. assert lens_dict['center_y'] == 0. assert lens_light_dict_list[0]['center_x'] == -0.06 def test_get_cosmo(self): kwargs_model = {'lens_model_list': ['SPEP'], 'source_light_model_list': ['GAUSSIAN'], 'lens_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION'], } kwargs_param = {'Ddt_sampling': True} kwargs_fixed_lens = [{'gamma': 1.9}] # for SPEP lens kwargs_fixed_source = [{'sigma': 0.1, 'center_x': 0.2, 'center_y': 0.2}] kwargs_fixed_ps = [{'ra_image': [-1, 1], 'dec_image': [-1, 1]}] kwargs_fixed_lens_light = [{}] kwargs_fixed_cosmo = {'D_dt': 1000} param_class = Param(kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_source=kwargs_fixed_source, kwargs_fixed_lens_light=kwargs_fixed_lens_light, kwargs_fixed_ps=kwargs_fixed_ps, kwargs_fixed_special=kwargs_fixed_cosmo, **kwargs_param) kwargs_true_lens = [ {'theta_E': 1., 'gamma': 1.9, 'e1':0.01, 'e2':-0.01, 'center_x': 0., 'center_y': 0.}] # for SPEP lens kwargs_true_source = [ {'amp': 1 * 2 * np.pi * 0.1 ** 2, 'center_x': 0.2, 'center_y': 0.2, 'sigma': 0.1}] kwargs_true_lens_light = [{'center_x': -0.06, 'center_y': 0.4, 'phi_G': 4.8, 'q': 0.86, 'n_sersic': 1.7, 'amp': 11.8, 'R_sersic': 0.697, 'phi_G_2': 0}] kwargs_true_ps = [{'point_amp': [1, 1], 'ra_image': [-1, 1], 'dec_image': [-1, 1]}] args = param_class.kwargs2args(kwargs_true_lens, kwargs_true_source, kwargs_lens_light=kwargs_true_lens_light, kwargs_ps=kwargs_true_ps, kwargs_special={'D_dt': 1000}) assert param_class.specialParams._D_dt_sampling is True def test_mass_scaling(self): kwargs_model = {'lens_model_list': ['SIS', 'NFW', 'NFW', 'SIS', 'SERSIC', 'HERNQUIST']} kwargs_constraints = {'mass_scaling_list': [False, 1, 1, 1, 1, 1]} kwargs_fixed_lens = [{}, {'alpha_Rs': 0.1}, {'alpha_Rs': 0.3}, {'theta_E': 0.1}, {'k_eff': 0.3}, {'sigma0': 1}] kwargs_fixed_cosmo = {} param_class = Param(kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_special=kwargs_fixed_cosmo , **kwargs_constraints) kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}, {'alpha_Rs': 0.1, 'Rs': 5, 'center_x': 1., 'center_y': 0}, {'alpha_Rs': 0.1, 'Rs': 5, 'center_x': 0, 'center_y': 1.}, {'theta_E': 0.1, 'center_x': 3, 'center_y': 1.}, {'k_eff': 0.3, 'R_sersic': 1, 'n_sersic': 2, 'center_x': 3, 'center_y': 1.}, {'sigma0': 1, 'Rs': 1, 'center_x': 3, 'center_y': 1.}] kwargs_source = [] kwargs_lens_light = [] kwargs_ps = [] mass_scale = 2 kwargs_cosmo = {'scale_factor': [mass_scale]} args = param_class.kwargs2args(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps, kwargs_special=kwargs_cosmo) assert args[-1] == mass_scale kwargs_return = param_class.args2kwargs(args) kwargs_lens = kwargs_return['kwargs_lens'] print(kwargs_lens, 'test') assert kwargs_lens[0]['theta_E'] == 1 assert kwargs_lens[1]['alpha_Rs'] == 0.1 * mass_scale assert kwargs_lens[2]['alpha_Rs'] == 0.3 * mass_scale assert kwargs_lens[3]['theta_E'] == 0.1 * mass_scale assert kwargs_lens[4]['k_eff'] == 0.3 * mass_scale assert kwargs_lens[5]['sigma0'] == 1 * mass_scale kwargs_return = param_class.args2kwargs(args, bijective=True) kwargs_lens = kwargs_return['kwargs_lens'] assert kwargs_lens[0]['theta_E'] == 1 assert kwargs_lens[1]['alpha_Rs'] == 0.1 assert kwargs_lens[2]['alpha_Rs'] == 0.3 def test_joint_lens_with_light(self): kwargs_model = {'lens_model_list': ['CHAMELEON'], 'lens_light_model_list': ['CHAMELEON']} i_light, k_lens = 0, 0 kwargs_constraints = {'joint_lens_with_light': [[i_light, k_lens, ['w_t', 'w_c', 'center_x', 'center_y', 'e1', 'e2']]]} kwargs_lens = [{'alpha_1': 10}] kwargs_lens_light = [{'amp': 1, 'w_t': 0.5, 'w_c': 0.1, 'center_x': 0, 'center_y': 0.3, 'e1': 0.1, 'e2': -0.2}] param = Param(kwargs_model=kwargs_model, **kwargs_constraints) args = param.kwargs2args(kwargs_lens=kwargs_lens, kwargs_lens_light=kwargs_lens_light) kwargs_return = param.args2kwargs(args) kwargs_lens_out = kwargs_return['kwargs_lens_light'] kwargs_lens_light_out = kwargs_return['kwargs_lens_light'] assert kwargs_lens_out[0]['w_c'] == kwargs_lens_light[0]['w_c'] assert kwargs_lens_light_out[0]['w_c'] == kwargs_lens_light[0]['w_c'] kwargs_model = {'lens_model_list': ['SIS'], 'lens_light_model_list': ['SERSIC']} i_light, k_lens = 0, 0 kwargs_constraints = {'joint_lens_with_light': [[i_light, k_lens, ['center_x', 'center_y']]]} # list[[i_point_source, k_source, ['param_name1', 'param_name2', ...]], [ kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}] kwargs_lens_light = [{'amp': 1, 'R_sersic': 0.5, 'n_sersic': 2, 'center_x': 1, 'center_y': 1}] param = Param(kwargs_model=kwargs_model, **kwargs_constraints) args = param.kwargs2args(kwargs_lens=kwargs_lens, kwargs_lens_light=kwargs_lens_light) #kwargs_lens_out, kwargs_source_out, _, kwargs_ps_out, _ = param.args2kwargs(args) kwargs_return = param.args2kwargs(args) kwargs_lens_out = kwargs_return['kwargs_lens'] assert kwargs_lens_out[0]['theta_E'] == kwargs_lens[0]['theta_E'] assert kwargs_lens_out[0]['center_x'] == kwargs_lens_light[0]['center_x'] def test_joint_source_with_point_source(self): kwargs_model = {'lens_model_list': ['SIS'], 'source_light_model_list': ['SERSIC'], 'point_source_model_list': ['SOURCE_POSITION']} i_source, k_ps = 0, 0 kwargs_constraints = {'joint_source_with_point_source': [[k_ps, i_source]]} # list[[i_point_source, k_source, ['param_name1', 'param_name2', ...]], [ kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}] kwargs_source = [{'amp': 1, 'n_sersic': 2, 'R_sersic': 0.3, 'center_x': 1, 'center_y': 1}] kwargs_ps = [{'ra_source': 0.5, 'dec_source': 0.5}] param = Param(kwargs_model=kwargs_model, **kwargs_constraints) args = param.kwargs2args(kwargs_lens=kwargs_lens, kwargs_source=kwargs_source, kwargs_ps=kwargs_ps) kwargs_return = param.args2kwargs(args) kwargs_lens_out = kwargs_return['kwargs_lens'] kwargs_source_out = kwargs_return['kwargs_source'] #kwargs_lens_out, kwargs_source_out, _, kwargs_ps_out, _ = param.args2kwargs(args) assert kwargs_lens_out[0]['theta_E'] == kwargs_lens[0]['theta_E'] assert kwargs_source_out[0]['center_x'] == kwargs_ps[0]['ra_source'] kwargs_model = {'lens_model_list': ['SIS'], 'source_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION']} i_source, k_ps = 0, 0 kwargs_constraints = {'joint_source_with_point_source': [[k_ps, i_source]]} # list[[i_point_source, k_source, ['param_name1', 'param_name2', ...]], [ kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}] kwargs_source = [{'amp': 1, 'n_sersic': 2, 'R_sersic': 0.3, 'center_x': 1, 'center_y': 1}] kwargs_ps = [{'ra_image': [0.5], 'dec_image': [0.5]}] param = Param(kwargs_model=kwargs_model, **kwargs_constraints) args = param.kwargs2args(kwargs_lens=kwargs_lens, kwargs_source=kwargs_source, kwargs_ps=kwargs_ps) #kwargs_lens_out, kwargs_source_out, _, kwargs_ps_out, _ = param.args2kwargs(args) kwargs_return = param.args2kwargs(args) kwargs_lens_out = kwargs_return['kwargs_lens'] kwargs_source_out = kwargs_return['kwargs_source'] assert kwargs_lens_out[0]['theta_E'] == kwargs_lens[0]['theta_E'] npt.assert_almost_equal(kwargs_source_out[0]['center_x'], -0.207, decimal=2) def test_joint_lens_light_with_point_source(self): kwargs_model = {'lens_model_list': ['SIS'], 'source_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION'], 'lens_light_model_list': ['SERSIC']} i_lens_light, k_ps = 0, 0 kwargs_constraints = {'joint_lens_light_with_point_source': [ [k_ps, i_lens_light]]} # list[[i_point_source, k_source, ['param_name1', 'param_name2', ...]], [ kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}] kwargs_source = [{'amp': 1, 'n_sersic': 2, 'R_sersic': 0.3, 'center_x': 1, 'center_y': 1}] kwargs_lens_light = [{'amp': 1, 'n_sersic': 2, 'R_sersic': 0.3, 'center_x': 0.2, 'center_y': 0.2}] kwargs_ps = [{'ra_image': [0.5], 'dec_image': [0.5]}] param = Param(kwargs_model=kwargs_model, **kwargs_constraints) args = param.kwargs2args(kwargs_lens=kwargs_lens, kwargs_source=kwargs_source, kwargs_lens_light=kwargs_lens_light, kwargs_ps=kwargs_ps) kwargs_return = param.args2kwargs(args) kwargs_lens_light_out = kwargs_return['kwargs_lens_light'] kwargs_ps_out = kwargs_return['kwargs_ps'] assert kwargs_lens_light_out[0]['center_x'] == kwargs_ps_out[0]['ra_image'] def test_with_solver(self): kwargs_model = {'lens_model_list': ['SPEP'], 'source_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION']} i_lens_light, k_ps = 0, 0 kwargs_constraints = {'solver_type': 'PROFILE', 'num_point_source_list': [4]} kwargs_lens = [{'theta_E': 1, 'gamma': 2, 'e1': 0.1, 'e2': 0.1, 'center_x': 0, 'center_y': 0}] kwargs_source = [{'amp': 1, 'n_sersic': 2, 'R_sersic': 0.3, 'center_x': 1, 'center_y': 1}] kwargs_lens_light = [{'amp': 1, 'n_sersic': 2, 'R_sersic': 0.3, 'center_x': 0.2, 'center_y': 0.2}] lensModel = LensModel(lens_model_list=['SPEP']) lensEquationSlover = LensEquationSolver(lensModel=lensModel) x_image, y_image = lensEquationSlover.image_position_from_source(sourcePos_x=0.0, sourcePos_y=0.01, kwargs_lens=kwargs_lens) print(x_image, y_image, 'test') kwargs_ps = [{'ra_image': x_image, 'dec_image': y_image}] param = Param(kwargs_model=kwargs_model, kwargs_lens_init=kwargs_lens, **kwargs_constraints) args = param.kwargs2args(kwargs_lens=kwargs_lens, kwargs_source=kwargs_source, kwargs_lens_light=kwargs_lens_light, kwargs_ps=kwargs_ps) #kwargs_lens_out, kwargs_source_out, kwargs_lens_light_out, kwargs_ps_out, _ = param.args2kwargs(args) kwargs_return = param.args2kwargs(args) kwargs_lens_out = kwargs_return['kwargs_lens'] kwargs_ps_out = kwargs_return['kwargs_ps'] dist = param.check_solver(kwargs_lens=kwargs_lens_out, kwargs_ps=kwargs_ps_out) npt.assert_almost_equal(dist, 0, decimal=10) def test_num_point_source_images(self): num = self.param_class.num_point_source_images assert num == 2 def test_shapelet_lens(self): kwargs_model = {'lens_model_list': ['SHAPELETS_CART'], 'source_light_model_list': [], 'lens_light_model_list': [], 'point_source_model_list': []} kwargs_param = {'num_shapelet_lens': 6} kwargs_fixed_lens = [{'beta': 1}] # for SPEP lens kwargs_fixed_source = [{}] kwargs_fixed_ps = [{}] kwargs_fixed_lens_light = [{}] kwargs_fixed_cosmo = [{}] self.param_class = Param(kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_source=kwargs_fixed_source, kwargs_fixed_lens_light=kwargs_fixed_lens_light, kwargs_fixed_ps=kwargs_fixed_ps, kwargs_fixed_special=kwargs_fixed_cosmo, **kwargs_param) self.param_class.print_setting()
class TestMultiNestSampler(object): """ test the fitting sequences """ 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) def test_sampler(self): kwargs_run = { 'n_live_points': 10, 'evidence_tolerance': 0.5, 'sampling_efficiency': 0.8, # 1 for posterior-only, 0 for evidence-only 'importance_nested_sampling': False, 'multimodal': True, 'const_efficiency_mode': False, # reduce sampling_efficiency to 5% when True } samples, means, logZ, logZ_err, logL, results = self.sampler.run( kwargs_run) assert len(means) == 16 if not pymultinest_installed: # trivial test when pymultinest is not installed properly assert np.count_nonzero(samples) == 0 if os.path.exists(self.output_dir): shutil.rmtree(self.output_dir, ignore_errors=True) def test_sampler_init(self): test_dir = 'some_dir' os.mkdir(test_dir) sampler = MultiNestSampler(self.Likelihood, prior_type='uniform', output_dir=test_dir) shutil.rmtree(test_dir, ignore_errors=True) try: sampler = MultiNestSampler( self.Likelihood, prior_type='gaussian', prior_means=None, # will raise an Error prior_sigmas=None, # will raise an Error output_dir=None, remove_output_dir=True) except Exception as e: assert isinstance(e, ValueError) try: sampler = MultiNestSampler(self.Likelihood, prior_type='some_type') except Exception as e: assert isinstance(e, ValueError) def test_prior(self): n_dims = self.sampler.n_dims cube_low = np.zeros(n_dims) cube_upp = np.ones(n_dims) self.prior_type = 'uniform' self.sampler.prior(cube_low, n_dims, n_dims) npt.assert_equal(cube_low, self.sampler.lowers) self.sampler.prior(cube_upp, n_dims, n_dims) npt.assert_equal(cube_upp, self.sampler.uppers) cube_mid = 0.5 * np.ones(n_dims) self.prior_type = 'gaussian' self.sampler.prior(cube_mid, n_dims, n_dims) cube_gauss = np.array([ 50., 50., 0., 0., 0., 0., 50., 4.25, 0., 0., 0., 0., 50., 4.25, 0., 0. ]) npt.assert_equal(cube_mid, cube_gauss) def test_log_likelihood(self): n_dims = self.sampler.n_dims args = np.nan * np.ones(n_dims) logL = self.sampler.log_likelihood(args, n_dims, n_dims) npt.assert_almost_equal(logL, -53.24465641401431, decimal=8)
['psf_iteration', kwargs_psf_iter], ['PSO', {'sigma_scale': .1, 'n_particles': 150, 'n_iterations': 100}], ['psf_iteration', kwargs_psf_iter], ['MCMC', {'n_burn': 300, 'n_run': 400, 'walkerRatio': 6, 'sigma_scale': 0.1}], ] chain_list = fitting_seq.fit_sequence(fitting_kwargs_list_1) kwargs_result_best = fitting_seq.best_fit() end_time = time.time() print(end_time - start_time, 'total time needed for computation') print('============ CONGRATULATION, YOUR JOB WAS SUCCESSFUL ================ ') #Save in pickle fix_setting = [fixed_lens, fixed_source, fixed_lens_light, fixed_ps, fixed_special] # cosmo = FlatLambdaCDM(H0=70, Om0=0.3, Ob0=0.) #!!!Wrong cosmos # td_cosmo = TDCosmography(z_l, z_s, kwargs_model, cosmo_fiducial=cosmo) # make instance of parameter class with given model options, constraints and fixed parameters # param = Param(kwargs_model, fixed_lens, fixed_source, fixed_lens_light, fixed_ps, fixed_special, kwargs_lens_init=kwargs_result_best['kwargs_lens'], **kwargs_constraints) sampler_type, samples_mcmc, param_mcmc, dist_mcmc = chain_list[-1] mcmc_new_list = [] labels_new = [r"$\gamma$", r"$D_{\Delta t}$","H$_0$" ] for i in range(len(samples_mcmc)): # transform the parameter position of the MCMC chain in a lenstronomy convention with keyword arguments # kwargs_result = param.args2kwargs(samples_mcmc[i]) D_dt = kwargs_result['kwargs_special']['D_dt'] # fermat_pot = td_cosmo.fermat_potential(kwargs_result['kwargs_lens'], kwargs_result['kwargs_ps']) # delta_fermat_12 = fermat_pot[0] - fermat_pot[2] gamma = kwargs_result['kwargs_lens'][0]['gamma'] # phi_ext, gamma_ext = kwargs_result['kwargs_lens'][1]['gamma1'], kwargs_result['kwargs_lens'][1]['gamma2'] mcmc_new_list.append([gamma, D_dt, cal_h0(z_l ,z_s, D_dt)]) pickle.dump([multi_band_list, kwargs_model, kwargs_result, chain_list, fix_setting, mcmc_new_list], open(folder+savename, 'wb')) #%%Print fitting result:
} ]] chain_list_mcmc = fitting_seq.fit_sequence(fitting_kwargs_list) kwargs_result = fitting_seq.best_fit() args_result = fitting_seq.param_class.kwargs2args(**kwargs_result) logL = fitting_seq.likelihoodModule.logL(args_result, verbose=True) sampler_type, samples_mcmc, param_mcmc, dist_mcmc = chain_list_mcmc[0] # import the parameter handling class # from lenstronomy.Sampling.parameters import Param import lenstronomy.Util.param_util as param_util param = Param(kwargs_model, fixed_lens, kwargs_fixed_ps=fixed_ps, kwargs_fixed_special=fixed_special, kwargs_lens_init=kwargs_result['kwargs_lens'], **kwargs_constraints) # the number of non-linear parameters and their names # num_param, param_list = param.num_param() lensModel = LensModel(kwargs_model['lens_model_list']) lensModelExtensions = LensModelExtensions(lensModel=lensModel) mcmc_new_list = [] if fix_gamma: labels_new = [ r"$\theta_E$", r"$\phi_{lens}$", r"$q$", r"$D_{dt}$", r"$H_0$" ] else: labels_new = [
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 = Data(kwargs_data) kwargs_psf = sim_util.psf_configure_simple(psf_type='GAUSSIAN', fwhm=fwhm, kernelsize=11, deltaPix=deltaPix, truncate=3, kernel=None) kwargs_psf = sim_util.psf_configure_simple(psf_type='PIXEL', fwhm=fwhm, kernelsize=11, deltaPix=deltaPix, truncate=6, kernel=kwargs_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 = {'subgrid_res': 1, 'psf_subgrid': False} 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) 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} num_source_model = len(source_model_list) kwargs_constraints = { 'image_plane_source_list': [False] * num_source_model, } kwargs_likelihood = { 'source_marg': True, 'point_source_likelihood': False, 'position_uncertainty': 0.004, 'check_solver': False, 'solver_tolerance': 0.001, } self.param_class = Param(kwargs_model, **kwargs_constraints) self.Likelihood = LikelihoodModule(imSim_class=imageModel, param_class=self.param_class, **kwargs_likelihood) self.sampler = Sampler(likelihoodModule=self.Likelihood)
def sl_sys_analysis(): # Get command line arguments args = {} if comm_rank == 0: print(":Registered %d processes" % comm_size) args["infile"] = sys.argv[1] args["nimgs"] = sys.argv[2] args["los"] = sys.argv[3] args = comm.bcast(args) # Organize devision of strong lensing systems with open(args["infile"], "r") as myfile: limg_data = myfile.read() systems = json.loads(limg_data) sys_nr_per_proc = int(len(systems) / comm_size) start_sys = sys_nr_per_proc * comm_rank end_sys = sys_nr_per_proc * (comm_rank + 1) with open("../lens_catalogs_sie_only.json", "r") as myfile: limg_data = myfile.read() systems_prior = json.loads(limg_data) if comm_rank == 0: print("Each process will have %d systems" % sys_nr_per_proc) print("That should take app. %f min." % (sys_nr_per_proc * 20)) results = {"D_dt": []} for ii in range(len(systems))[(start_sys + 2) : end_sys]: system = systems[ii] system_prior = systems_prior[ii] print("Analysing system ID: %d" % system["losID"]) # the data set is z_lens = system_prior["zl"] z_source = 2.0 # image positions units of arcsec # time delays units of days # image brightness # amplitude (in arbitrary linear units, not magnitudes) ximg = [] yimg = [] delay = [] image_amps = [] for jj in range(system["nimgs"]): ximg.append(system["ximg"][jj]) yimg.append(system["yimg"][jj]) delay.append(system["delay"][jj]) image_amps.append(system["mags"][jj]) ximg = np.asarray(ximg) yimg = np.asarray(yimg) # 1-sigma astrometric uncertainties of the image positions # (assuming equal precision) astrometry_sigma = 0.004 delay = np.asarray(delay) d_dt = delay[1:] - delay[0] # 1-sigma uncertainties in the time-delay measurement (in units of days) d_dt_sigma = np.ones(system["nimgs"] - 1) * 2 image_amps = np.asarray(image_amps) image_amps_sigma = np.ones(system["nimgs"]) * 0.3 flux_ratios = image_amps[1:] - image_amps[0] flux_ratio_errors = np.ones(system["nimgs"] - 1) * 0.1 # lens model choicers lens_model_list = ["SPEP", "SHEAR"] fixed_lens = [] kwargs_lens_init = [] kwargs_lens_sigma = [] kwargs_lower_lens = [] kwargs_upper_lens = [] fixed_lens.append({}) kwargs_lens_init.append( { "theta_E": 1.0, "gamma": 2, "center_x": 0, "center_y": 0, "e1": 0, "e2": 0.0, } ) kwargs_lens_sigma.append( { "theta_E": 0.2, "e1": 0.1, "e2": 0.1, "gamma": 0.1, "center_x": 0.1, "center_y": 0.1, } ) kwargs_lower_lens.append( { "theta_E": 0.01, "e1": -0.5, "e2": -0.5, "gamma": 1.5, "center_x": -10, "center_y": -10, } ) kwargs_upper_lens.append( { "theta_E": 10, "e1": 0.5, "e2": 0.5, "gamma": 2.5, "center_x": 10, "center_y": 10, } ) fixed_lens.append({"ra_0": 0, "dec_0": 0}) kwargs_lens_init.append({"e1": 0.0, "e2": 0.0}) kwargs_lens_sigma.append({"e1": 0.1, "e2": 0.1}) kwargs_lower_lens.append({"e1": -0.2, "e2": -0.2}) kwargs_upper_lens.append({"e1": 0.2, "e2": 0.2}) lens_params = [ kwargs_lens_init, kwargs_lens_sigma, fixed_lens, kwargs_lower_lens, kwargs_upper_lens, ] point_source_list = ["LENSED_POSITION"] fixed_ps = [ {"ra_image": ximg, "dec_image": yimg} ] # we fix the image position coordinates kwargs_ps_init = fixed_ps kwargs_ps_sigma = [ { "ra_image": 0.01 * np.ones(len(ximg)), "dec_image": 0.01 * np.ones(len(ximg)), } ] kwargs_lower_ps = [ { "ra_image": -10 * np.ones(len(ximg)), "dec_image": -10 * np.ones(len(ximg)), } ] kwargs_upper_ps = [ {"ra_image": 10 * np.ones(len(ximg)), "dec_image": 10 * np.ones(len(ximg))} ] ps_params = [ kwargs_ps_init, kwargs_ps_sigma, fixed_ps, kwargs_lower_ps, kwargs_upper_ps, ] # we let some freedome in how well the actual image positions are matching those # given by the data (indicated as 'ra_image', 'dec_image' and held fixed while fitting) fixed_cosmo = {} kwargs_cosmo_init = { "D_dt": 5000, "delta_x_image": np.zeros_like(ximg), "delta_y_image": np.zeros_like(ximg), } kwargs_cosmo_sigma = { "D_dt": 10000, "delta_x_image": np.ones_like(ximg) * astrometry_sigma, "delta_y_image": np.ones_like(ximg) * astrometry_sigma, } kwargs_lower_cosmo = { "D_dt": 0, "delta_x_image": np.ones_like(ximg) * (-1), "delta_y_image": np.ones_like(ximg) * (-1), } kwargs_upper_cosmo = { "D_dt": 10000, "delta_x_image": np.ones_like(ximg) * (1), "delta_y_image": np.ones_like(ximg) * (1), } cosmo_params = [ kwargs_cosmo_init, kwargs_cosmo_sigma, fixed_cosmo, kwargs_lower_cosmo, kwargs_upper_cosmo, ] kwargs_params = { "lens_model": lens_params, "point_source_model": ps_params, "cosmography": cosmo_params, } # ## setup options for likelihood and parameter sampling kwargs_constraints = { "num_point_source_list": [4], # any proposed lens model must satisfy the image positions # appearing at the position of the point sources being sampeld "solver_type": "PROFILE_SHEAR", "cosmo_type": "D_dt", # sampling of the time-delay distance # explicit modelling of the astrometric imperfection of # the point source positions "point_source_offset": True, } kwargs_likelihood = { "check_bounds": True, "point_source_likelihood": True, "position_uncertainty": astrometry_sigma, "check_solver": True, "solver_tolerance": 0.001, "time_delay_likelihood": True, "image_likelihood": False, # this needs to be explicitly given when not having imaging data "flux_ratio_likelihood": True, # enables the flux ratio likelihood } kwargs_data_joint = { "time_delays_measured": d_dt, "time_delays_uncertainties": d_dt_sigma, "flux_ratios": flux_ratios, "flux_ratio_errors": flux_ratio_errors, } kwargs_model = { "lens_model_list": lens_model_list, "point_source_model_list": point_source_list, } mpi = False # MPI possible, but not supported through that notebook. fitting_seq = FittingSequence( kwargs_data_joint, kwargs_model, kwargs_constraints, kwargs_likelihood, kwargs_params, ) fitting_kwargs_list = [ # ['update_settings', {'lens_add_fixed': [[0, ['gamma']]]}], ["PSO", {"sigma_scale": 1.0, "n_particles": 100, "n_iterations": 100}] ] chain_list, param_list, samples_mcmc, param_mcmc, dist_mcmc = fitting_seq.fit_sequence( fitting_kwargs_list ) lens_result, source_result, lens_light_result, ps_result, cosmo_result = ( fitting_seq.best_fit() ) # and now we run the MCMC fitting_kwargs_list = [ ["PSO", {"sigma_scale": 0.1, "n_particles": 100, "n_iterations": 100}], [ "MCMC", {"n_burn": 200, "n_run": 200, "walkerRatio": 10, "sigma_scale": 0.1}, ], ] chain_list, param_list, samples_mcmc, param_mcmc, dist_mcmc = fitting_seq.fit_sequence( fitting_kwargs_list ) lens_result, source_result, lens_light_result, ps_result, cosmo_result = ( fitting_seq.best_fit() ) # print("number of non-linear parameters in the MCMC process: ", len(param_mcmc)) # print("parameters in order: ", param_mcmc) print("number of evaluations in the MCMC process: ", np.shape(samples_mcmc)[0]) param = Param( kwargs_model, fixed_lens, kwargs_fixed_ps=fixed_ps, kwargs_fixed_cosmo=fixed_cosmo, kwargs_lens_init=lens_result, **kwargs_constraints, ) # the number of non-linear parameters and their names # num_param, param_list = param.num_param() lensAnalysis = LensAnalysis(kwargs_model) mcmc_new_list = [] labels_new = [ r"$\gamma$", r"$\phi_{ext}$", r"$\gamma_{ext}$", r"$D_{\Delta t}$", ] for i in range(len(samples_mcmc)): # transform the parameter position of the MCMC chain in a # lenstronomy convention with keyword arguments # kwargs_lens_out, kwargs_light_source_out, kwargs_light_lens_out, kwargs_ps_out, kwargs_cosmo = param.args2kwargs( samples_mcmc[i] ) D_dt = kwargs_cosmo["D_dt"] gamma = kwargs_lens_out[0]["gamma"] phi_ext, gamma_ext = lensAnalysis._lensModelExtensions.external_shear( kwargs_lens_out ) mcmc_new_list.append([gamma, phi_ext, gamma_ext, D_dt]) # plot = corner.corner(mcmc_new_list, labels=labels_new, show_titles=True) # and here the predicted angular diameter distance from a # default cosmology (attention for experimenter bias!) lensCosmo = LensCosmo(z_lens=z_lens, z_source=z_source) results["D_dt"].append(D_dt) f = h5py.File( "H0_" + args["los"] + "_nimgs" + str(args["nimgs"]) + "_" + str(comm_rank) + ".hdf5", "w", ) hf.create_dataset("D_dt", data=results["D_dt"]) hf.close()