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()
