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 __init__(self, multi_band_list, kwargs_model, kwargs_constraints, kwargs_likelihood, kwargs_params, verbose=True): self.multi_band_list = multi_band_list self.kwargs_model = kwargs_model self.kwargs_constraints = kwargs_constraints self.kwargs_likelihood = kwargs_likelihood self.kwargs_params = kwargs_params self._verbose = verbose self.fitting = Fitting(multi_band_list=self.multi_band_list, kwargs_model=self.kwargs_model, kwargs_constraints=self.kwargs_constraints, kwargs_likelihood=self.kwargs_likelihood, kwargs_params=self.kwargs_params) self._param = Param(kwargs_model, kwargs_constraints, fix_lens_solver=True) if 'source_model' in self.kwargs_params: kwargs_init, _, kwargs_fixed, _, _ = self.kwargs_params[ 'source_model'] else: kwargs_init, kwargs_fixed = [], [] self._kwargs_source_init = copy.deepcopy(kwargs_init) self._kwargs_source_fixed = copy.deepcopy(kwargs_fixed) self._lens_temp, self._source_temp, self._lens_light_temp, self._ps_temp, self._cosmo_temp = self.fitting.init_kwargs( )
def param_class(self): """ :return: instance of the Param class with the recent options and bounds """ kwargs_fixed_lens, kwargs_fixed_source, kwargs_fixed_lens_light, kwargs_fixed_ps, kwargs_fixed_special, kwargs_fixed_extinction = self.fixed_kwargs kwargs_lower_lens, kwargs_lower_source, kwargs_lower_lens_light, kwargs_lower_ps, kwargs_lower_special, kwargs_lower_extinction = self._lower_kwargs kwargs_upper_lens, kwargs_upper_source, kwargs_upper_lens_light, kwargs_upper_ps, kwargs_upper_special, kwargs_upper_extinction = self._upper_kwargs kwargs_model = self.kwargs_model kwargs_constraints = self.kwargs_constraints lens_temp = self._kwargs_temp['kwargs_lens'] param_class = Param(kwargs_model, kwargs_fixed_lens, kwargs_fixed_source, kwargs_fixed_lens_light, kwargs_fixed_ps, kwargs_fixed_special, kwargs_fixed_extinction, kwargs_lower_lens, kwargs_lower_source, kwargs_lower_lens_light, kwargs_lower_ps, kwargs_lower_special, kwargs_lower_extinction, kwargs_upper_lens, kwargs_upper_source, kwargs_upper_lens_light, kwargs_upper_ps, kwargs_upper_special, kwargs_upper_extinction, kwargs_lens_init=lens_temp, **kwargs_constraints) return param_class
def param_class(self, kwargs_lens): """ :return: instance of the Param class with the recent options and bounds """ kwargs_fixed_lens, kwargs_fixed_source, kwargs_fixed_lens_light, kwargs_fixed_ps, kwargs_fixed_cosmo = self.fixed_kwargs kwargs_lower_lens, kwargs_lower_source, kwargs_lower_lens_light, kwargs_lower_ps, kwargs_lower_cosmo = self.lower_kwargs kwargs_upper_lens, kwargs_upper_source, kwargs_upper_lens_light, kwargs_upper_ps, kwargs_upper_cosmo = self.upper_kwargs kwargs_model = self.kwargs_model kwargs_constraints = self.kwargs_constraints param_class = Param(kwargs_model, kwargs_fixed_lens, kwargs_fixed_source, kwargs_fixed_lens_light, kwargs_fixed_ps, kwargs_fixed_cosmo, kwargs_lower_lens, kwargs_lower_source, kwargs_lower_lens_light, kwargs_lower_ps, kwargs_lower_cosmo, kwargs_upper_lens, kwargs_upper_source, kwargs_upper_lens_light, kwargs_upper_ps, kwargs_upper_cosmo, kwargs_lens_init=kwargs_lens, **kwargs_constraints) return param_class
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'] } kwargs_param = {'num_point_source_list': [2]} 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 = [{}] 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_cosmo=kwargs_fixed_cosmo, **kwargs_param) self.param_class.print_setting()
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 get_param_class(self, lens_name, model_id): """ Get `Param` instance for the lens model. :param lens_name: name of the lens :type lens_name: `str` :param model_id: model run identifier :type model_id: `str` :return: `Param` instance :rtype: `obj` """ self.load_output(lens_name, model_id=model_id) config = ModelConfig(settings=self._model_settings) kwargs_params = config.get_kwargs_params() kwargs_model = config.get_kwargs_model() kwargs_constraints = config.get_kwargs_constraints() param = Param( kwargs_model, kwargs_params['lens_model'][2], kwargs_params['source_model'][2], kwargs_params['lens_light_model'][2], kwargs_params['point_source_model'][2], # kwargs_params['special'][2], # kwargs_params['extinction_model'][2], # kwargs_lens_init=kwargs_result['kwargs_lens'], kwargs_lens_init=kwargs_params['lens_model'][0], **kwargs_constraints) return param
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_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_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_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_special={'D_dt': 1000}) assert param_class.specialParams._D_dt_sampling is True
def test_joint_lens_with_light_dict(self): kwargs_model = { 'lens_model_list': ['SHEAR'], 'lens_light_model_list': ['SERSIC'] } i_light, k_lens = 0, 0 kwargs_constraints = { 'joint_lens_with_light': [[i_light, k_lens, { 'ra_0': 'center_x', 'dec_0': 'center_y' }]] } kwargs_lens = [{'gamma1': 0.05, 'gamma2': 0.06}] kwargs_lens_light = [{ 'amp': 1, 'R_sersic': 1, 'n_sersic': 4, 'center_x': 0.1, 'center_y': 0.3 }] 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'] kwargs_lens_light_out = kwargs_return['kwargs_lens_light'] assert kwargs_lens_out[0]['gamma1'] == kwargs_lens[0]['gamma1'] assert kwargs_lens_out[0]['ra_0'] == kwargs_lens_light[0]['center_x'] assert kwargs_lens_out[0]['dec_0'] == kwargs_lens_light[0]['center_y']
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 test_logsampling(self): kwargs_model = { 'lens_model_list': ['SIS'], 'source_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION'], 'lens_light_model_list': ['SERSIC'] } kwargs_constraints = {'log_sampling_lens': [[0, ['theta_E']]]} kwargs_lens = [{'theta_E': 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 }] 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_out = kwargs_return['kwargs_lens'] assert args[0] == -1 assert kwargs_lens_out[0]['theta_E'] == 0.1
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_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_raise(self): kwargs_model = { 'lens_model_list': ['SIS'], 'source_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION'], 'lens_light_model_list': ['SERSIC'] } kwargs_constraints = { 'log_sampling_lens': [[0, {'theta_E'}]] } # wrong type, dict instead of list with self.assertRaises(TypeError): param = Param(kwargs_model=kwargs_model, **kwargs_constraints)
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 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()
def test_force_positive_source_surface_brightness(self): kwargs_likelihood = { 'force_positive_source_surface_brightness': True, 'numPix_source': 10, 'deltaPix_source': 0.1 } kwargs_model = {'source_light_model_list': ['SERSIC']} kwargs_constraints = {} param_class = Param(kwargs_model, **kwargs_constraints) kwargs_data = sim_util.data_configure_simple(numPix=10, deltaPix=0.1, exposure_time=1, sigma_bkg=0.1) data_class = Data(kwargs_data) kwargs_psf = {'psf_type': 'NONE'} psf_class = PSF(kwargs_psf) kwargs_sersic = { 'amp': -1., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0 } source_model_list = ['SERSIC'] kwargs_source = [kwargs_sersic] source_model_class = LightModel(light_model_list=source_model_list) imageModel = ImageModel(data_class, psf_class, lens_model_class=None, source_model_class=source_model_class) image_sim = sim_util.simulate_simple(imageModel, [], kwargs_source) data_class.update_data(image_sim) likelihood = LikelihoodModule(imSim_class=imageModel, param_class=param_class, **kwargs_likelihood) logL, _ = likelihood.logL(args=param_class.kwargs2args( kwargs_source=kwargs_source)) assert logL <= -10**10
def param_class(self): """ creating instance of lenstronomy Param() class. It uses the keyword arguments in self.kwargs_constraints as __init__() arguments, as well as self.kwargs_model, and the set of kwargs_fixed___, kwargs_lower___, kwargs_upper___ arguments for lens, lens_light, source, point source, extinction and special parameters. :return: instance of the Param class with the recent options and bounds """ kwargs_fixed_lens, kwargs_fixed_source, kwargs_fixed_lens_light, kwargs_fixed_ps, kwargs_fixed_special, kwargs_fixed_extinction = self.fixed_kwargs kwargs_lower_lens, kwargs_lower_source, kwargs_lower_lens_light, kwargs_lower_ps, kwargs_lower_special, kwargs_lower_extinction = self._lower_kwargs kwargs_upper_lens, kwargs_upper_source, kwargs_upper_lens_light, kwargs_upper_ps, kwargs_upper_special, kwargs_upper_extinction = self._upper_kwargs kwargs_model = self.kwargs_model kwargs_constraints = self.kwargs_constraints lens_temp = self._kwargs_temp['kwargs_lens'] param_class = Param(kwargs_model, kwargs_fixed_lens, kwargs_fixed_source, kwargs_fixed_lens_light, kwargs_fixed_ps, kwargs_fixed_special, kwargs_fixed_extinction, kwargs_lower_lens, kwargs_lower_source, kwargs_lower_lens_light, kwargs_lower_ps, kwargs_lower_special, kwargs_lower_extinction, kwargs_upper_lens, kwargs_upper_source, kwargs_upper_lens_light, kwargs_upper_ps, kwargs_upper_special, kwargs_upper_extinction, kwargs_lens_init=lens_temp, **kwargs_constraints) return param_class
def postprocess_mcmc_chain(kwargs_result, samples, kwargs_model, fixed_lens_kwargs, fixed_ps_kwargs, fixed_src_light_kwargs, fixed_special_kwargs, kwargs_constraints, kwargs_fixed_lens_light=None, verbose=False, forward_modeling=False): """Postprocess the MCMC chain for making the chains consistent with the optimized lens model and converting parameters Returns ------- pandas.DataFrame processed MCMC chain, where each row is a sample """ param = Param(kwargs_model, fixed_lens_kwargs, kwargs_fixed_ps=fixed_ps_kwargs, kwargs_fixed_source=fixed_src_light_kwargs, kwargs_fixed_special=fixed_special_kwargs, kwargs_fixed_lens_light=kwargs_fixed_lens_light, kwargs_lens_init=kwargs_result['kwargs_lens'], **kwargs_constraints) if verbose: param.print_setting() n_samples = len(samples) processed = [] for i in range(n_samples): kwargs = {} kwargs_out = param.args2kwargs(samples[i]) kwargs_lens_out, kwargs_special_out, kwargs_ps_out, kwargs_source_out, kwargs_lens_light_out = kwargs_out['kwargs_lens'], kwargs_out['kwargs_special'], kwargs_out['kwargs_ps'], kwargs_out['kwargs_source'], kwargs_out['kwargs_lens_light'] for k, v in kwargs_lens_out[0].items(): kwargs['lens_mass_{:s}'.format(k)] = v for k, v in kwargs_lens_out[1].items(): kwargs['external_shear_{:s}'.format(k)] = v if forward_modeling: for k, v in kwargs_source_out[0].items(): kwargs['src_light_{:s}'.format(k)] = v for k, v in kwargs_lens_light_out[0].items(): kwargs['lens_light_{:s}'.format(k)] = v else: kwargs['src_light_R_sersic'] = kwargs_source_out[0]['R_sersic'] if 'ra_source' in kwargs_ps_out[0]: kwargs['src_light_center_x'] = kwargs_ps_out[0]['ra_source'] - kwargs_lens_out[0]['center_x'] kwargs['src_light_center_y'] = kwargs_ps_out[0]['dec_source'] - kwargs_lens_out[0]['center_y'] for k, v in kwargs_special_out.items(): kwargs[k] = v processed.append(kwargs) processed_df = pd.DataFrame(processed) processed_df = metadata_utils.add_qphi_columns(processed_df) processed_df = metadata_utils.add_gamma_psi_ext_columns(processed_df) return processed_df
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_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_lens_out, kwargs_source_out, kwargs_lens_light_out, kwargs_ps_out, _ = param.args2kwargs( args) assert kwargs_lens_light_out[0]['center_x'] == kwargs_ps_out[0][ 'ra_image']
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)
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)])
def _run_pso(self, n_particles, n_iterations, kwargs_fixed_lens, kwargs_mean_lens, kwargs_sigma_lens, kwargs_fixed_source, kwargs_mean_source, kwargs_sigma_source, kwargs_fixed_lens_light, kwargs_mean_lens_light, kwargs_sigma_lens_light, kwargs_fixed_ps, kwargs_mean_ps, kwargs_sigma_ps, kwargs_fixed_cosmo, kwargs_mean_cosmo, kwargs_sigma_cosmo, threadCount=1, mpi=False, print_key='PSO', sigma_factor=1, compute_bool=None, fix_solver=False): # initialise mcmc classes param_class = Param(self.kwargs_model, self.kwargs_constraints, kwargs_fixed_lens, kwargs_fixed_source, kwargs_fixed_lens_light, kwargs_fixed_ps, kwargs_fixed_cosmo, self._lens_lower, self._source_lower, self._lens_light_lower, self._ps_lower, self._cosmo_lower, self._lens_upper, self._source_upper, self._lens_light_upper, self._ps_upper, self._cosmo_upper, kwargs_lens_init=kwargs_mean_lens, fix_lens_solver=fix_solver) init_pos = param_class.setParams(kwargs_mean_lens, kwargs_mean_source, kwargs_mean_lens_light, kwargs_mean_ps, kwargs_mean_cosmo) sigma_start = param_class.setParams(kwargs_sigma_lens, kwargs_sigma_source, kwargs_sigma_lens_light, kwargs_sigma_ps, kwargs_sigma_cosmo) lowerLimit = np.array(init_pos) - np.array(sigma_start) * sigma_factor upperLimit = np.array(init_pos) + np.array(sigma_start) * sigma_factor num_param, param_list = param_class.num_param() # initialize ImSim() class kwargs_likelihood = copy.deepcopy(self.kwargs_likelihood) if compute_bool is not None: kwargs_likelihood['bands_compute'] = compute_bool imSim_class = class_creator.create_multiband(self.multi_band_list, self.kwargs_model) likelihoodModule = LikelihoodModule( imSim_class=imSim_class, param_class=param_class, kwargs_likelihood=kwargs_likelihood) # run PSO mcmc_class = Sampler(likelihoodModule=likelihoodModule) result, chain = mcmc_class.pso(n_particles, n_iterations, lowerLimit, upperLimit, init_pos=init_pos, threadCount=threadCount, mpi=mpi, print_key=print_key) lens_result, source_result, lens_light_result, ps_result, cosmo_result = param_class.getParams( result, bijective=True) return lens_result, source_result, lens_light_result, ps_result, cosmo_result, chain, param_list
def _mcmc_run(self, n_burn, n_run, walkerRatio, kwargs_fixed_lens, kwargs_mean_lens, kwargs_sigma_lens, kwargs_fixed_source, kwargs_mean_source, kwargs_sigma_source, kwargs_fixed_lens_light, kwargs_mean_lens_light, kwargs_sigma_lens_light, kwargs_fixed_ps, kwargs_mean_ps, kwargs_sigma_ps, kwargs_fixed_cosmo, kwargs_mean_cosmo, kwargs_sigma_cosmo, threadCount=1, mpi=False, init_samples=None, sigma_factor=1, compute_bool=None, fix_solver=False): param_class = Param(self.kwargs_model, self.kwargs_constraints, kwargs_fixed_lens, kwargs_fixed_source, kwargs_fixed_lens_light, kwargs_fixed_ps, kwargs_fixed_cosmo, self._lens_lower, self._source_lower, self._lens_light_lower, self._ps_lower, self._cosmo_lower, self._lens_upper, self._source_upper, self._lens_light_upper, self._ps_upper, self._cosmo_upper, kwargs_lens_init=kwargs_mean_lens, fix_lens_solver=fix_solver) # initialize ImSim() class kwargs_likelihood = copy.deepcopy(self.kwargs_likelihood) if compute_bool is not None: kwargs_likelihood['bands_compute'] = compute_bool imSim_class = class_creator.create_multiband(self.multi_band_list, self.kwargs_model) likelihoodModule = LikelihoodModule( imSim_class=imSim_class, param_class=param_class, kwargs_likelihood=kwargs_likelihood) # run PSO mcmc_class = Sampler(likelihoodModule=likelihoodModule) mean_start = param_class.setParams(kwargs_mean_lens, kwargs_mean_source, kwargs_mean_lens_light, kwargs_mean_ps, kwargs_mean_cosmo) sigma_start = param_class.setParams(kwargs_sigma_lens, kwargs_sigma_source, kwargs_sigma_lens_light, kwargs_sigma_ps, kwargs_sigma_cosmo) num_param, param_list = param_class.num_param() # run MCMC if not init_samples is None: initpos = ReusePositionGenerator(init_samples) else: initpos = None samples, dist = mcmc_class.mcmc_CH(walkerRatio, n_run, n_burn, mean_start, np.array(sigma_start) * sigma_factor, threadCount=threadCount, mpi=mpi, init_pos=initpos) return samples, param_list, dist
def setup(self): self.SimAPI = Simulation() # 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 = self.SimAPI.data_configure(numPix, deltaPix, exp_time, sigma_bkg) data_class = Data(kwargs_data) kwargs_psf = self.SimAPI.psf_configure(psf_type='GAUSSIAN', fwhm=fwhm, kernelsize=11, deltaPix=deltaPix, truncate=3, kernel=None) kwargs_psf = self.SimAPI.psf_configure( 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 = self.SimAPI.simulate(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 = { 'joint_center_lens_light': False, 'joint_center_source_light': False, 'additional_images_list': [False], 'fix_to_point_source_list': [False] * num_source_model, 'image_plane_source_list': [False] * num_source_model, 'solver': False, } 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=kwargs_likelihood) self.sampler = Sampler(likelihoodModule=self.Likelihood)
def test_general_scaling(self): kwargs_model = { 'lens_model_list': ['PJAFFE', 'PJAFFE', 'NFW', 'PJAFFE', 'NFW'] } # Scale Rs for two of the PJAFFEs, and sigma0 for a different set of PJAFFEs # Scale alpha_Rs for the NFWs kwargs_constraints = { 'general_scaling': { 'Rs': [1, False, False, 1, False], 'sigma0': [False, 1, False, 1, False], 'alpha_Rs': [False, False, 1, False, 1], } } # PJAFFE: sigma0, Ra, Rs, center_x, center_y # NFW: Rs, alpha_Rs, center_x, center_y kwargs_fixed_lens = [ { 'Rs': 2.0, 'center_x': 1.0 }, { 'sigma0': 2.0, 'Ra': 2.0, 'Rs': 3.0, 'center_y': 1.5 }, { 'alpha_Rs': 0.1 }, { 'Ra': 0.1, 'center_x': 0, 'center_y': 0 }, { 'Rs': 3, 'center_x': -1, 'center_y': 3 }, ] kwargs_fixed_cosmo = {} param_class = Param(kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_special=kwargs_fixed_cosmo, **kwargs_constraints) kwargs_lens = [{ 'sigma0': 3, 'Ra': 2, 'center_y': 5 }, { 'center_x': 1. }, { 'Rs': 3, 'center_x': 0.0, 'center_y': -1.0 }, { 'sigma0': 3, 'Rs': 1.5 }, { 'alpha_Rs': 4 }] kwargs_source = [] kwargs_lens_light = [] kwargs_ps = [] # Define the scaling and power for each parameter kwargs_cosmo = { 'Rs_scale_factor': [2.0], 'Rs_scale_pow': [1.1], 'sigma0_scale_factor': [3], 'sigma0_scale_pow': [2.0], 'alpha_Rs_scale_factor': [0.3], 'alpha_Rs_scale_pow': [0.5], } args = param_class.kwargs2args(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps, kwargs_special=kwargs_cosmo) num, names = param_class.num_param() print(names) print(args) kwargs_return = param_class.args2kwargs(args) kwargs_lens = kwargs_return['kwargs_lens'] print('kwargs_lens:', kwargs_lens) npt.assert_almost_equal(kwargs_lens[0]['Rs'], 2.0 * 2.0**1.1) npt.assert_almost_equal(kwargs_lens[0]['sigma0'], 3) npt.assert_almost_equal(kwargs_lens[1]['Rs'], 3.0) npt.assert_almost_equal(kwargs_lens[1]['sigma0'], 3.0 * 2.0**2.0) npt.assert_almost_equal(kwargs_lens[2]['alpha_Rs'], 0.3 * 0.1**0.5) npt.assert_almost_equal(kwargs_lens[3]['Rs'], 2.0 * 1.5**1.1) npt.assert_almost_equal(kwargs_lens[3]['sigma0'], 3.0 * 3**2.0) npt.assert_almost_equal(kwargs_lens[4]['alpha_Rs'], 0.3 * 4**0.5) kwargs_return = param_class.args2kwargs(args, bijective=True) kwargs_lens = kwargs_return['kwargs_lens'] npt.assert_almost_equal(kwargs_lens[0]['Rs'], 2.0) npt.assert_almost_equal(kwargs_lens[1]['sigma0'], 2.0) npt.assert_almost_equal(kwargs_lens[2]['alpha_Rs'], 0.1) npt.assert_almost_equal(kwargs_lens[3]['Rs'], 1.5) npt.assert_almost_equal(kwargs_lens[3]['sigma0'], 3) npt.assert_almost_equal(kwargs_lens[4]['alpha_Rs'], 4)
def run(self, algorithm_list=['PSO', 'MCMC'], setting_list=[None, None]): """ Run the fitting. The algorithm_list and setting_list will be pass to 'fitting_kwargs()' """ self.fitting_kwargs(algorithm_list=algorithm_list, setting_list=setting_list) fitting_specify_class = self.fitting_specify_class start_time = time.time() chain_list = self.fitting_seq.fit_sequence(self.fitting_kwargs_list) kwargs_result = self.fitting_seq.best_fit() ps_result = kwargs_result['kwargs_ps'] source_result = kwargs_result['kwargs_lens_light'] if self.fitting_kwargs_list[-1][0] == 'MCMC': self.sampler_type, self.samples_mcmc, self.param_mcmc, self.dist_mcmc = chain_list[ -1] end_time = time.time() print(round(end_time - start_time, 3), 'total time taken for the overall fitting (s)') print( '============ CONGRATULATION, YOUR JOB WAS SUCCESSFUL ================ ' ) from lenstronomy.ImSim.image_linear_solve import ImageLinearFit imageLinearFit = ImageLinearFit( data_class=fitting_specify_class.data_class, psf_class=fitting_specify_class.psf_class, source_model_class=fitting_specify_class.lightModel, point_source_class=fitting_specify_class.pointSource, kwargs_numerics=fitting_specify_class.kwargs_numerics) image_reconstructed, error_map, _, _ = imageLinearFit.image_linear_solve( kwargs_source=source_result, kwargs_ps=ps_result) imageModel = fitting_specify_class.imageModel image_host_list = [ ] #The linear_solver before and after LensModelPlot could have different result for very faint sources. for i in range(len(source_result)): image_host_list.append( imageModel.source_surface_brightness(source_result, de_lensed=True, unconvolved=False, k=i)) image_ps_list = [] for i in range(len(ps_result)): image_ps_list.append(imageModel.point_source(ps_result, k=i)) if self.fitting_kwargs_list[-1][0] == 'MCMC': from lenstronomy.Sampling.parameters import Param try: kwargs_fixed_source = fitting_specify_class.kwargs_params[ 'lens_light_model'][2] except: kwargs_fixed_source = None try: kwargs_fixed_ps = fitting_specify_class.kwargs_params[ 'point_source_model'][2] except: kwargs_fixed_ps = None param = Param(fitting_specify_class.kwargs_model, kwargs_fixed_lens_light=kwargs_fixed_source, kwargs_fixed_ps=kwargs_fixed_ps, **fitting_specify_class.kwargs_constraints) mcmc_flux_list = [] if len(fitting_specify_class.point_source_list) > 0: qso_labels_new = [ "Quasar_{0} flux".format(i) for i in range( len(fitting_specify_class.point_source_list)) ] galaxy_labels_new = [ "Galaxy_{0} flux".format(i) for i in range(len(fitting_specify_class.light_model_list)) ] labels_flux = qso_labels_new + galaxy_labels_new else: labels_flux = [ "Galaxy_{0} flux".format(i) for i in range(len(fitting_specify_class.light_model_list)) ] if len(self.samples_mcmc ) > 10000: #Only save maximum 10000 chain results. trans_steps = [ len(self.samples_mcmc) - 10000, len(self.samples_mcmc) ] else: trans_steps = [0, len(self.samples_mcmc)] print("Start transfering the Params to fluxs...") for i in range(trans_steps[0], trans_steps[1]): kwargs_out = param.args2kwargs(self.samples_mcmc[i]) kwargs_light_source_out = kwargs_out['kwargs_lens_light'] 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_list_quasar = [] if len(fitting_specify_class.point_source_list) > 0: for j in range(len( fitting_specify_class.point_source_list)): image_ps_j = fitting_specify_class.imageModel.point_source( kwargs_ps_out, k=j) flux_list_quasar.append(np.sum(image_ps_j)) flux_list_galaxy = [] for j in range(len(fitting_specify_class.light_model_list)): image_j = fitting_specify_class.imageModel.source_surface_brightness( kwargs_light_source_out, unconvolved=False, k=j) flux_list_galaxy.append(np.sum(image_j)) mcmc_flux_list.append(flux_list_quasar + flux_list_galaxy) if int(i / 1000) > int((i - 1) / 1000): print(trans_steps[1] - trans_steps[0], "MCMC samplers in total, finished translate:", i - trans_steps[0]) self.mcmc_flux_list = np.array(mcmc_flux_list) self.labels_flux = labels_flux self.chain_list = chain_list self.kwargs_result = kwargs_result self.ps_result = ps_result self.source_result = source_result self.imageLinearFit = imageLinearFit self.reduced_Chisq = imageLinearFit.reduced_chi2( image_reconstructed, error_map) self.image_host_list = image_host_list self.image_ps_list = image_ps_list self.translate_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 = [