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 _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
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'] 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_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_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_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_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()
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 = [ r"$\theta_E$", r"$\gamma$", r"$\phi_{lens}$", r"$q$", r"$D_{dt}$", r"$H_0$" ]
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 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)) 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) print(system) # the data set is z_lens = system_prior["zl"] z_source = 2.0 # multiple images properties ximg = np.zeros(system["nimgs"]) yimg = np.zeros(system["nimgs"]) delay = 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] delay[jj] = system["delay"][jj] #[days] image_amps[jj] = system["mags"][jj] #[linear units or magnitudes] # sort by arrival time index_sort = np.argsort(delay) ximg = ximg[index_sort] yimg = yimg[index_sort] delay = delay[index_sort] image_amps = image_amps[index_sort] d_dt = delay[1:] - delay[0] # measurement uncertainties d_dt_sigma = np.ones(system["nimgs"] - 1) * args["dt_sigma"] 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"] # lens model choices lens_model_list = ["SPEP", "SHEAR"] # first choice: 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, }) # second choice: SHEAR 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}] kwargs_ps_init = fixed_ps # 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, ] 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) * args["astrometry_sigma"], "delta_y_image": np.ones_like(ximg) * args["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": [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", "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": args["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}$", ] D_dt = np.zeros(len(samples_mcmc)) theta_E = np.zeros(len(samples_mcmc)) 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[i] = kwargs_cosmo["D_dt"] gamma[i] = kwargs_lens_out[0]["gamma"] theta_E[i] = kwargs_lens_out[0]['theta_E'] e1[i] = kwargs_lens_out[0]['e1'] e2[i] = kwargs_lens_out[0]['e2'] phi_ext, gamma_ext = lensAnalysis._lensModelExtensions.external_shear( kwargs_lens_out) # 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!) cosmo = FlatLambdaCDM( H0=71, Om0=0.3089, Ob0=0., ) lensCosmo = LensCosmo( cosmo=cosmo, z_lens=z_lens, z_source=z_source, ) gamma = np.mean(gamma) phi_ext = np.mean(phi_ext) gamma_ext = np.mean(gamma_ext) theta_E = np.mean(theta_E) D_dt = np.mean(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["D_dt"].append(lensCosmo.D_dt) with open( "./quasars_%s_nimgs_%s_%s.json" % (args["los"], args["nimgs"], args["version"]), 'w') as fout: json.dump(results, fout)
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)
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()