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_with_light(self):
kwargs_model = {'lens_model_list': ['CHAMELEON'], 'lens_light_model_list': ['CHAMELEON']}
i_light, k_lens = 0, 0
kwargs_constraints = {'joint_lens_with_light': [[i_light, k_lens, ['w_t', 'w_c', 'center_x', 'center_y', 'e1', 'e2']]]}
kwargs_lens = [{'alpha_1': 10}]
kwargs_lens_light = [{'amp': 1, 'w_t': 0.5, 'w_c': 0.1, 'center_x': 0, 'center_y': 0.3, 'e1': 0.1, 'e2': -0.2}]
param = Param(kwargs_model=kwargs_model, **kwargs_constraints)
args = param.kwargs2args(kwargs_lens=kwargs_lens, kwargs_lens_light=kwargs_lens_light)
kwargs_return = param.args2kwargs(args)
kwargs_lens_out = kwargs_return['kwargs_lens_light']
kwargs_lens_light_out = kwargs_return['kwargs_lens_light']
assert kwargs_lens_out[0]['w_c'] == kwargs_lens_light[0]['w_c']
assert kwargs_lens_light_out[0]['w_c'] == kwargs_lens_light[0]['w_c']
kwargs_model = {'lens_model_list': ['SIS'], 'lens_light_model_list': ['SERSIC']}
i_light, k_lens = 0, 0
kwargs_constraints = {'joint_lens_with_light': [[i_light, k_lens, ['center_x',
'center_y']]]} # list[[i_point_source, k_source, ['param_name1', 'param_name2', ...]], [
kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}]
kwargs_lens_light = [{'amp': 1, 'R_sersic': 0.5, 'n_sersic': 2, 'center_x': 1, 'center_y': 1}]
param = Param(kwargs_model=kwargs_model, **kwargs_constraints)
args = param.kwargs2args(kwargs_lens=kwargs_lens, kwargs_lens_light=kwargs_lens_light)
#kwargs_lens_out, kwargs_source_out, _, kwargs_ps_out, _ = param.args2kwargs(args)
kwargs_return = param.args2kwargs(args)
kwargs_lens_out = kwargs_return['kwargs_lens']
assert kwargs_lens_out[0]['theta_E'] == kwargs_lens[0]['theta_E']
assert kwargs_lens_out[0]['center_x'] == kwargs_lens_light[0]['center_x']
def test_get_cosmo(self):
kwargs_model = {'lens_model_list': ['SPEP'], 'source_light_model_list': ['GAUSSIAN'],
'lens_light_model_list': ['SERSIC'], 'point_source_model_list': ['LENSED_POSITION'],
}
kwargs_param = {'Ddt_sampling': True}
kwargs_fixed_lens = [{'gamma': 1.9}] # for SPEP lens
kwargs_fixed_source = [{'sigma_x': 0.1, 'sigma_y': 0.1, 'center_x': 0.2, 'center_y': 0.2}]
kwargs_fixed_ps = [{'ra_image': [-1, 1], 'dec_image': [-1, 1]}]
kwargs_fixed_lens_light = [{}]
kwargs_fixed_cosmo = {'D_dt': 1000}
param_class = Param(kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_source=kwargs_fixed_source,
kwargs_fixed_lens_light=kwargs_fixed_lens_light, kwargs_fixed_ps=kwargs_fixed_ps,
kwargs_fixed_special=kwargs_fixed_cosmo, **kwargs_param)
kwargs_true_lens = [
{'theta_E': 1., 'gamma': 1.9, 'e1':0.01, 'e2':-0.01, 'center_x': 0., 'center_y': 0.}] # for SPEP lens
kwargs_true_source = [
{'amp': 1 * 2 * np.pi * 0.1 ** 2, 'center_x': 0.2, 'center_y': 0.2, 'sigma_x': 0.1, 'sigma_y': 0.1}]
kwargs_true_lens_light = [{'center_x': -0.06, 'center_y': 0.4, 'phi_G': 4.8,
'q': 0.86, 'n_sersic': 1.7,
'amp': 11.8, 'R_sersic': 0.697, 'phi_G_2': 0}]
kwargs_true_ps = [{'point_amp': [1, 1], 'ra_image': [-1, 1], 'dec_image': [-1, 1]}]
args = param_class.kwargs2args(kwargs_true_lens, kwargs_true_source,
kwargs_lens_light=kwargs_true_lens_light, kwargs_ps=kwargs_true_ps,
kwargs_special={'D_dt': 1000})
assert param_class.specialParams._D_dt_sampling is True
def test_joint_lens_with_light_dict(self):
kwargs_model = {
'lens_model_list': ['SHEAR'],
'lens_light_model_list': ['SERSIC']
}
i_light, k_lens = 0, 0
kwargs_constraints = {
'joint_lens_with_light':
[[i_light, k_lens, {
'ra_0': 'center_x',
'dec_0': 'center_y'
}]]
}
kwargs_lens = [{'gamma1': 0.05, 'gamma2': 0.06}]
kwargs_lens_light = [{
'amp': 1,
'R_sersic': 1,
'n_sersic': 4,
'center_x': 0.1,
'center_y': 0.3
}]
param = Param(kwargs_model=kwargs_model, **kwargs_constraints)
args = param.kwargs2args(kwargs_lens=kwargs_lens,
kwargs_lens_light=kwargs_lens_light)
kwargs_return = param.args2kwargs(args)
kwargs_lens_out = kwargs_return['kwargs_lens']
kwargs_lens_light_out = kwargs_return['kwargs_lens_light']
assert kwargs_lens_out[0]['gamma1'] == kwargs_lens[0]['gamma1']
assert kwargs_lens_out[0]['ra_0'] == kwargs_lens_light[0]['center_x']
assert kwargs_lens_out[0]['dec_0'] == kwargs_lens_light[0]['center_y']
def test_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_force_positive_source_surface_brightness(self):
kwargs_likelihood = {'force_minimum_source_surface_brightness': True}
kwargs_model = {'source_light_model_list': ['SERSIC']}
kwargs_constraints = {}
param_class = Param(kwargs_model, **kwargs_constraints)
kwargs_data = sim_util.data_configure_simple(numPix=10, deltaPix=0.1, exposure_time=1, sigma_bkg=0.1)
data_class = ImageData(**kwargs_data)
kwargs_psf = {'psf_type': 'NONE'}
psf_class = PSF(**kwargs_psf)
kwargs_sersic = {'amp': -1., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0}
source_model_list = ['SERSIC']
kwargs_source = [kwargs_sersic]
source_model_class = LightModel(light_model_list=source_model_list)
imageModel = ImageModel(data_class, psf_class, lens_model_class=None, source_model_class=source_model_class)
image_sim = sim_util.simulate_simple(imageModel, [], kwargs_source)
kwargs_data['image_data'] = image_sim
kwargs_data_joint = {'multi_band_list': [[kwargs_data, kwargs_psf, {}]], 'multi_band_type': 'single-band'}
likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data_joint, kwargs_model=kwargs_model, param_class=param_class, **kwargs_likelihood)
logL, _ = likelihood.logL(args=param_class.kwargs2args(kwargs_source=kwargs_source), verbose=True)
assert logL <= -10**10
def test_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_pixelbased_modelling(self):
ss_source = 2
numPix_source = self.numPix*ss_source
n_scales = 3
kwargs_pixelbased = {
'source_interpolation': 'nearest',
'supersampling_factor_source': ss_source, # supersampling of pixelated source grid
# following choices are to minimize pixel solver runtime (not to get accurate reconstruction!)
'threshold_decrease_type': 'none',
'num_iter_source': 2,
'num_iter_lens': 2,
'num_iter_global': 2,
'num_iter_weights': 2,
}
kwargs_likelihood = {
'image_likelihood': True,
'kwargs_pixelbased': kwargs_pixelbased,
'check_positive_flux': True, # effectively not applied, activated for code coverage purposes
}
kernel = PSF(**self.kwargs_psf).kernel_point_source
kwargs_psf = {'psf_type': 'PIXEL', 'kernel_point_source': kernel}
kwargs_numerics = {'supersampling_factor': 1}
kwargs_data = {'multi_band_list': [[self.kwargs_band, kwargs_psf, kwargs_numerics]]}
kwargs_model = {
'lens_model_list': ['SPEP'],
'lens_light_model_list': ['SLIT_STARLETS'],
'source_light_model_list': ['SLIT_STARLETS'],
}
kwargs_fixed_source = [{'n_scales': n_scales, 'n_pixels': numPix_source**2, 'scale': 1, 'center_x': 0, 'center_y': 0}]
kwargs_fixed_lens_light = [{'n_scales': n_scales, 'n_pixels': self.numPix**2, 'scale': 1, 'center_x': 0, 'center_y': 0}]
kwargs_constraints = {'source_grid_offset': True}
param_class = Param(kwargs_model,
kwargs_fixed_source=kwargs_fixed_source,
kwargs_fixed_lens_light=kwargs_fixed_lens_light,
**kwargs_constraints)
likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data, kwargs_model=kwargs_model,
param_class=param_class, **kwargs_likelihood)
kwargs_source = [{'amp': np.ones(n_scales*numPix_source**2)}]
kwargs_lens_light = [{'amp': np.ones(n_scales*self.numPix**2)}]
kwargs_special = {'delta_x_source_grid': 0, 'delta_y_source_grid': 0}
args = param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=kwargs_source,
kwargs_lens_light=kwargs_lens_light, kwargs_special=kwargs_special)
logL = likelihood.logL(args, verbose=True)
num_data_evaluate = likelihood.num_data
npt.assert_almost_equal(logL/num_data_evaluate, -1/2., decimal=1)
def test_force_positive_source_surface_brightness(self):
kwargs_likelihood = {
'force_positive_source_surface_brightness': True,
'numPix_source': 10,
'deltaPix_source': 0.1
}
kwargs_model = {'source_light_model_list': ['SERSIC']}
kwargs_constraints = {}
param_class = Param(kwargs_model, **kwargs_constraints)
kwargs_data = sim_util.data_configure_simple(numPix=10,
deltaPix=0.1,
exposure_time=1,
sigma_bkg=0.1)
data_class = Data(kwargs_data)
kwargs_psf = {'psf_type': 'NONE'}
psf_class = PSF(kwargs_psf)
kwargs_sersic = {
'amp': -1.,
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}
source_model_list = ['SERSIC']
kwargs_source = [kwargs_sersic]
source_model_class = LightModel(light_model_list=source_model_list)
imageModel = ImageModel(data_class,
psf_class,
lens_model_class=None,
source_model_class=source_model_class)
image_sim = sim_util.simulate_simple(imageModel, [], kwargs_source)
data_class.update_data(image_sim)
likelihood = LikelihoodModule(imSim_class=imageModel,
param_class=param_class,
**kwargs_likelihood)
logL, _ = likelihood.logL(args=param_class.kwargs2args(
kwargs_source=kwargs_source))
assert logL <= -10**10
def test_mass_scaling(self):
kwargs_model = {'lens_model_list': ['SIS', 'NFW', 'NFW', 'SIS', 'SERSIC', 'HERNQUIST']}
kwargs_constraints = {'mass_scaling_list': [False, 1, 1, 1, 1, 1]}
kwargs_fixed_lens = [{}, {'alpha_Rs': 0.1}, {'alpha_Rs': 0.3}, {'theta_E': 0.1},
{'k_eff': 0.3}, {'sigma0': 1}]
kwargs_fixed_cosmo = {}
param_class = Param(kwargs_model, kwargs_fixed_lens=kwargs_fixed_lens, kwargs_fixed_special=kwargs_fixed_cosmo
, **kwargs_constraints)
kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0},
{'alpha_Rs': 0.1, 'Rs': 5, 'center_x': 1., 'center_y': 0},
{'alpha_Rs': 0.1, 'Rs': 5, 'center_x': 0, 'center_y': 1.},
{'theta_E': 0.1, 'center_x': 3, 'center_y': 1.},
{'k_eff': 0.3, 'R_sersic': 1, 'n_sersic': 2, 'center_x': 3, 'center_y': 1.},
{'sigma0': 1, 'Rs': 1, 'center_x': 3, 'center_y': 1.}]
kwargs_source = []
kwargs_lens_light = []
kwargs_ps = []
mass_scale = 2
kwargs_cosmo = {'scale_factor': [mass_scale]}
args = param_class.kwargs2args(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps, kwargs_special=kwargs_cosmo)
assert args[-1] == mass_scale
kwargs_return = param_class.args2kwargs(args)
kwargs_lens = kwargs_return['kwargs_lens']
print(kwargs_lens, 'test')
assert kwargs_lens[0]['theta_E'] == 1
assert kwargs_lens[1]['alpha_Rs'] == 0.1 * mass_scale
assert kwargs_lens[2]['alpha_Rs'] == 0.3 * mass_scale
assert kwargs_lens[3]['theta_E'] == 0.1 * mass_scale
assert kwargs_lens[4]['k_eff'] == 0.3 * mass_scale
assert kwargs_lens[5]['sigma0'] == 1 * mass_scale
kwargs_return = param_class.args2kwargs(args, bijective=True)
kwargs_lens = kwargs_return['kwargs_lens']
assert kwargs_lens[0]['theta_E'] == 1
assert kwargs_lens[1]['alpha_Rs'] == 0.1
assert kwargs_lens[2]['alpha_Rs'] == 0.3
def test_joint_lens_light_with_point_source(self):
kwargs_model = {
'lens_model_list': ['SIS'],
'source_light_model_list': ['SERSIC'],
'point_source_model_list': ['LENSED_POSITION'],
'lens_light_model_list': ['SERSIC']
}
i_lens_light, k_ps = 0, 0
kwargs_constraints = {
'joint_lens_light_with_point_source': [[k_ps, i_lens_light]]
} # list[[i_point_source, k_source, ['param_name1', 'param_name2', ...]], [
kwargs_lens = [{'theta_E': 1, 'center_x': 0, 'center_y': 0}]
kwargs_source = [{
'amp': 1,
'n_sersic': 2,
'R_sersic': 0.3,
'center_x': 1,
'center_y': 1
}]
kwargs_lens_light = [{
'amp': 1,
'n_sersic': 2,
'R_sersic': 0.3,
'center_x': 0.2,
'center_y': 0.2
}]
kwargs_ps = [{'ra_image': [0.5], 'dec_image': [0.5]}]
param = Param(kwargs_model=kwargs_model, **kwargs_constraints)
args = param.kwargs2args(kwargs_lens=kwargs_lens,
kwargs_source=kwargs_source,
kwargs_lens_light=kwargs_lens_light,
kwargs_ps=kwargs_ps)
kwargs_lens_out, kwargs_source_out, kwargs_lens_light_out, kwargs_ps_out, _ = param.args2kwargs(
args)
assert kwargs_lens_light_out[0]['center_x'] == kwargs_ps_out[0][
'ra_image']
def 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)
class TestFittingSequence(object):
"""
test the fitting sequences
"""
def setup(self):
# data specifics
sigma_bkg = 0.05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 10 # cutout pixel size
deltaPix = 0.1 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
# PSF specification
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix,
exp_time, sigma_bkg)
data_class = ImageData(**kwargs_data)
kwargs_psf_gaussian = {
'psf_type': 'GAUSSIAN',
'fwhm': fwhm,
'pixel_size': deltaPix
}
psf = PSF(**kwargs_psf_gaussian)
kwargs_psf = {
'psf_type': 'PIXEL',
'kernel_point_source': psf.kernel_point_source
}
psf_class = PSF(**kwargs_psf)
kwargs_spemd = {
'theta_E': 1.,
'gamma': 1.8,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
lens_model_list = ['SPEP']
self.kwargs_lens = [kwargs_spemd]
lens_model_class = LensModel(lens_model_list=lens_model_list)
kwargs_sersic = {
'amp': 1.,
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
kwargs_sersic_ellipse = {
'amp': 1.,
'R_sersic': .6,
'n_sersic': 3,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
lens_light_model_list = ['SERSIC']
self.kwargs_lens_light = [kwargs_sersic]
lens_light_model_class = LightModel(
light_model_list=lens_light_model_list)
source_model_list = ['SERSIC_ELLIPSE']
self.kwargs_source = [kwargs_sersic_ellipse]
source_model_class = LightModel(light_model_list=source_model_list)
kwargs_numerics = {
'supersampling_factor': 1,
'supersampling_convolution': False,
'compute_mode': 'regular'
}
imageModel = ImageModel(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
kwargs_numerics=kwargs_numerics)
image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens,
self.kwargs_source,
self.kwargs_lens_light)
data_class.update_data(image_sim)
kwargs_data['image_data'] = image_sim
kwargs_data_joint = {
'multi_band_list': [[kwargs_data, kwargs_psf, kwargs_numerics]],
'multi_band_type': 'single-band'
}
self.data_class = data_class
self.psf_class = psf_class
kwargs_model = {
'lens_model_list': lens_model_list,
'source_light_model_list': source_model_list,
'lens_light_model_list': lens_light_model_list,
'fixed_magnification_list': [False],
}
self.kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False}
kwargs_constraints = {
'image_plane_source_list': [False] * len(source_model_list)
}
kwargs_likelihood = {
'source_marg': True,
'position_uncertainty': 0.004,
'check_solver': False,
'solver_tolerance': 0.001,
}
self.param_class = Param(kwargs_model, **kwargs_constraints)
self.Likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data_joint,
kwargs_model=kwargs_model,
param_class=self.param_class,
**kwargs_likelihood)
self.sampler = Sampler(likelihoodModule=self.Likelihood)
def test_pso(self):
n_particles = 2
n_iterations = 2
result, chain = self.sampler.pso(n_particles,
n_iterations,
lower_start=None,
upper_start=None,
threadCount=1,
init_pos=None,
mpi=False,
print_key='PSO')
assert len(result) == 16
def test_mcmc_emcee(self):
n_walkers = 36
n_run = 2
n_burn = 2
mean_start = self.param_class.kwargs2args(
kwargs_lens=self.kwargs_lens,
kwargs_source=self.kwargs_source,
kwargs_lens_light=self.kwargs_lens_light)
sigma_start = np.ones_like(mean_start) * 0.1
samples, dist = self.sampler.mcmc_emcee(n_walkers,
n_run,
n_burn,
mean_start,
sigma_start,
mpi=False)
assert len(samples) == n_walkers * n_run
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()
class TestLikelihoodModule(object):
"""
test the fitting sequences
"""
def setup(self):
np.random.seed(42)
# data specifics
sigma_bkg = 0.05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 50 # cutout pixel size
deltaPix = 0.1 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
kwargs_model = {
'lens_model_list': ['SPEP'],
'lens_light_model_list': ['SERSIC'],
'source_light_model_list': ['SERSIC_ELLIPSE'],
'point_source_model_list': ['SOURCE_POSITION'],
'fixed_magnification_list': [True]
}
# PSF specification
kwargs_band = sim_util.data_configure_simple(numPix, deltaPix,
exp_time, sigma_bkg)
data_class = ImageData(**kwargs_band)
kwargs_psf = {
'psf_type': 'GAUSSIAN',
'fwhm': fwhm,
'pixel_size': deltaPix
}
psf_class = PSF(**kwargs_psf)
print(np.shape(psf_class.kernel_point_source), 'test kernel shape -')
kwargs_spemd = {
'theta_E': 1.,
'gamma': 1.95,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
self.kwargs_lens = [kwargs_spemd]
kwargs_sersic = {
'amp': 1 / 0.05**2.,
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
kwargs_sersic_ellipse = {
'amp': 1.,
'R_sersic': .6,
'n_sersic': 3,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
self.kwargs_lens_light = [kwargs_sersic]
self.kwargs_source = [kwargs_sersic_ellipse]
self.kwargs_ps = [
{
'ra_source': 0.55,
'dec_source': 0.02,
'source_amp': 1.
}
] # quasar point source position in the source plane and intrinsic brightness
self.kwargs_cosmo = {'D_dt': 1000}
kwargs_numerics = {
'supersampling_factor': 1,
'supersampling_convolution': False,
'compute_mode': 'gaussian'
}
lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_class = class_creator.create_class_instances(
**kwargs_model)
imageModel = ImageModel(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
extinction_class,
kwargs_numerics=kwargs_numerics)
image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens,
self.kwargs_source,
self.kwargs_lens_light,
self.kwargs_ps)
ra_pos, dec_pos = imageModel.PointSource.image_position(
kwargs_ps=self.kwargs_ps, kwargs_lens=self.kwargs_lens)
data_class.update_data(image_sim)
kwargs_band['image_data'] = image_sim
self.data_class = data_class
self.psf_class = psf_class
self.kwargs_model = kwargs_model
self.kwargs_numerics = {
'supersampling_factor': 1,
'supersampling_convolution': False
}
kwargs_constraints = {
'num_point_source_list': [4],
'solver_type':
'NONE', # 'PROFILE', 'PROFILE_SHEAR', 'ELLIPSE', 'CENTER'
'Ddt_sampling': True
}
def condition_definition(kwargs_lens,
kwargs_source,
kwargs_lens_light,
kwargs_ps=None,
kwargs_special=None,
kwargs_extinction=None):
logL = 0
if kwargs_lens_light[0]['R_sersic'] > kwargs_source[0]['R_sersic']:
logL -= 10**15
return logL
kwargs_likelihood = {
'force_no_add_image': True,
'source_marg': True,
'astrometric_likelihood': True,
'image_position_uncertainty': 0.004,
'check_matched_source_position': False,
'source_position_tolerance': 0.001,
'source_position_sigma': 0.001,
'check_positive_flux': True,
'flux_ratio_likelihood': True,
'prior_lens': [[0, 'theta_E', 1, 0.1]],
'custom_logL_addition': condition_definition,
'image_position_likelihood': True
}
self.kwargs_data = {
'multi_band_list': [[kwargs_band, kwargs_psf, kwargs_numerics]],
'multi_band_type': 'single-band',
'time_delays_measured': np.ones(4),
'time_delays_uncertainties': np.ones(4),
'flux_ratios': np.ones(4),
'flux_ratio_errors': np.ones(4),
'ra_image_list': ra_pos,
'dec_image_list': dec_pos
}
self.param_class = Param(self.kwargs_model, **kwargs_constraints)
self.imageModel = ImageModel(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
kwargs_numerics=kwargs_numerics)
self.Likelihood = LikelihoodModule(kwargs_data_joint=self.kwargs_data,
kwargs_model=kwargs_model,
param_class=self.param_class,
**kwargs_likelihood)
def test_logL(self):
args = self.param_class.kwargs2args(
kwargs_lens=self.kwargs_lens,
kwargs_source=self.kwargs_source,
kwargs_lens_light=self.kwargs_lens_light,
kwargs_ps=self.kwargs_ps,
kwargs_special=self.kwargs_cosmo)
logL = self.Likelihood.logL(args, verbose=True)
num_data_evaluate = self.Likelihood.num_data
npt.assert_almost_equal(logL / num_data_evaluate, -1 / 2., decimal=1)
def test_time_delay_likelihood(self):
kwargs_likelihood = {
'time_delay_likelihood': True,
}
likelihood = LikelihoodModule(kwargs_data_joint=self.kwargs_data,
kwargs_model=self.kwargs_model,
param_class=self.param_class,
**kwargs_likelihood)
args = self.param_class.kwargs2args(
kwargs_lens=self.kwargs_lens,
kwargs_source=self.kwargs_source,
kwargs_lens_light=self.kwargs_lens_light,
kwargs_ps=self.kwargs_ps,
kwargs_special=self.kwargs_cosmo)
logL = likelihood.logL(args, verbose=True)
npt.assert_almost_equal(logL, -3080.29, decimal=-1)
#def test_solver(self):
# make simulation with point source positions in image plane
# x_pos, y_pos = self.imageModel.PointSource.image_position(self.kwargs_ps, self.kwargs_lens)
# kwargs_ps = [{'ra_image': x_pos[0], 'dec_image': y_pos[0]}]
# kwargs_likelihood = {
# 'source_marg': True,
# 'astrometric_likelihood': True,
# 'position_uncertainty': 0.004,
# 'check_solver': True,
# 'solver_tolerance': 0.001,
# 'check_positive_flux': True,
# 'solver': True
# }
#imageModel = ImageModel(self.data_class, self.psf_class, self.lens_model_class, self.source_model_class,
# self.lens_light_model_class,
# point_source_class, kwargs_numerics=kwargs_numerics)
def test_force_positive_source_surface_brightness(self):
kwargs_likelihood = {'force_minimum_source_surface_brightness': True}
kwargs_model = {'source_light_model_list': ['SERSIC']}
kwargs_constraints = {}
param_class = Param(kwargs_model, **kwargs_constraints)
kwargs_data = sim_util.data_configure_simple(numPix=10,
deltaPix=0.1,
exposure_time=1,
background_rms=0.1)
data_class = ImageData(**kwargs_data)
kwargs_psf = {'psf_type': 'NONE'}
psf_class = PSF(**kwargs_psf)
kwargs_sersic = {
'amp': -1.,
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}
source_model_list = ['SERSIC']
kwargs_source = [kwargs_sersic]
source_model_class = LightModel(light_model_list=source_model_list)
imageModel = ImageModel(data_class,
psf_class,
lens_model_class=None,
source_model_class=source_model_class)
image_sim = sim_util.simulate_simple(imageModel, [], kwargs_source)
kwargs_data['image_data'] = image_sim
kwargs_data_joint = {
'multi_band_list': [[kwargs_data, kwargs_psf, {}]],
'multi_band_type': 'single-band'
}
likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data_joint,
kwargs_model=kwargs_model,
param_class=param_class,
**kwargs_likelihood)
logL = likelihood.logL(
args=param_class.kwargs2args(kwargs_source=kwargs_source),
verbose=True)
assert logL <= -10**10
class TestLikelihoodModule(object):
"""
test the fitting sequences
"""
def setup(self):
np.random.seed(42)
# data specifics
sigma_bkg = 0.05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 50 # cutout pixel size
deltaPix = 0.1 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
kwargs_model = {'lens_model_list': ['SPEP'],
'lens_light_model_list': ['SERSIC'],
'source_light_model_list': ['SERSIC'],
'point_source_model_list': ['SOURCE_POSITION'],
'fixed_magnification_list': [True]}
# PSF specification
kwargs_band = sim_util.data_configure_simple(numPix, deltaPix, exp_time, sigma_bkg)
data_class = ImageData(**kwargs_band)
kwargs_psf = {'psf_type': 'GAUSSIAN', 'fwhm': fwhm, 'pixel_size': deltaPix}
psf_class = PSF(**kwargs_psf)
print(np.shape(psf_class.kernel_point_source), 'test kernel shape -')
kwargs_spep = {'theta_E': 1., 'gamma': 1.95, 'center_x': 0, 'center_y': 0, 'e1': 0.1, 'e2': 0.1}
self.kwargs_lens = [kwargs_spep]
kwargs_sersic = {'amp': 1/0.05**2., 'R_sersic': 0.1, 'n_sersic': 2, 'center_x': 0, 'center_y': 0}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
kwargs_sersic_ellipse = {'amp': 1., 'R_sersic': .6, 'n_sersic': 3, 'center_x': 0, 'center_y': 0}
self.kwargs_lens_light = [kwargs_sersic]
self.kwargs_source = [kwargs_sersic_ellipse]
self.kwargs_ps = [{'ra_source': 0.55, 'dec_source': 0.02,
'source_amp': 1.}] # quasar point source position in the source plane and intrinsic brightness
self.kwargs_cosmo = {'D_dt': 1000}
kwargs_numerics = {'supersampling_factor': 1, 'supersampling_convolution': False}
lens_model_class, source_model_class, lens_light_model_class, point_source_class, extinction_class = class_creator.create_class_instances(**kwargs_model)
imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class,
lens_light_model_class, point_source_class, extinction_class, kwargs_numerics=kwargs_numerics)
image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens, self.kwargs_source,
self.kwargs_lens_light, self.kwargs_ps)
ra_pos, dec_pos = imageModel.PointSource.image_position(kwargs_ps=self.kwargs_ps, kwargs_lens=self.kwargs_lens)
data_class.update_data(image_sim)
kwargs_band['image_data'] = image_sim
self.data_class = data_class
self.psf_class = psf_class
self.kwargs_model = kwargs_model
self.kwargs_numerics = {
'supersampling_factor': 1,
'supersampling_convolution': False}
kwargs_constraints = {
'num_point_source_list': [4],
'solver_type': 'NONE', # 'PROFILE', 'PROFILE_SHEAR', 'ELLIPSE', 'CENTER'
'Ddt_sampling': True
}
def condition_definition(kwargs_lens, kwargs_source, kwargs_lens_light, kwargs_ps=None, kwargs_special=None, kwargs_extinction=None):
logL = 0
if kwargs_lens_light[0]['R_sersic'] > kwargs_source[0]['R_sersic']:
logL -= 10**15
return logL
kwargs_likelihood = {'force_no_add_image': True,
'source_marg': True,
'astrometric_likelihood': True,
'image_position_uncertainty': 0.004,
'check_matched_source_position': False,
'source_position_tolerance': 0.001,
'source_position_sigma': 0.001,
'check_positive_flux': True,
'flux_ratio_likelihood': True,
'prior_lens': [[0, 'theta_E', 1, 0.1]],
'custom_logL_addition': condition_definition,
'image_position_likelihood': True
}
self.kwargs_data = {'multi_band_list': [[kwargs_band, kwargs_psf, kwargs_numerics]], 'multi_band_type': 'single-band',
'time_delays_measured': np.ones(4),
'time_delays_uncertainties': np.ones(4),
'flux_ratios': np.ones(4),
'flux_ratio_errors': np.ones(4),
'ra_image_list': ra_pos,
'dec_image_list': dec_pos
}
self.param_class = Param(self.kwargs_model, **kwargs_constraints)
self.imageModel = ImageModel(data_class, psf_class, lens_model_class, source_model_class,
lens_light_model_class,
point_source_class, kwargs_numerics=kwargs_numerics)
self.Likelihood = LikelihoodModule(kwargs_data_joint=self.kwargs_data, kwargs_model=kwargs_model, param_class=self.param_class, **kwargs_likelihood)
self.kwargs_band = kwargs_band
self.kwargs_psf = kwargs_psf
self.numPix = numPix
def test_logL(self):
args = self.param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source,
kwargs_lens_light=self.kwargs_lens_light, kwargs_ps=self.kwargs_ps, kwargs_special=self.kwargs_cosmo)
logL = self.Likelihood.logL(args, verbose=True)
num_data_evaluate = self.Likelihood.num_data
npt.assert_almost_equal(logL/num_data_evaluate, -1/2., decimal=1)
def test_time_delay_likelihood(self):
kwargs_likelihood = {'time_delay_likelihood': True,
}
likelihood = LikelihoodModule(kwargs_data_joint=self.kwargs_data, kwargs_model=self.kwargs_model, param_class=self.param_class, **kwargs_likelihood)
args = self.param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=self.kwargs_source,
kwargs_lens_light=self.kwargs_lens_light, kwargs_ps=self.kwargs_ps, kwargs_special=self.kwargs_cosmo)
logL = likelihood.logL(args, verbose=True)
npt.assert_almost_equal(logL, -3097.189103539873, decimal=-1)
def test_check_bounds(self):
penalty, bound_hit = self.Likelihood.check_bounds(args=[0, 1], lowerLimit=[1, 0], upperLimit=[2, 2],
verbose=True)
assert bound_hit
def test_pixelbased_modelling(self):
ss_source = 2
numPix_source = self.numPix*ss_source
n_scales = 3
kwargs_pixelbased = {
'source_interpolation': 'nearest',
'supersampling_factor_source': ss_source, # supersampling of pixelated source grid
# following choices are to minimize pixel solver runtime (not to get accurate reconstruction!)
'threshold_decrease_type': 'none',
'num_iter_source': 2,
'num_iter_lens': 2,
'num_iter_global': 2,
'num_iter_weights': 2,
}
kwargs_likelihood = {
'image_likelihood': True,
'kwargs_pixelbased': kwargs_pixelbased,
'check_positive_flux': True, # effectively not applied, activated for code coverage purposes
}
kernel = PSF(**self.kwargs_psf).kernel_point_source
kwargs_psf = {'psf_type': 'PIXEL', 'kernel_point_source': kernel}
kwargs_numerics = {'supersampling_factor': 1}
kwargs_data = {'multi_band_list': [[self.kwargs_band, kwargs_psf, kwargs_numerics]]}
kwargs_model = {
'lens_model_list': ['SPEP'],
'lens_light_model_list': ['SLIT_STARLETS'],
'source_light_model_list': ['SLIT_STARLETS'],
}
kwargs_fixed_source = [{'n_scales': n_scales, 'n_pixels': numPix_source**2, 'scale': 1, 'center_x': 0, 'center_y': 0}]
kwargs_fixed_lens_light = [{'n_scales': n_scales, 'n_pixels': self.numPix**2, 'scale': 1, 'center_x': 0, 'center_y': 0}]
kwargs_constraints = {'source_grid_offset': True}
param_class = Param(kwargs_model,
kwargs_fixed_source=kwargs_fixed_source,
kwargs_fixed_lens_light=kwargs_fixed_lens_light,
**kwargs_constraints)
likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data, kwargs_model=kwargs_model,
param_class=param_class, **kwargs_likelihood)
kwargs_source = [{'amp': np.ones(n_scales*numPix_source**2)}]
kwargs_lens_light = [{'amp': np.ones(n_scales*self.numPix**2)}]
kwargs_special = {'delta_x_source_grid': 0, 'delta_y_source_grid': 0}
args = param_class.kwargs2args(kwargs_lens=self.kwargs_lens, kwargs_source=kwargs_source,
kwargs_lens_light=kwargs_lens_light, kwargs_special=kwargs_special)
logL = likelihood.logL(args, verbose=True)
num_data_evaluate = likelihood.num_data
npt.assert_almost_equal(logL/num_data_evaluate, -1/2., decimal=1)
class TestDynestySampler(object):
"""
test the fitting sequences
"""
def setup(self):
# data specifics
sigma_bkg = 0.05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 10 # cutout pixel size
deltaPix = 0.1 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
# PSF specification
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix,
exp_time, sigma_bkg)
data_class = ImageData(**kwargs_data)
kwargs_psf_gaussian = {
'psf_type': 'GAUSSIAN',
'fwhm': fwhm,
'pixel_size': deltaPix
}
psf = PSF(**kwargs_psf_gaussian)
kwargs_psf = {
'psf_type': 'PIXEL',
'kernel_point_source': psf.kernel_point_source
}
psf_class = PSF(**kwargs_psf)
kwargs_spemd = {
'theta_E': 1.,
'gamma': 1.8,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
lens_model_list = ['SPEP']
self.kwargs_lens = [kwargs_spemd]
lens_model_class = LensModel(lens_model_list=lens_model_list)
kwargs_sersic = {
'amp': 1.,
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
kwargs_sersic_ellipse = {
'amp': 1.,
'R_sersic': .6,
'n_sersic': 3,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
lens_light_model_list = ['SERSIC']
self.kwargs_lens_light = [kwargs_sersic]
lens_light_model_class = LightModel(
light_model_list=lens_light_model_list)
source_model_list = ['SERSIC_ELLIPSE']
self.kwargs_source = [kwargs_sersic_ellipse]
source_model_class = LightModel(light_model_list=source_model_list)
kwargs_numerics = {
'supersampling_factor': 1,
'supersampling_convolution': False,
'compute_mode': 'regular'
}
imageModel = ImageModel(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
kwargs_numerics=kwargs_numerics)
image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens,
self.kwargs_source,
self.kwargs_lens_light)
data_class.update_data(image_sim)
kwargs_data['image_data'] = image_sim
kwargs_data_joint = {
'multi_band_list': [[kwargs_data, kwargs_psf, kwargs_numerics]],
'multi_band_type': 'single-band'
}
self.data_class = data_class
self.psf_class = psf_class
kwargs_model = {
'lens_model_list': lens_model_list,
'source_light_model_list': source_model_list,
'lens_light_model_list': lens_light_model_list,
'fixed_magnification_list': [False],
}
self.kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False}
kwargs_constraints = {
'image_plane_source_list': [False] * len(source_model_list)
}
kwargs_likelihood = {
'source_marg': False,
'position_uncertainty': 0.004,
'check_solver': False,
'solver_tolerance': 0.001,
}
# reduce number of param to sample (for runtime)
kwargs_fixed_lens = [{
'gamma': 1.8,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}]
kwargs_lower_lens = [{'theta_E': 0.8}]
kwargs_upper_lens = [{'theta_E': 1.2}]
kwargs_fixed_source = [{
'R_sersic': 0.6,
'n_sersic': 3,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}]
kwargs_fixed_lens_light = [{
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}]
self.param_class = Param(
kwargs_model,
kwargs_fixed_lens=kwargs_fixed_lens,
kwargs_fixed_source=kwargs_fixed_source,
kwargs_fixed_lens_light=kwargs_fixed_lens_light,
kwargs_lower_lens=kwargs_lower_lens,
kwargs_upper_lens=kwargs_upper_lens,
**kwargs_constraints)
self.Likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data_joint,
kwargs_model=kwargs_model,
param_class=self.param_class,
**kwargs_likelihood)
prior_means = self.param_class.kwargs2args(
kwargs_lens=self.kwargs_lens,
kwargs_source=self.kwargs_source,
kwargs_lens_light=self.kwargs_lens_light)
prior_sigmas = np.ones_like(prior_means) * 0.1
self.sampler = DynestySampler(self.Likelihood,
prior_type='uniform',
prior_means=prior_means,
prior_sigmas=prior_sigmas,
sigma_scale=0.5)
def test_sampler(self):
kwargs_run = {
'dlogz_init': 0.01,
'nlive_init': 4,
'nlive_batch': 4,
'maxbatch': 1,
'wt_kwargs': {
'pfrac': 0.8
},
}
samples, means, logZ, logZ_err, logL, results = self.sampler.run(
kwargs_run)
assert len(means) == 1
def test_sampler_init(self):
try:
sampler = DynestySampler(
self.Likelihood,
prior_type='gaussian',
prior_means=None, # will raise an Error
prior_sigmas=None) # will raise an Error
except Exception as e:
assert isinstance(e, ValueError)
try:
sampler = DynestySampler(self.Likelihood, prior_type='some_type')
except Exception as e:
assert isinstance(e, ValueError)
def test_prior(self):
n_dims = self.sampler.n_dims
cube_low = np.zeros(n_dims)
cube_upp = np.ones(n_dims)
self.prior_type = 'uniform'
cube_low = self.sampler.prior(cube_low)
npt.assert_equal(cube_low, self.sampler.lowers)
cube_upp = self.sampler.prior(cube_upp)
npt.assert_equal(cube_upp, self.sampler.uppers)
cube_mid = 0.5 * np.ones(n_dims)
self.prior_type = 'gaussian'
self.sampler.prior(cube_mid)
cube_gauss = np.array([0.5])
npt.assert_equal(cube_mid, cube_gauss)
def test_log_likelihood(self):
n_dims = self.sampler.n_dims
args = np.nan * np.ones(n_dims)
logL = self.sampler.log_likelihood(args)
npt.assert_almost_equal(logL, -47.167446538898204)
class TestMultiNestSampler(object):
"""
test the fitting sequences
"""
def setup(self):
# data specifics
sigma_bkg = 0.05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 10 # cutout pixel size
deltaPix = 0.1 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
# PSF specification
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix,
exp_time, sigma_bkg)
data_class = ImageData(**kwargs_data)
kwargs_psf_gaussian = {
'psf_type': 'GAUSSIAN',
'fwhm': fwhm,
'pixel_size': deltaPix
}
psf = PSF(**kwargs_psf_gaussian)
kwargs_psf = {
'psf_type': 'PIXEL',
'kernel_point_source': psf.kernel_point_source
}
psf_class = PSF(**kwargs_psf)
kwargs_spemd = {
'theta_E': 1.,
'gamma': 1.8,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
lens_model_list = ['SPEP']
self.kwargs_lens = [kwargs_spemd]
lens_model_class = LensModel(lens_model_list=lens_model_list)
kwargs_sersic = {
'amp': 1.,
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
kwargs_sersic_ellipse = {
'amp': 1.,
'R_sersic': .6,
'n_sersic': 3,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
lens_light_model_list = ['SERSIC']
self.kwargs_lens_light = [kwargs_sersic]
lens_light_model_class = LightModel(
light_model_list=lens_light_model_list)
source_model_list = ['SERSIC_ELLIPSE']
self.kwargs_source = [kwargs_sersic_ellipse]
source_model_class = LightModel(light_model_list=source_model_list)
kwargs_numerics = {
'supersampling_factor': 1,
'supersampling_convolution': False,
'compute_mode': 'regular'
}
imageModel = ImageModel(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
kwargs_numerics=kwargs_numerics)
image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens,
self.kwargs_source,
self.kwargs_lens_light)
data_class.update_data(image_sim)
kwargs_data['image_data'] = image_sim
kwargs_data_joint = {
'multi_band_list': [[kwargs_data, kwargs_psf, kwargs_numerics]],
'multi_band_type': 'single-band'
}
self.data_class = data_class
self.psf_class = psf_class
kwargs_model = {
'lens_model_list': lens_model_list,
'source_light_model_list': source_model_list,
'lens_light_model_list': lens_light_model_list,
'fixed_magnification_list': [False],
}
self.kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False}
kwargs_constraints = {
'image_plane_source_list': [False] * len(source_model_list)
}
kwargs_likelihood = {
'source_marg': False,
'position_uncertainty': 0.004,
'check_solver': False,
'solver_tolerance': 0.001,
}
self.param_class = Param(kwargs_model, **kwargs_constraints)
self.Likelihood = LikelihoodModule(kwargs_data_joint=kwargs_data_joint,
kwargs_model=kwargs_model,
param_class=self.param_class,
**kwargs_likelihood)
prior_means = self.param_class.kwargs2args(
kwargs_lens=self.kwargs_lens,
kwargs_source=self.kwargs_source,
kwargs_lens_light=self.kwargs_lens_light)
prior_sigmas = np.ones_like(prior_means) * 0.1
self.output_dir = 'test_nested_out'
self.sampler = MultiNestSampler(self.Likelihood,
prior_type='uniform',
prior_means=prior_means,
prior_sigmas=prior_sigmas,
output_dir=self.output_dir,
remove_output_dir=True)
def test_sampler(self):
kwargs_run = {
'n_live_points': 10,
'evidence_tolerance': 0.5,
'sampling_efficiency':
0.8, # 1 for posterior-only, 0 for evidence-only
'importance_nested_sampling': False,
'multimodal': True,
'const_efficiency_mode':
False, # reduce sampling_efficiency to 5% when True
}
samples, means, logZ, logZ_err, logL, results = self.sampler.run(
kwargs_run)
assert len(means) == 16
if not pymultinest_installed:
# trivial test when pymultinest is not installed properly
assert np.count_nonzero(samples) == 0
if os.path.exists(self.output_dir):
shutil.rmtree(self.output_dir, ignore_errors=True)
def test_sampler_init(self):
test_dir = 'some_dir'
os.mkdir(test_dir)
sampler = MultiNestSampler(self.Likelihood,
prior_type='uniform',
output_dir=test_dir)
shutil.rmtree(test_dir, ignore_errors=True)
try:
sampler = MultiNestSampler(
self.Likelihood,
prior_type='gaussian',
prior_means=None, # will raise an Error
prior_sigmas=None, # will raise an Error
output_dir=None,
remove_output_dir=True)
except Exception as e:
assert isinstance(e, ValueError)
try:
sampler = MultiNestSampler(self.Likelihood, prior_type='some_type')
except Exception as e:
assert isinstance(e, ValueError)
def test_prior(self):
n_dims = self.sampler.n_dims
cube_low = np.zeros(n_dims)
cube_upp = np.ones(n_dims)
self.prior_type = 'uniform'
self.sampler.prior(cube_low, n_dims, n_dims)
npt.assert_equal(cube_low, self.sampler.lowers)
self.sampler.prior(cube_upp, n_dims, n_dims)
npt.assert_equal(cube_upp, self.sampler.uppers)
cube_mid = 0.5 * np.ones(n_dims)
self.prior_type = 'gaussian'
self.sampler.prior(cube_mid, n_dims, n_dims)
cube_gauss = np.array([
50., 50., 0., 0., 0., 0., 50., 4.25, 0., 0., 0., 0., 50., 4.25, 0.,
0.
])
npt.assert_equal(cube_mid, cube_gauss)
def test_log_likelihood(self):
n_dims = self.sampler.n_dims
args = np.nan * np.ones(n_dims)
logL = self.sampler.log_likelihood(args, n_dims, n_dims)
assert logL < 0
class TestFittingSequence(object):
"""
test the fitting sequences
"""
def setup(self):
np.random.seed(42)
# data specifics
sigma_bkg = 0.05 # background noise per pixel
exp_time = 100 # exposure time (arbitrary units, flux per pixel is in units #photons/exp_time unit)
numPix = 50 # cutout pixel size
deltaPix = 0.1 # pixel size in arcsec (area per pixel = deltaPix**2)
fwhm = 0.5 # full width half max of PSF
# PSF specification
kwargs_data = sim_util.data_configure_simple(numPix, deltaPix,
exp_time, sigma_bkg)
data_class = Data(kwargs_data)
kwargs_psf = sim_util.psf_configure_simple(psf_type='GAUSSIAN',
fwhm=fwhm,
kernelsize=11,
deltaPix=deltaPix,
truncate=3,
kernel=None)
psf_class = PSF(kwargs_psf)
kwargs_spemd = {
'theta_E': 1.,
'gamma': 1.95,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
lens_model_list = ['SPEP']
self.kwargs_lens = [kwargs_spemd]
lens_model_class = LensModel(lens_model_list=lens_model_list)
kwargs_sersic = {
'amp': 1 / 0.05**2.,
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}
# 'SERSIC_ELLIPSE': elliptical Sersic profile
kwargs_sersic_ellipse = {
'amp': 1.,
'R_sersic': .6,
'n_sersic': 3,
'center_x': 0,
'center_y': 0,
'e1': 0.1,
'e2': 0.1
}
lens_light_model_list = ['SERSIC']
self.kwargs_lens_light = [kwargs_sersic]
lens_light_model_class = LightModel(
light_model_list=lens_light_model_list)
source_model_list = ['SERSIC_ELLIPSE']
self.kwargs_source = [kwargs_sersic_ellipse]
source_model_class = LightModel(light_model_list=source_model_list)
self.kwargs_ps = [
{
'ra_source': 0.55,
'dec_source': 0.02,
'source_amp': 1.
}
] # quasar point source position in the source plane and intrinsic brightness
self.kwargs_cosmo = {'D_dt': 1000}
point_source_list = ['SOURCE_POSITION']
point_source_class = PointSource(
point_source_type_list=point_source_list,
fixed_magnification_list=[True])
kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False}
imageModel = ImageModel(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
kwargs_numerics=kwargs_numerics)
image_sim = sim_util.simulate_simple(imageModel, self.kwargs_lens,
self.kwargs_source,
self.kwargs_lens_light,
self.kwargs_ps)
data_class.update_data(image_sim)
self.data_class = data_class
self.psf_class = psf_class
self.kwargs_model = {
'lens_model_list': lens_model_list,
'source_light_model_list': source_model_list,
'lens_light_model_list': lens_light_model_list,
'point_source_model_list': point_source_list,
}
self.kwargs_numerics = {'subgrid_res': 1, 'psf_subgrid': False}
kwargs_constraints = {
'num_point_source_list': [4],
'solver_type':
'NONE', # 'PROFILE', 'PROFILE_SHEAR', 'ELLIPSE', 'CENTER'
'cosmo_type': 'D_dt'
}
kwargs_likelihood = {
'force_no_add_image': True,
'source_marg': True,
'point_source_likelihood': True,
'position_uncertainty': 0.004,
'check_solver': True,
'solver_tolerance': 0.001,
'check_positive_flux': True,
}
self.param_class = Param(self.kwargs_model, **kwargs_constraints)
self.imageModel = ImageModel(data_class,
psf_class,
lens_model_class,
source_model_class,
lens_light_model_class,
point_source_class,
kwargs_numerics=kwargs_numerics)
self.Likelihood = LikelihoodModule(imSim_class=self.imageModel,
param_class=self.param_class,
**kwargs_likelihood)
def test_logL(self):
args = self.param_class.kwargs2args(
kwargs_lens=self.kwargs_lens,
kwargs_source=self.kwargs_source,
kwargs_lens_light=self.kwargs_lens_light,
kwargs_ps=self.kwargs_ps,
kwargs_cosmo=self.kwargs_cosmo)
logL, _ = self.Likelihood.logL(args)
num_data_evaluate = self.Likelihood.imSim.numData_evaluate()
npt.assert_almost_equal(logL / num_data_evaluate, -1 / 2., decimal=1)
def test_time_delay_likelihood(self):
kwargs_likelihood = {
'time_delay_likelihood': True,
'time_delays_measured': np.ones(4),
'time_delays_uncertainties': np.ones(4)
}
likelihood = LikelihoodModule(imSim_class=self.imageModel,
param_class=self.param_class,
**kwargs_likelihood)
args = self.param_class.kwargs2args(
kwargs_lens=self.kwargs_lens,
kwargs_source=self.kwargs_source,
kwargs_lens_light=self.kwargs_lens_light,
kwargs_ps=self.kwargs_ps,
kwargs_cosmo=self.kwargs_cosmo)
logL, _ = likelihood.logL(args)
npt.assert_almost_equal(logL, -3340.79, decimal=-1)
def test_solver(self):
# make simulation with point source positions in image plane
x_pos, y_pos = self.imageModel.PointSource.image_position(
self.kwargs_ps, self.kwargs_lens)
kwargs_ps = [{'ra_image': x_pos[0], 'dec_image': y_pos[0]}]
kwargs_likelihood = {
'source_marg': True,
'point_source_likelihood': True,
'position_uncertainty': 0.004,
'check_solver': True,
'solver_tolerance': 0.001,
'check_positive_flux': True,
'solver': True
}
#imageModel = ImageModel(self.data_class, self.psf_class, self.lens_model_class, self.source_model_class,
# self.lens_light_model_class,
# point_source_class, kwargs_numerics=kwargs_numerics)
def test_force_positive_source_surface_brightness(self):
kwargs_likelihood = {
'force_positive_source_surface_brightness': True,
'numPix_source': 10,
'deltaPix_source': 0.1
}
kwargs_model = {'source_light_model_list': ['SERSIC']}
kwargs_constraints = {}
param_class = Param(kwargs_model, **kwargs_constraints)
kwargs_data = sim_util.data_configure_simple(numPix=10,
deltaPix=0.1,
exposure_time=1,
sigma_bkg=0.1)
data_class = Data(kwargs_data)
kwargs_psf = {'psf_type': 'NONE'}
psf_class = PSF(kwargs_psf)
kwargs_sersic = {
'amp': -1.,
'R_sersic': 0.1,
'n_sersic': 2,
'center_x': 0,
'center_y': 0
}
source_model_list = ['SERSIC']
kwargs_source = [kwargs_sersic]
source_model_class = LightModel(light_model_list=source_model_list)
imageModel = ImageModel(data_class,
psf_class,
lens_model_class=None,
source_model_class=source_model_class)
image_sim = sim_util.simulate_simple(imageModel, [], kwargs_source)
data_class.update_data(image_sim)
likelihood = LikelihoodModule(imSim_class=imageModel,
param_class=param_class,
**kwargs_likelihood)
logL, _ = likelihood.logL(args=param_class.kwargs2args(
kwargs_source=kwargs_source))
assert logL <= -10**10
